Notes on Translating Three-Address Code to Assembly Code for the X86

Notes on the X86 Architecture

General Information

Assembly code files should end with the suffix ".s". Such files can be assembled to executable code by invoking the C compiler:

% cc -o foo foo.s

Memory Alignment

Registers and Register Windows

There are also 6 segment registers, used in memory address operations, a flags register, and an instruction pointer.

The Stack

X86 Stack Frame

Code Generation

Identifiers

Assembler Directives

 .comm  x,4,4

.globl x
.data
	.align 4
	.type	 x,@object
	.size	 x,4
x:
	.long 5

.comm id, n, m

C code				 assembler directive
int x, a[5]; 			.comm		x,4,4
				.comm		a,20,4
char y;				.comm		y,1,1

Code should all be generated in the "text" segment (.text).
Before starting a portion of code for a function foo, generate
 .align 4
 .global foo
 .type foo,@function
foo:


Code and data can be intermixed, by switching segments back and forth.
The code section's end should be marked with a label and a .size
directive.

.Lfe1:
	.size	 main,.Lfe1-main



Parameters

Parameters all occupy space on the stack and are generally pushed from
back to front; the first four parameters can, if they fit into 32 bits,
passed in registers instead.  Data smaller than 4 bytes is passed in a
4 byte position on the stack; data larger than 4 bytes per parameter
is longword aligned.


Accessing an actual parameter from within the called function consists
of accessing a register (e.g. %eax) or
loading memory k(%ebp), where k is 8 + the offset of the parameter
(8 + 4 * i for parameter i, if all parameters are passed as 4 bytes).

Size Conversions

On a CISC architecture there are 8- and 16-bit versions of many of the
instructions.
The instruction ``movsbl src, reg'' loads and converts the source byte
in memory into a 32-bit register value.


A corresponding instruction, "movb i, %al" followed by
"movb %al,c" stores the low byte of
a 32-bit value i into a single byte of memory c, accomplishing the
conversion in the other direection.

Translating Assignment Statements

Note: for simplicity, the operations below are all translated in terms
of 32-bit operands.  For character operations a "b" is appended to
the instruction; any C language mixed-type arithmetic should result in
explicit size conversions per the preceding section.


Most of these operands are using temporary registers, usually the %o
registers.

Global operands

Global values have addresses computed as constants at compile times;
such 32-bit values are loaded into a register




x := y + z 
 movl y,%eax 

            movl z,%edx 

            leal (%edx,%eax),%ecx 

	    movl %ecx,x (if x is a global) 




Local operands

If in memory, locals and temporaries are accessed by displacing off of
%ebp with progressively smaller numbers, e.g. starting with -4(%ebp),
-8(%ebp), and so forth. y, and z in the code below are constant offsets
(such as -4) the compiler computes and defines for a given local.
Some locals may already be in registers and require no load instructions.




x := y + z 
 movl y(%ebp), %eax 

            movl z(%ebp), reg2 

            leal (%edx, %eax),%ecx 

            movl %ecx,x (or mark %ecx as holding x)



Translating Jumps

A label is simply an identifier.  They can be stored as integers in
intermediate code, and written out prefixed by ".L".  Goto's are simply
"branch always" instructions.   Pipelining causes branches to be expensive.




goto L 
 ba L 


if x op y goto L 
 movl x,%eax 

                  cmpl y(%ebp),%eax 

                  jcc .Ln 





where cc is a condition code, one of






e 
 equal 


ne 
 not equal 


l 
 less than 


le 
 less than or equal 


ge 
 greater than or equal 


g 
 greater





Arrays

Global Arrays

The value of the ith element x[i] of global array x, whose elements
are n bytes wide, is read or written by adding an offset to the base
address.  For constant indices things are simple, for example
x[2] is written as x+8.  To do array subscriping with a variable index,
one multiplies the index by the element size and adds it to the base
address.  If the element size is 2, 4, or 8, an addressing mode is
available to multiply it directly as part of the address calculation.




 addr a    
 movl $a,%edx


 x[i] = y   
 movl i,%edx 

            leal 0(,%edx,4),%eax 

	    movl $x,%edx
            movl y,%esi
            movl %esi,(%eax,%edx)


Local Arrays

Computing the address of a local array is done by adding an offset to
the frame pointer.

Procedures

Entering a Procedure

On entering a procedure, the first instructions generally save
the old frame pointer register %ebp, and then set the new %ebp
to the current top of stack.  The stack pointer is then decremented
by the amount of local variable space needed in the procedure.

  pushl %ebp
  movl %esp,%ebp
  subl $n,%esp


where n is the space need by the stack frame, computed as 4
+ space for locals and temporaries --- typically some number like 48.


Calling a Procedure

First, the parameters are pushed, from right to left, onto the stack.
After parameters, a call
instruction does the actual call.  For a call such as
f(c, i) the code is:




param i   
 movl i,%eax 

           pushl %eax 

	   movl c,%eax 

           pushl %eax 

           call f


Return From a Procedure

On the X86, the return value is stored in %eax.  Function exit is
kind of complicated; it must have a leave instruction followed by
a ret instruction, and the leave instruction must be aligned specially,
so there is a .p2align pseudoinstruction. A label is included; if
several return statements occur within a single function body, each
will set the %eax and then jump to a single exit code.




return 
 ret 

        restore 


return x 
 movl x,%eax 

          jmp .L2 

          .p2align 4,,7 

          .L2: 

           leave 

           ret