Black Phoenix's [Temp] Brain Blog

HL-ZASM compiler is much different from old ZASM2 used with the ZCPU. One major difference is that it doesn’t parse the source code twice to compile it, but instead it splits the compile process into the following steps:

1. Preprocess stage – the code is preprocessed, all source comments are removed, all macros are satisfied (even the #include macro now works). This also strips all the line breaks, although it retains information on character positions in the source file.
2. Parse stage – the source code is parsed, and the code tree is generated. Code tree is similar to the one in HybriC, it shows how expressions should be compiled, and all the statements, expressions, opcodes to be included in the final program.
3. Tree optimize stage – at this stage code tree is optimized by known patterns, before moving on to next stage
4. Generate stage – this stage will conver the code tree into actual opcodes, although not resolving the constant values yet (constant values like jump offsets, function pointers, etc)
5. Optimize stage – the intermediate generated code is optimized for known patterns
6. Resolve stage – all the constant values, function pointers, label pointers, etc are resolved at this stage
7. Binary stage – at this stage intermediate code is converted into ZCPU binary. It will be then written to the processor itself

It is possible to generate commented assembly listing for every program in two different ways – before labels/constant values are resolved, and after. For example this is before they are resolved:

gvar:
     0 alloc 1
// gfunc()
gfunc:
     1 enter 2
// ptr = &lvar
     4 mov EAX,SS:ESP
     7 add EAX,1
    10 sstack EBP:2,EAX
// lvar = &gvar+15
    14 sstack EBP:1,&gvar+15
    19 leave

And this is after the constant values are resolved:

gvar:
     0 alloc 1
// gfunc()
gfunc:
     1 enter 2
// ptr = &lvar
     4 mov EAX,SS:ESP
     7 add EAX,1
    10 sstack EBP:2,EAX
// lvar = &gvar+15
    14 sstack EBP:1,15
    19 leave

Both source code listings will compile (when stripped of the offsets column though), but the first one is slightly more descriptive.

I’m planning a large ZCPU update (ZCPU is the processor in Wire addon for Garry’s Mod). This will be a perfomance update (new virtual machine and client-side compiler will make things much more faster and smooth), feature update (new compiler and processor features), and there will even be a new entity (the sound processor).

There are several parts of this update. First there is the new ZCPU virtual machine, which now compiles ZCPU bytecode into blocks of Lua code, which makes everything run much much faster. It will compile up to 8 instructions into single block of instructions executed at once, although branching opcodes may make these blocks smaller.

There are few new ZCPU features, for example introduction of the page table, which allows one to quickly switch page permission and mapping data, and quickly setting them up. Page table is a table which holds all the settings for all the pages in RAM (pages which will be out of this table will use default settings, which can be also specified).

There’s also a new feature which allows to trap page access, which means an interrupt will be generated every time you attempt to access a certain memory location. This also allows user to override result of the memory operation, and create all sorts of interesting programming solutions.

The new compiler adds proper C language support, although it’s not exactly same as a usual C compiler (it does not require a linker, since it’s based on an assembler), it has the same syntax. And you can still use the old ZASM syntax, all the old programs will still compile.

There is a plan of a new entity called the sound processor, which will be a sound equivalent of the GPU. It’s a programmable entity which can play back sound, change pitch, volume, etc. You can easily program a sequencer to play some MIDI-like music with it, it will come with a small bank of music samples (optional for download, but part of wiremod).