Stop using registers for computation

[aceinetx]

Right now this code:

int num(){
        return 2+2*2;
}

int main(){
        return num() + (num()-1);
}

Compiles to this (no constant folding, qproc backend)

num:
movi r0 2
movi r1 2
movi r2 2
mul r1 r2
add r0 r1
pop ip
main:
call num
call num
movi r0 1
sub r0 r0
add r0 r0
pop ip

This is just wrong and doesn't work as expected, I think we should use push/pop to compute values, something like this

num:
push 2
push 2
push 2
pop r1
pop r0
mul r0 r1
push r0
pop r1
pop r0
add r0 r1
; mov r0 r0 optimized out
pop ip
main:
call num
push r0
call num
push r0
push 1
pop r1
pop r0
sub r0 r1
push r0
pop r1
pop r0
add r0 r1
; mov r0 r0 optimized out
pop ip

This is larger, we can probably make some optimizations to it later, but it eliminates the need for register allocation, and works as expected

[HyperWinX]

I wouldnt agree. Registers have higher priority than stack - each stack operation takes more cycles than using a register. When running on more complex code, register allocator should be smart enough to count references for each variable, and determine whether to use registers, or not. Are there any specific reasons why you want to store everything on stack?

[aceinetx]

I wouldnt agree. Registers have higher priority than stack - each stack operation takes more cycles than using a register. When running on more complex code, register allocator should be smart enough to count references for each variable, and determine whether to use registers, or not. Are there any specific reasons why you want to store everything on stack?

You may be right, but there are some problems that we would need to solve before implementing anything like that

• 1. Computations across functions can use the same registers

Take this code:

int f(){
return 2+2;
}
int main(){
return f() + f();
}

This would be compiled to something like that:

f:
mov x0, 2;
mov x1, 2;
add x0, x1;
ret;
main:
call f;
mov x0, x1;
call f;
add x0, x1;
ret;

As you can see, f modifies x0 and x1 registers. The compiler doesn't know that - what if f is an external function? How do we know which registers f modifies? Without knowing this, the result might be wrong.
One solution to this problem might be pushing and poping the registers on the ir level, compile a function and then go back to it's declaration and push/pop the used registers:

f:
push x0;
push x1;
mov x0, 2;
mov x1, 2;
add x0, x1;
pop x1;
pop x0;
ret;

• 2. We can run out of registers

If we have a big expression like this:

int main(){
return 2+2*2*2+5+(5+2)+3+10+2;
}

It will use more registers than the currently supported backends provide. Of course, this can be easily optimized, but if we were to call functions, which can't be optimized, the problem stays, currently, I have no idea how can we fix this.

If we can fix these problems, we will switch to using registers no questions asked

[HyperWinX]

As you can see, f modifies x0 and x1 registers. The compiler doesn't know that - what if f is an external function? How do we know which registers f modifies? Without knowing this, the result might be wrong.
One solution to this problem might be pushing and poping the registers on the ir level, compile a function and then go back to it's declaration and push/pop the used registers:

You should check how GCC/Clang handle this. Pretty sure, that ABI gives some guarantees in that case.

Yes. GCC/Clang both push whatever values they need to save onto the stack before calling a function that can use registers with these values.