llvm-project

It seems like someone did: https://github.com/llvm/llvm-project/issues/96971. However the performance implications of this was not well explored there

Maybe LLVM doesn't have time for performance improvements due to still reading through 30000 open issues, which also include miscompilations leading to incorrect results at runtime? For example, my bug report that `+= 2` is broken has not been acknowledged (read?) by anyone for 3 years: const size_t n = 13; // triggers the issue #pragma omp parallel for for (uint32_t i = 0; i < n; i += 2) { // counts PAST 13! https://github.com/llvm/llvm-project/issues/70687

Well, let me google that for you. https://github.com/llvm/llvm-project/pulls?q=is%3Apr+state%3... https://github.com/llvm/llvm-project/pulls?q=is%3Apr+state%3... https://github.com/llvm/llvm-project/pulls?q=is%3Apr+state%3...

Here's two big ones to start. But I have a feeling that an arbitrarily large list won't change your mind. https://github.com/llvm/llvm-project https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/lin...

As one example, LLVM still routinely does dumb stuff like this: https://github.com/llvm/llvm-project/issues/53348 Regarding ABI, calee-saved registers also often result in useless data shuffling and prevent the compiler from using them for argument/result passing.

In my personal opinion, the fix[1] for that issue clearly implicates C-style habits polluting a C++ code base. No right-thinking knower of C++ initializes objects with memset! Also I believe that -Wall would have flagged that, and I know for certain that cppcoreguidelines-init-variables + cppcoreguidelines-pro-type-member-init would have flagged it. 1: https://github.com/llvm/llvm-project/commit/905a88b923433eb8...

That vminpd+vminpd+vorpd actually does handle signed zero properly! Screws up NaN payloads to the max though. Can be easily extended to canonicalize the NaN with 2 instrs + constant though of course. (which ends up at the same number of instrs as your proper impl (albeit with worse port distribution and latency), but you get to have a canonical NaN!) Hit upon https://github.com/llvm/llvm-project/issues/217376 while playing around with proper minimumnum, failing to SMT-verify whatever version of LLVM I had; did find a funky working 6-instr (+ constant) version though: vpandn ymm2, ymm1, ymm0 vpcmpeqd ymm2, ymm2, 0x80000000 # whether ymm0 is -0 and ymm1 is +0 (or other cases that magically don't cause issues) vcmpltpd ymm3, ymm0, ymm1 vcmpunordpd ymm3, ymm3, ymm1 # regular NaN-is-larger ymm0<ymm1 vpor y

Parent is right. Use of uninitialized memory is UB, and incidentally, the type of UB that the C standard is not working to define, but is relying on sanitizers to find in source programs, since it is considered always a bug. This entire thread has a lot of "no security issues have ever been found in my code, and I test a lot. Therefore no bugs will ever exist in my code and we're all safe." To see you doing this in an explicitly security-conscious setting is distressing. If anything, I see assertions like this and juxtaposed with blatant, willful misunderstanding of how C and C compilers work and it does the opposite of inspiring confidence. Look at CVE-2009-1897; this is the classic example of how C compilers are happy to try to optimize code in the face of UB and lead to worse problems. > If the above code has any but one of the above 1

The loop dependency on a poly isn't all that hard for compilers to unroll, and most correctly rounded implementations are polys. You're often paying only a couple cycles' worth of stalls. We can see this in action. LLVM implements sin() with a correctly rounded double poly [0]. Let's ignore range reduction and throw the core into compiler explorer to be autovectorized [1]. uiCA estimates a theoretical latency for the inner loop of 15 cycles, and the code achieves 18. I suspect most custom implementations would do worse than this. [0] https://github.com/llvm/llvm-project/blob/165c472d65cd62eb33... [1] https://godbolt.org/z/rGGq8aG38

>In a production-grade compiler like LLVM they are rare enough that it compiles giant projects like Linux and Chromium without detectable issues. https://github.com/llvm/llvm-project/issues Yea, sure, but there's waay more than Linux or Chromium

there's been some forward movement on doing this via an appropriate intrinsic in LLVM https://github.com/llvm/llvm-project/pull/166702 note that this isn't the only "trick" needed for constant-time programming though. Indexing an array with a secret index needs its own trick, for example. I agree that trying to trick the compiler is very ugly. A well-known applied cryptographer has a paper from last year saying that not only is it ugly, but it doesn't work particularly well, and if anything the trendline of the various "tricks" is that they get less effective over time. https://eprint.iacr.org/2025/435

I filed the bug: https://github.com/llvm/llvm-project/issues/204883

Not sure if it's a stated goal somewhere official but there's been plenty of fixes of the years moving stuff to be deterministic, e.g https://github.com/llvm/llvm-project/commit/cdbde3aacc1260a7... The internal programming guide also says which collections to use for deterministic iteration order: https://llvm.org/docs/ProgrammersManual.html#llvm-adt-setvec... So definitely a bug here.

cvise. Here is a link to a mini tutorial I wrote for a user in an LLVM issue: https://github.com/llvm/llvm-project/issues/108827#issuecomm...

https://github.com/llvm/llvm-project/issues/45725 Are you familiar with pointer provenance ? This gets very deep, very fast, so if you don't know and don't want to know I can't help you, but if you do want to know try maybe: https://www.ralfj.de/blog/2018/07/24/pointers-and-bytes.html So e.g. if we make a pointer to thing A, which we then destroy, and then for a pointer to thing B, and then we compare these pointers, even if the address which will be the only bits making up this pointer in hardware was identical, a language could choose to say these pointers are not the same (Rust says they compare equal but that's up to Rust). LLVM is equipped to do this optimisation. So far, not a bug, though perhaps not what you expected... However everybody is pretty sure that we don't want provenance for other value types. It's troublesome for pointe