Graal VS llvm-project

How does it compare to graal wasm? https://github.com/oracle/graal/blob/master/wasm/README.md/

Java was created by James Gosling and released by Sun Microsystems in 1995. It was designed with the principle of "Write Once, Run Anywhere" (WORA), enabling cross-platform compatibility through the Java Virtual Machine (JVM). Over the years, Java became a leading language for enterprise applications, Android development, and large-scale backend systems. Oracle now maintains Java, with modern innovations such as Project Loom and GraalVM enhancing its performance.

Sorry, I know you weren't asking me, but for this same use case, yes, I've used a GHA build matrix with each OS/arch pair.

Cosmo/APE support would fix this, and GraalVM already ships with a Musl libc implementation, so it isn't very far off.

https://github.com/oracle/graal/issues/8350

It wasn’t long before I ran into several other blog posts about developers successfully using GraalVM and frameworks such as Quarkus to address this very problem. And so I’ve decided to try it out for myself.

GraalVM adds an advanced just-in-time (JIT) optimizing compiler, which is written in Java, to the HotSpot Java Virtual Machine.

You can trim down the runtime[1] but the tooling around doing this is non-existent / unreliable. Alternatively, you can generate native binaries with GraalVM[2] which comes with its own baggage (license, slow compile time, etc).

[1]: https://docs.oracle.com/javase/8/embedded/develop-apps-platf...

[2]: https://www.graalvm.org/

Too bad it looks stuck since about a month ago (https://github.com/oracle/graal/issues/8350#issuecomment-210...), needs some attention from @jart.

Really now? Now that's interesting. I thought GraalVM might be a good option in that space https://www.graalvm.org/ last I checked, but something literally called Hermetic Java has my interest piqued.

LLD has a new option "--randomize-section-padding" for this purpose: https://github.com/llvm/llvm-project/pull/117653

Github issue:

https://github.com/llvm/llvm-project/issues/127365

The article is right: it is almost never a compiler bug. I have had that experience of reporting and being wrong. It sucks.

On the other hand, I have a confirmed bug in Cland [1] and a non-rejected bug in GCC [2], so it does happen.

[1]: https://github.com/llvm/llvm-project/issues/61133

[2]: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108448

Have been is the right word.

This thread keeps having its goal posts moved around, first is was an example, then got the spotlight of being only about clang, then I pointed out about Apple/Google original purposes, then it was something else, and yet another one.

Just head off to /r/cpp that is where hunches are coming from.

Have you at very least filtered by C++ clang only related contributions instead of LLVM ones?

Most likely not, only clicked here https://github.com/llvm/llvm-project/graphs/contributors and came right away to reply.

I'm excited about -fbounds-safety coming soon: https://github.com/llvm/llvm-project/commit/64360899c76c

okay can you at least tell me how the architecture of https://github.com/llvm/llvm-project is "bad"?

https://github.com/llvm/llvm-project/blob/main/clang/docs/Bo...

Incidentally, this automatic branch-if-zero from LLVM is being improved.

First of all, a recent LLVM patch apparently changes codegen to use CMOV instead of a branch:

https://github.com/llvm/llvm-project/pull/102885

Beyond that, Intel recently updated their manual to retroactively define the behavior of BSR/BSF on zero inputs: it leaves the destination register unmodified. This matches the AMD manual, and I suspect it matches the behavior of all existing x86-64 processors (but that will need to be tested, I guess).

If so, you don't need either a branch or CMOV. Just set the register to 32 and then run BSR. If the value is zero, then BSR leaves the register unmodified and you get 32.

Since this behavior is now guaranteed for future x86-64 processors, and assuming it is indeed compatible with all existing x86-64 processors, LLVM will no longer need the old path regardless of what it's compiling for.

Note that if you're targeting a newer x86-64 version, LLVM will just emit TZCNT, which just does what you'd expect and returns 32 if the input is zero (or 64 for a 64-bit TZCNT). But as the blog post demonstrates, many people still build for baseline x86_64.

(Intel does document one discrepancy between processors: "On some older processors, use of a 32-bit operand size may clear the upper 32 bits of a 64-bit destination while leaving the lower 32 bits unmodified.")