ARM GNU Assembler Code Generator

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

Calling Convention

The first four arguments are passed in the registers r0 through r3. Any additional arguments are passed on the stack, starting at r13. r13 will always be a multiple of 8.

The return address for the called function is passed in r14.

The called function will store its return value in r0.

The called function is required to preserve the values of registers r4 through r11 and register r13.

This calling convention is compatible with the Procedure Call Standard for the ARM Architecture (AAPCS).

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
  padding
  argn
  :
  arg4        <-- r13 points here

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

  :
  old frame
  padding
  argn
  :
  arg4
  saved r14
  saved r11
  :
  saved r4   <-- r13 points here

Register Usage

Inside a function, registers r4..r8, r10, and r11 are used for local variables and function arguments.

r12 is used as a temporary, and r3 is used when another temporary is needed.

Methods

add_constant align arg_reference arg_register assymetric_binop? at_expr? begin_block begin_function binop? byte call common_if count_locals create_frame destroy_frame emit_constants emit_function_prologue end_block end_function end_if eval_binop eval_expr export function get_byte get_word global? goto grow_frame ifelse ifeq ifge ifgt ifle iflt ifne import integer? label let load_at load_value load_value_into_register local_reference local_register new number_of_register_arguments 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

add_constant(value)

Create an entry in the constants table, returning the label that will refer to the constant. The value may be an integer or a label.

align(alignment = nil)

arg_reference(n)

Returns 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(nvars, save_lr = true)

Creates a stack frame for the given number of arguments and local variables.

destroy_frame(ret = false)

Destroys the current stack frame. If ret is true, loads the saved value of lr into pc.

emit_constants()

Writes any constants that need to be written to the instruction stream, and clears the list of constants that need to be written.

emit_function_prologue(formals = [], nlocals = 0)

Emit function prologue.

end_block()

Ends the current block.

end_function()

Ends a function body.

end_if()

Ends a conditional.

eval_binop(expr, register)

Evaluate the binary operation expr and store the result in register

eval_expr(expr, register)

Evaluates the expression expr and stores 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.

grow_frame(nwords)

Grows the current frame by n words, plus padding to respect alignment rules.

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_reference(n)

Returns 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

number_of_register_arguments(n = @environment.args)

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

number_of_stack_arguments(n = @environment.args)

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