Am I correct to think the world still lacks a C compiler that can
effectively target a CPU existing on just x100 bytes of Ram?

Just checking ... for a living, I write assembly code for a famously
irregular 8 bit CPU with precisely x100 bytes of Ram available. We
run several interrupts and threads, say six total, each with a stack
of about 8 bytes. With a complete app built I have few/no bytes
leftover free.

So I need, for example, a compiler that doesn't waste resources on
nonsense like frame pointers, like pushing/popping registers in a
subroutine even though the popped value is then never used by any
actual caller, on failing to inline any routine called only once, on
calling rather than jumping to a routine called last, on linking
routines not called, etc. Part of what helps to make such a compiler
feasible is that there is only 64K of Rom total: it's entirely
feasible to examine the complete app during optimisation.

I'm not interested in rewriting All the machine code (except that I am
interested in competent disassembly, another unmet need), but I do
wish I could use the anonymous balanced {} braces of C to express the
control flow of the new code I write, rather than having to use labels
and goto. Structured control would alone be a step forward. Having a
compiler that choose competently from among the bit/byte short/long
maths/jump instructions would be nice too, of course.

The last documented tool survey where I work occurred before the
Internet exploded. So I thought I'd ask. Pointers, anyone?