Mainly fixed up the compiler today. There was an issue with nested array references. The compiler was not loading the value from the inner array to use as an index.

This showed up in the following code, pgtbl indexed by a value from pte array.


The compiler was rebuilt for both Qupls and Riscv, but operation of the Riscv version is unknown.

Latest Bug Fixes
The compiler was using the wrong overloaded function to output numeric values. This resulted in the numeric values being truncated for 64-bit values (the upper bits were removed).

Bugs are being pretty ornery lately, taking me time to fix. There is currently a bug in stack allocation for arrays declared locally. Not enough stack space is allocated, it is close but not enough.
The latest bug fix was for array indexing. It looks like it should work at least for up to three dimensional arrays. The maximum number of array dimensions is nine. The following test program is used to test arrays.



The following code is generated. Notice the stack allocation is 77160, but according to the size of the arrays it should be over 96000. (20*30*40)*4 array = 96000.

Got the array size bug fixed. Processing array indexes in the parser needed to be improved.

Now adding support for Qupls40, which has only 16 GPRs. If the compiler runs out of temporaries it starts using callee saved regs.

Took a side trip trying to fix an issue where indexing was generating both a multiply and scaled indexed addressing. The index was scaled during the memory op, but also multiplied by the size. Only one or the other should be done. I had to back out changes, then reload and start over.

Latest change:
- moving link registers to and from a general purpose register so that it can be saved and restored on the stack.
- the link registers are not part of the general purpose array. They generally do not need arithmetic or logical ops performed on them.
- having them separate from the GPRs effectively makes another GPR register available for use.
- this is like the PowerPC.

Switching to using longer mnemonics for assembly language. “load” instead of “ld” and that sort of thing. It is a little easier to read the longer mnemonics and the assembler code is seldom read.

Added constant optimization of branches to the compiler. If two constants are being compared for a branch condition, then either an unconditional branch is output or no branch is output. Unconditional branches are faster than conditional ones because they are performed earlier in the pipeline. So, smaller and faster code results if constants are being compared. This happens fairly often at the start of loops with loop inversion. For the first iteration the value of the loop counter is known.

Improved the type coercion for expressions, still needs a lot of work though. Unless specifically indicated otherwise, the largest type between the two in the operation is returned. Ran into an old ‘I’ll get to it later’ bug. Constants indicated as unsigned with the ‘U’ appended to them were simply treated as signed constants, the unsigned indicator was ignored. For most constants this does not make much difference. But when shifting an unsigned value by a signed value, the wrong shift ended up being used.

The compiler croaked parsing a character string definition like:

It thought it was some sort of weird aggregate type when all that is needed is to concatenate all the string information.

It was just a little bit more code to fix it up. Made a couple of other minor fixes too.

Upgraded the arpl compiler for the StarkCPU (Qupls3) to select predicate branches instead of ordinary conditional branches if the number of lines of code branched over is small ( < 7). It does this during peephole optimization.

Also disabled inlining of code for the StarkCPU. The ‘leave’ instruction needs to be adapted to support inline code. Inline code does not get much mileage in the StarkCPU, so it is simply disabled.

Found a bug in the compiler, assignments of constants to registers when the register is actually a pointer did not work. The compiler spit out a load instruction when it should have spit out a store instruction.