Code generation scheme for RCMA

Transcription

1 Code generation scheme for RCMA Axel Simon July 5th, Revised Specification of the R-CMa We detail what constitutes the Register C-Machine (R-CMa ) and its operations in turn We then detail how the different constructs of C are translated 11 The Principle of the R-CMa The R-CMa consists of a code segment, and a unified memory area containing the stack and heap In addition, the R-CMa has two infinite sets of registers, namely: local registers, denoted R 1, R 2, R i,, and global registers, denote R 0, R 1, R j, C S 0 1 PC 0 SP R loc R 1 R glob R 0 R 6 R 4 The local registers are used to keep the contents of function-local variables, for intermediate results during the evaluation of non-trivial expressions and as a backup for parameter variables 1

2 The global registers are used to store parameters that are passed to a function We assume that the calling convention is that all registers are caller-saved, that is, every function must backup its parameters (that are passed in global registers) before calling any other function As a consequence, the global registers are all dead while the body of a function is executing Only when a call is made are they set to pass the arguments to the callee After the call returns, the global register R 0 contains the result Since passing parameters and returning function results is all that global registers are used for, the term global is a bit misleading More accurate names for local and global registers would be intra-procedural and inter-procedural registers, but these names are a bit of mouth full, so we stick to local and global In order to relate variables with memory cells in S and with the two register files, we use the address map ρ : Var {G, L, RG, RL} N which maps each variable to a tag in {G, L, RG, RL} and a number Specifically: ρ x = G, a indicates that x is stored at the address a ρ x = L, a indicates that x is stored at the address F P + a ρ x = RG, a indicates that x is stored in the global register R a (note that a 0 in this case) ρ x = RL, a indicates that x is stored in the local register R a (note that a > 0 in this case) In principle, the location of a variable may change, depending on the current location of the P C, for example, a global variable might be temporarily stored in a local register However, such optimization is not done by the translation presented here Given the address environment ρ, we specify the translation of C statements and expressions using the following three functions: code i s ρ: generate code for the statement s code i R e ρ: generate code that writes the r-value of expression e into R i code i L e ρ: generate code that writes the l-value of expression e into R i Note: During the translation of code, we retain the invariant that all registers with indices j < i are occupied (or, at least, cannot be trivially reused) and that all registers k i are dead Thus, the functions above cannot be called with any i but with the index such that the above invariant holds 2

3 12 Instruction set of the R-CMa We defined the following binary arithmetic instructions We follow the Intel convention of first giving the result register, then the argument registers add R i R j R k sub R i R j R k div R i R j R k mul R i R j R k mod R i R j R k R i R j + R k R i R j R k R i R j /R k R i R j R k R i sgn(r k )k where R j = n R k + k n 0, 0 k < R k le R i R j R k R i if R j < R k then 1 else 0 gr R i R j R k R i if R j > R k then 1 else 0 eq R i R j R k R i if R j = R k then 1 else 0 leq R i R j R k R i if R j R k then 1 else 0 geq R i R j R k R i if R j R k then 1 else 0 and R i R j R k R i R j & R k // bit-wise and or R i R j R k R i R j R k // bit-wise or In addition to the binary operation, we define the following two unary operations: not R i R j R k R i if R j = 0 then 1 else 0 neg R i R j R k R i R j We define the following instructions to load values from the store instruction semantics intuition load R i R j R i S[R j ] load a value from an address loadc R i c R i c load a constant loadrc R i c R i F P + c load a constant relative to FP loada R i c R i S[c] load a global variable loadr R i c R i S[F P + c] load a local variable The instructions for storing values in memory defined as follows We mention the move instruction here to avoid confusion with the move instruction of the original C-Machine where it was only used to copy whole structure For the R-CMa we overload this instruction to also copy the value from one register to another 3

4 instruction semantics intuition store R i R j S[R i ] R j store the value R j at address R i storea c R i S[c] R i write global variable storer c R i S[F P + c] R i write local variable move R i R j R i R j copy a register move k R j [S[SP + i] S[R j + i]] k 1 i=0 copy k values onto the stack SP SP + k In order to implement the control flow of a program, we define the following branch instructions: instruction semantics intuition jump A P C A jump to address A jumpz R i A if R i = 0 then P C A jump if R i = 0 jumpi R i A P C A + R i jump indirectly In order to implement function calls, the corresponding setup of the stack frame and the passing of parameters, we define the following instructions: instruction semantics intuition saveloc R a R b [S[SP + i] R a+i ] (b a) i=0 back registers R a, R b SP SP + (1 + b a) note: if b < a this is a no-op restoreloc R a R b SP SP (1 + b a) restore registers R a, R b [R a+i S[SP + i]] 0 i=(b a) note: if b < a this is a no-op call R i S[SP ] P C; SP SP + 1; P C R i ; F P SP call function at address R i In case parameters must be passed on the stack or if registers need to be spilled onto the stack, we defined the following instructions: instruction semantics intuition push R i S[SP ] R i ; SP SP + 1 push the register R i pop R i R i S[SP ]; SP SP 1 pop into register R i pop k SP SP k pop k values off the stack 4

