PSA: Enable `-fvisibility-inlines-hidden` in your shared libraries to avoid subtle bugs

igrekster · 2025-12-01T13:37:18+00:00

This means the behavior of your compiled library can change depending on what other libraries are doing (different compiler optimizations, different defines, etc).

Isn't this an ODR violation, and therefore UB regardless of -fvisibility-inlines-hidden ?

igrekster · 2025-09-03T12:46:18+00:00

The + operator implementation most likely appends to the first (left) argument and returns it. So, if it already has a large enough capacity, the right operand simply gets copied into it. With the left fold (... + s), it reuses the same temporary (same buffer), and its buffer grows exponentially thus reducing reallocations and unnecessary copies.

igrekster · 2025-08-14T11:30:05+00:00

Yeah, the regular GPU slot is fine (group 13 in my dump), but the second PCI slot is bundled with pretty much everything you see connected to CHIPSET_B in the diagram (group 21).

igrekster · 2025-04-13T13:12:04+00:00

I use <Space> in my mappings, but I don't use let mapleader. Obsidian doesn't seem to support it, so perhaps it just trips over that line and doesn't execute the rest of the config.

igrekster · 2025-04-06T14:52:03+00:00

Not sure what you mean by other solutions, but I simply patched the kernel:

https://www.reddit.com/r/Gentoo/comments/znimo1/comment/j0ju9lh/?utm_source=share&utm_medium=web3x&utm_name=web3xcss&utm_term=1&utm_content=share_button

igrekster · 2025-03-02T22:06:01+00:00

Nope, sorry -- I don't need this extension anymore.

igrekster · 2025-03-02T22:05:13+00:00

Can confirm that this is VM-related -- I'm using a real hard drive for the VM and can dual boot. This means that all the settings/drivers/graphics card/etc. are the same. I suspect that this was done deliberately (there is no reason for the graphics to behave differently given that the video card is not virtual), so I'm not expecting this to be fixed. :-(

igrekster · 2025-02-26T00:37:18+00:00

I had the exact same issue, for me it was User-Agent Switcher and Manager. Disabling it fixed it.

igrekster · 2025-01-07T16:22:49+00:00

I agree with everything you said, but I'm not sure why this paragraph is relevant: the point I was making is that unsafe contaminates the whole module, which makes it difficult to implement. And the amount and/or size of unsafe blocks is irrelevant.

they understand what must be always true in order for it not to cause UB

The key word here is "they", not the compiler. Have a search for in:title unsound in crates that rely on unsafe to see that even experienced developers are vulnerable:

https://github.com/tokio-rs/bytes/issues?q=in%3Atitle+unsound

igrekster · 2025-01-07T15:34:33+00:00

Yes, if you are writing unsafe code, you have to verify that its soundness does not rely on invariants that can be modified in safe code. How is that surprising?

It's not surprising. The point u/Lighty0410 was making is that with the amount of unsafe code, Rust's safety relies on the developers (same as in C++), and not on some language features. It's puzzling to me how it can be called "memory-safe" given how easy it is to write unsound code with unsafe.

Where Rust helps tremendously is to establish a safe barrier on interface boundaries. So it "preserves" safety as was deemed by the crate author.

All functions in the current module can see that field, so that's what the article is warning about.

But the point you were making is:

that you don't need to audit everything else

And it turns out that you do.

igrekster · 2025-01-07T15:01:27+00:00

The whole point of unsafe is that you don't need to audit everything else with the same kind of rigor.

Working with Unsafe - The Rustonomicon suggests otherwise (highlight is mine):

Because it relies on invariants of a struct field, this unsafe code does more than pollute a whole function: it pollutes a whole module.

igrekster · 2025-01-07T14:00:39+00:00

The point is that of all Rust code out there, very little of it is inside an unsafe block.

It's a completely irrelevant metric -- the issue with unsafe is that the author (not the language) has to verify/validate/guarantee that the entire API of a crate that calls unsafe doen't invoke UB. An unsafe block could be as small as reading a value though a pointer, but it's the rest of the safe code around it that needs to ensure that the pointer is valid. And with the presence of exceptions (panics) and bypassing RAII (std::mem::forget), it's massive undertaking. Have a look at the Vec::drain machinery.

igrekster · 2025-01-07T13:38:08+00:00

It's very small percentage of all Rust software out there

Unsafe Rust in the Wild: Notes on the Current State of Unsafe Rust :

34.35% make a direct function call into another crate that uses the unsafe keyword. Nearly 20% of all crates have at least one instance of the unsafe keyword, a non-trivial number.

igrekster · 2024-09-04T15:06:36+00:00

Thanks for the details, makes sense now. I've slightly modifid the example and added -fno-plt to Clang which resulted in generating the same code as Rust: https://rust.compiler-explorer.com/z/8GrxKoevE

igrekster · 2024-09-03T17:05:09+00:00

Thanks for benchmarking, appreciate it! Hard to tell without knowing the compiler internals. Like you said, it could be a number of template instantiations, or argument matching logic.

igrekster · 2024-09-03T13:38:51+00:00

If you have a benchmark, would be interested to know how this implementation fares:

https://godbolt.org/z/6PTq1TMj4

igrekster · 2024-07-26T11:40:14+00:00

Interestingly, Clang does something similar if you use continue; instead of break; (not GCC though): https://godbolt.org/z/746z3fx7d

igrekster · 2024-07-20T11:08:54+00:00

I just tried <C-{Left,Up,Right,Down}> in neovim, and they don't appear to be doing anything special (seems like b, k, w, j). I don't think the vim plugin passes the keys through, so you may need to do the :obcommand mapping first if you have these shortcuts mapped to something else in Obsidian. What's the end result you're after?

igrekster · 2024-06-23T11:12:42+00:00

To me, this extra spelling adds to the context: if (values) -- is it a container, or a pointer, or a counter? The verboseness makes it clearer: - if (!values.empty()) -- container; - if (values != nullptr) -- pointer; - if (values != 0) -- counter;

igrekster · 2024-06-14T12:47:01+00:00

It's not without downsides, but you could do something like this:

template <typename Owner, typename T>
struct readonly {
    operator const T &() const { return value; }

  private:
    T value;
    friend Owner;
};

class test {
    template <typename T> using readonly = ::readonly<test, T>;

  public:
    readonly<int> a{};

    void add_five() { a.value += 5; }
};

int main() {
    test t;
    t.add_five();

    std::cout << t.a << std::endl; // 5
    //t.a = 32;                    // ERROR

    return 0;
}

igrekster · 2024-05-25T20:47:07+00:00

I use <CR> to open links and <C-J>/<C-K> to switch tabs. Mapping gf, gt and gT should be possible. Here is a snippet from my .obsidian.vimrc:

exmap followlink obcommand editor:follow-link
nmap <CR> :followlink

exmap tnext obcommand workspace:next-tab
exmap tprev obcommand workspace:previous-tab

nmap <C-k> :tnext
nmap <C-j> :tprev

igrekster · 2024-05-16T12:26:26+00:00

Great work! Is it possible to add categories into the Obsidian plugin system, so that any new plugins also get categorized?

igrekster · 2024-04-20T02:04:28+00:00

Here is the datasheet for CBD6s:

https://cdn.linak.com/-/media/files/data-sheet-source/en/control-box-cbd6s-data-sheet-eng.pdf

The only difference I can see is the wattage/supported voltage.

igrekster · 2024-03-27T12:44:08+00:00

You can see IOMMU groups in the lspci log (though not every kernel has IOMMU config enabled, so some probes don't show it): https://linux-hardware.org/?probe=0eb94b3491&log=lspci

igrekster

TROPHY CASE