Clang

Yes.

Now, you can, of course, use the GNU versions of those compilers, but it's very common to use Clang.

Clang is the CLang compiler that's part of LLVM.

So many people are using Clang, and they don't even realize that they're using part of LLVM.

Right.

TinyGo is just another LLVM language, which means, of course, that we get, I don't know how many millions maybe of human hours working on this really seriously industrial-strength framework for writing compilers.

I'm really sorry, that's the worst piece of direction anyone's ever given or something like that.

But, you know, if I may name drop Clang...

Sir John Hurt said to me, I said, you know, I hope you don't mind that I mess around a bit in studio and try and make jokes and have a bit of a laugh.

And he said, no, no.

And this is the way the specification says a compiler is allowed to operate.

So we actually tried to look at that in this research to understand, you know, is a certain compiler more susceptible to these problems than other compilers? Should we use Clang instead of GCC or something like that? And the answer was, it's not just one compiler responsible.

Every single compiler will do these kinds of transformations.

And that's actually expected.

The, the group of developers behind the low-level virtual machine, which is also the thing behind...

Well, the LLVM shows up and runs a lot of different things, but the, the, the Clang or Clang compiler being one of the big ones, uh, and some other things.

And they are talking about agents.md, and because of dumb reasons, you also have to have a claude.md. Um, come on, Anthropic, get with it.

Let Claude look at agents.md.

Yeah.

If you type in Clang and Fly, it's like the first thing that shows up.

Oh, go search Clang and Fly.

Come on.

And then like us.

And a few years before, a guy called DeLeslie Hutchins had added thread safety annotations to GCC.

And then he was working on the migration to Clang, to CLang and LLVM.

And so ART was the first thing building an Android which was using CLang because we wanted these thread safety annotations.

And what we were using thread safety annotations primarily for was to say, this C++ thread is accessing the Java heap.

We're seeing hardware giants like AMD raising the bar for performance.

AMD's compiler team working with LLVM Clang have introduced a new compiler flag called -fenable-readonly-dhp.

This mouthful of an option enables something called instruction transparent huge pages at both compile and link time.

But what does that mean for us? Basically, it allows programs to use larger memory pages, specifically two megabytes ones instead of smaller, more fragmented chunks.