5 13 Code Generation for the R-CMa 131 Expressions and Assignments Expressions containing binary operators are translated as follows: code i R e 1 op e 2 ρ = code i R e 1 ρ code i+1 R e 2 ρ op R i R i R i+1 This function could be specialized to check if one or both arguments are registers and, in that case, to simply use that register rather than to generate code that stores the value of that register into R i resp R i+1 This optimization already saves a lot of move instructions This optimization also applies to unary operations which, in general, are translated as follows: code i R op e ρ = codei R e ρ op R i R i The value and address of a variable are translated as follows: loada R i a if ρ x = G, a code i R x ρ = loadr R i a if ρ x = L, a move R i R j if ρ x = r, j r {RG, RL} code i L x ρ = { loadc Ri a if ρ x = G, a loadrc R i a if ρ x = L, a Note that the latter function is undefined for a register since a register has no l-value The fact that a register has no l-value manifests itself in the translation of an assignment statement, which is, in general, defined as follows: code i R e 1 = e 2 ρ = code i R e 2 ρ code i+1 L e 1 ρ store R i+1 R i In case the left-hand-side is a register, we need to apply the following special case: 5

6 code i R x = e 2 ρ = code i R e 2 ρ move R j R i Note that the assignment above is an expression In general, an assignment can be derived as a statement, so we have to define: code i e 1 = e 2 ρ = code i R e 1 = e 2 ρ However, this is a special case of the following translation: code i e ρ = code i R e ρ Note here that the result of calculating e is ignored In the translation of the C-Machine we had a pop instruction here to explicitly ignore the result Here, the register R i which holds the result is simply dead in the following code 132 Pointer and Pointer Arithmetic Pointers and pointer arithmetic can be translated using the following definitions: creation of pointers: code i R &e ρ = code i L e ρ reading from a pointer: code i R e ρ = code i L e ρ load R i R i writing to a pointer: code i L e ρ = code i R e ρ 6

7 133 Translation of Control-Flow Translation of if ( c ) tt else ee is as follows: code i if(c) tt else ee ρ = code i R c ρ jumpz R i A code i tt ρ jump B A : code i ee ρ B : The translation of loops is as follows: code i while(e) s ρ = A : code i R e ρ jumpz R i B code i s ρ jump A B : code i for(e 1 ; e 2 ; e 3 ) s ρ = code i R e 1 ρ A : code i R e 2 ρ jumpz R i B code i s ρ code i R e 3 ρ jump A B : A switch statement with a sequence of cases that use consecutive constants, ie: 7

8 switch (e) { case c 0 : s 0 ; break ; } case c k 1 : s k 1 ; break ; d e f a u l t : s ; break ; with c i + 1 = c i+1 for i = [0, k 1] is translated into a body code i s ρ = code i R e ρ check i c 0 c k 1 B A 0 : code i s 0 ρ jump D A k 1 : code i s k 1 ρ jump D a jump table B : jump A 0 C : jump A k 1 and the range-check macro which is defined as follows: check i l u B = loadc R i+1 l geq R i+2 R i R i+1 jumpz R i+2 E sub R i R i R i+1 loadc R i+1 k E : D : geq R i+2 R i R i+1 jumpz R i+2 D loadc R i k jumpi R i B 8

9 134 Function Calls and Return Function calls are translated by evaluating each argument and assigning it to a global register R i Since the arguments may contain other function calls (and indeed the function g may be an expression containing function calls), the global registers can only be set once all arguments and g are evaluated Before the actual call, all local registers that are in use at this point (except for R i ) are backed up onto the stack The registers R i R i+n are not saved since they are not needed after the function call returns Upon the return of the function the saved registers are restored and the result of the function, which is in R 0, is written to R i which is the register into which the result of the function call is to be saved code i R g(e 1, e n ) ρ = code i R g ρ code i+1 R code i+n R e 1 ρ e n ρ move R 1 R i+1 move R n R i+n saveloc R 1 R i 1 mark call R i restoreloc R 1 R i 1 move R i R 0 Note: If additional parameters have to be a passed on the stack (for instance structs) they need to be pushed on the stack using push R i for basic types and move k R i for C structs A return statement is translated as follows: code i return e ρ = code i R e ρ move R 0 R i return In case the function returns no value, the following translation suffices: code i return ρ = return 9

10 135 Whole Functions and Programs A complete function is translated as follows: code 1 R t r f(args){decls ss} ρ = enter q move R l+1 R 1 move R l+n R n code l+n+1 ss ρ return Here, the value q denotes the maximum stack space used by the function If no local variables are stored on the stack and no arguments to functions are ever passed on the stack, then q = 3 which allows for storing the special registers F P, EP and P C Note that a function is always translated so that the first available register is R 1, that is, no register is used so far We assumed that the local variables of the function extend ρ to ρ and take up l local registers, namely R 1, R l The move instructions save all parameters R 1, R n to the function in local registers R l+1, R l+n This ensures that other functions within this function can be called without worrying about the global registers In case the translated function is a leaf function, the global registers do not have to be saved The translation of the body of the function may therefore use temporary registers starting from l + n + 1 The return statement may be omitted if the function returns a value and does so correctly on all of the paths through the function A program P = F 1 ; F n must contain the function F i at address _f i and a single main function at address _main It can be translated as follows: code 1 P ρ = enter (k + 3) alloc k loadc R 1 _main mark _f 1 : _f n : call R 1 halt code 1 F 1 ρ code 1 F n ρ 10

11 Here, k denotes the size of the global variables which are assumed to be all allocated on the stack In principle, it would be possible to allocated global variables in k local registers, but this would require that each function is translated using code k R rather than code1 R We omitted this possibility since global variables normally reside in memory Keeping global variables in registers would make the independent translation of different modules difficult since it is not clear what k is nor is it possible to determine within a single module if the address of a global variable has been taken anywhere in the program (in which case it must reside in memory) Note that the only live local register at the point of the call is R 1 However, this register contains the address of _main which is not needed after the call Thus, no local register needs to be saved and the saveloc and restoreloc instructions can be omitted 11