MIPS GNU Assembler Code Generator

The MIPS code generator generates assembly code for use with the GNU assembler.

Calling Convention

The first four arguments are passed in the registers $4 through $7. Any additional arguments are passed on the stack, starting at $sp + 16. Words $sp through $sp + 12 will be available for the called function to use. $sp will always be a multiple of 8.

The return address for the called function is passed in $31.

When performing a position-independent call, the address of the called function is passed in $25.

The called function will store its return value in $2.

The called function is required to preserve the values of registers $16 through $23 and register $30.

This calling convention is compatible with the System V ELF ABI.

Call Frames

Call frames have the following layout:

When a function is called, it receives a stack frame that looks like the following:

  :
  old frame
  argn
  :
  arg4
  empty3
  empty2
  empty1
  empty0    <-- $sp points here

The function prologue of functions generated by this code generator creates activation frames that look as follows:

: old frame argn : arg4 arg3 arg2 arg1 arg0 return address pointer to Global Offset Table local0 : local7 local8 : localn padding <— $sp points here

In words:

The four empty slots provided by the caller are used to store arguments 0 through 3 (originally passed in $4 through $7), if necessary.

The stack frame created below the four slots provided by the caller contains the following data, in order:

Saved return address (originally passed in $31), if necessary.
Saved pointer to global offset table (computed from $25), if necessary.
Saved values of caller‘s locals 0 through 7 (originally in $16 through $23), if necessary.
Values of our locals > 8, if necessary.
Padding to align $sp on a multiple of 8, if necessary.

In accordance with the System V ELF ABI for MIPS, the pointer to the global offset table is calculated as follows:

$gp = _gp_disp + $25

where $gp is the register to store the pointer, $25 is the register holding the address of the called function, and _gp_disp is the offset between the beginning of the function and the global offset table.

Methods

align arg_offset arg_reference arg_register assymetric_binop? at_expr? begin_block begin_function binop? byte call common_if count_locals create_frame emit_function_prologue end_block end_function end_if eval_binop eval_expr export function get_byte get_word global? goto ifelse ifeq ifge ifgt ifle iflt ifne import integer? label let load_at load_value load_value_into_register local_offset local_reference local_register max_locals new number_of_stack_arguments register_arg? register_local? ret set set_byte set_word string symbol? symmetric_binop? tail_call word write

Public Class methods

new(params)

Public Instance methods

align(alignment = nil)

arg_offset(n)

Return the offset from $sp at which the nth (0-based) argument is stored.

arg_reference(n)

Return an $sp-relative reference for the nth (0-based) argument

arg_register(n)

Return the register in which the nth (0-based) argument is stored, or nil if not stored in a register

assymetric_binop?(op)

Test if op is a binary operation

at_expr?(value)

Test if a value is an at-expression

begin_block(*code)

Begins a new block.

begin_function(formals, nlocals)

Emit function prologue and declare formals as function arguments

binop?(op)

Test if op is a binary operation

byte(value)

Define a byte with the given value

call(func, *args)

Call a function.

common_if(comp, x, y = nil)

Start a conditional using the specified branch instruction after the comparison.

count_locals(statements)

Counts the number of local variables created in a sequence of statements.

create_frame(nlocals)

Creates an activation frame which can store nlocals local variables

emit_function_prologue(formals = [], nlocals = 0)

Emit function prologue.

end_block()

Ends the current block.

end_function()

End a function body

end_if()

End a conditional.

eval_binop(expr, register)

Evaluate the binary operation expr and store the result in register

eval_expr(expr, register)

Evaluate the expression expr and store the result in register

export(*symbols)

Export symbols from the current section

function(formals, *code)

Add a function to the current section

get_byte(base, offset, register)

Load byte from base + offset into register

get_word(base, offset, register)

Load word from base + offset * _@WORDSIZE_ into register

global?(symbol)

Test if a symbol refers to a global

goto(label)

Jump to a label.

ifelse()

Start the false path of a conditional.

ifeq(x, y)

Test if x is equal to y

ifge(x, y)

Test if x is greater than or equal to y

ifgt(x, y)

Test if x is strictly greater than y

ifle(x, y)

Test if x is less than or equal to y

iflt(x, y)

Test if x is strictly less than y

ifne(x, y)

Test if x different from y

import(*symbols)

Import labels into the current section

integer?(value)

Test if a value is an integer

label(name)

Emit a label

let(symbol, *expr)

Introduce a new local variable

load_at(address, register = @TEMPORARY)

Load the value at the given address.

load_value(x, register = @TEMPORARY)

Load a value into a register. Returns the name of the register. If the value was already in a register, the name of that register is returned. Else, the value is loaded into a register and the name of that register is returned. The register to use in that case may be specified using the optional second argument.

load_value_into_register(x, register)

Load a value into a specific register

local_offset(n)

Return the offset from $sp at which the nth (0-based) local variable is stored. For register locals this is the offset at which the saved value (from the calling function) is stored.

local_reference(n)

Return an $sp-relative reference for the nth (0-based) local

local_register(n)

Return the register in which the nth local (0-based) is stored, or nil if not stored in a register

max_locals()

Compute the maximum number of locals that would fit in the current frame size.

number_of_stack_arguments(n)

Calculate the number of stack arguments, given the total number of arguments.

register_arg?(n)

Returns true if the nth (0-based) argument is stored in a register

register_local?(n)

Returns true if the nth (0-based) local is stored in a register