Most of the time I've used inline assembly it's because the compiler was optimizing something badly. I don't want it to rearrange anything.

(Scheduling is almost useless on modern desktop CPUs anyway, except for some instruction fusion patterns.)

Raw multi-line R"()" strings in C++ reduce some of the tedium. I wrote myself an Emacs tree sitter pattern to highlight asm syntax nicer than a string normally would, which helps. There is also the stasm library (which I haven't used) that looks like a pleasant syntax. https://github.com/stasinek/stasm

Clang (but not GCC) also supports the MSVC assembly syntax which is derived from Borland inline assembly. Unlike MSVC, Clang supports it in 64-bit mode and also for arm.

I haven't used CodeWarrior for PowerPC, but that approach sounds like it requires the C compiler to understand the assembler instructions you are using. Is it? But most use cases of inline assembler I've seen these days is for using instructions that the compiler will not emit.

Yes, but just because the C compiler doesn't emit them, that doesn't mean it can't understand them. If there are already tables for the assembler, specifying acceptable addressing modes and encodings, those can probably be reused - though that might require the designers to think of the toolchain as a cohesive whole. I don't think would automatically be a bad thing.

+1, ^5, ditto and Amen for CodeWarrior and its inline asm. CW was way ahead of its time in terms of UX. Its C++ compiler was well above average too, particularly in terms of codegen (although all C++ compilers were effectively broken in that era.)

The only thing that held it back was the lack of scripting. It was probably a rebound rejection of the MPW days, when everything was script-based (and with a crazy custom language.) I remember thinking that the design team probably didn't want to open that Pandora's box, lest scripting might lazily become required and spoil the UX.

Unfortunately, this made CW unsuited to the advent of CI. Even then, I still think it was stupid for Apple not to acquire Metrowerks. The first 5-10 years of Xcode versions had a worse UX and way worse codegen.

Sometimes you genuinely know better than the compiler. Not often, but sometimes.

I'm an embedded developer and recently for work I had to do inline assembly. The function was there or four lines of C, two nested for loops. The runtime cost of the C is 200-300 cycles.

I rewrote the function in assembly using features particular to my CPU and brought the runtime cost to 90 cycles with no loops.

In this application, the 60% runtime reduction was worth the week it took to engineer.