Re: transpiling to low level C

On 16/12/2024 07:02, BGB wrote:

On 12/15/2024 5:22 PM, Thiago Adams wrote:

Em 12/15/2024 7:22 PM, Lawrence D'Oliveiro escreveu:

On Sun, 15 Dec 2024 07:44:34 -0300, Thiago Adams wrote:
>

I also think LLVM is too big.

>
How about QBE, then <https://c9x.me/compile/>.

>
QBE is just for linux and it does not generate code directly. C is everywhere.
But I am reading QBE docs to see what is necessary in a IL.
>

 I agree that both LLVM and GCC are too big.

I've just been working on a new backend which can be shared between different projects. It can be built into a standalone library, which has a size from 70KB to 180KB (x64 target), depending on output options. (30K of that is my language's std library.)
The 70KB product interprets only. The full one can also generate EXE/DLL/OBJ files, my private MX format, ASM source, IL source (when code has been generated via its API), or it can run programs directly as native code (when not interpreting the IL!).
It's several magnitudes smaller in scale than LLVM, and can be compiled from source in 0.06 seconds:
   c:\px>tm mm6 -opt pcl -dll
   Compiling pcl.m to pcl.dll
   TM: 0.06
   c:\px>dir pcl.dll
   16/12/2024  11:38           175,616 pcl.dll

I am not sure the minimum size of a usable C compiler, my current estimate is probably somewhere in the area of 50-100 kLOC.
 My current compiler is a bit bigger than this, and my own past attempt to implement a C compiler in under 30k lines had failed.

Mine, for quite a large subset (that can compile Lua and sqlite3 for example), is between 180KB and 290KB. That's roughly 20 to 30Kloc, assuming that one line of code maps to approx 10 bytes of x64 code.
The 18KB version is to interpret only; the 290K is 'fully loaded' (see above). But usually my C standard headers are embedded, adding 40KB. (I no longer embed windows.h; that's a massive 600KB.
But, people write all sorts of much smaller C compilers, obviously with some compromises. The smallest I remember is one fitting into a 512-byte boot-loader.

If I were to estimate a feature set for a 3AC IL:
   Basic UNARY and BINARY operators;
     Also COMPARE and similar;
   Load and Store Index operators;
     With support for an immediate index;
   GOTO
   IF-GOTO
   CALL (with a list of argument variables and a target variable).

The IL I mentioned above isn't that small. There are about 150 instructions. Probably half could be dispensed with (eg. 'MIN/MAX' ops, or in-place MUL), but then the functionality needs to be provided by other means. And as I showed, the resulting backend isn't that huge.
It uses a stack-model, and IL code looks ugly. I'd also developed a 3AC IL that looked gorgeous, like a mini-HLL, but that was just too hard to work with, even though such a model is similar to SSA which is very popular.