Class Voodoo::NasmGenerator
In: voodoo/generators/nasm_generator.rb
Parent: CommonCodeGenerator

NASM Code Generator

The NASM code generator is a common base class for generators that output assembly code for use with the Netwide Assembler.

This class is used by both the I386NasmGenerator and the AMD64NasmGenerator, and contains the functionality that is common to both.

To use the functionality from this class, a subclass must define the following methods and constants:

  • emit_function_prologue
  • load_arg
  • load_local
  • @CODE_ALIGNMENT
  • @DATA_ALIGNMENT
  • @FUNCTION_ALIGNMENT
  • @SCRATCH_REG
  • @WORD_NAME
  • @WORDSIZE
  • @AX, @BX, @CX, @DX, @BP, and @SP

Methods

action_to_mnemonic   align   at_expr?   begin_block   begin_function   binop   binop2   binop?   byte   comment   common_if   div   div2   dword   emit_function_epilogue   end_block   end_function   end_if   end_if   eval_div   eval_expr   eval_mul   export   global?   goto   ifelse   ifeq   ifge   ifgt   ifle   iflt   ifne   immediate_operand?   import   integer?   label   load_address   load_at   load_symbol   load_value   load_value_into_register   load_value_into_register   memory_operand?   mod   mod2   mul   mul2   new   qword   ret   set   set_byte   set_register   set_word   string   symbol?   symmetric_operation?   write  

Public Class methods

Public Instance methods

action_to_mnemonic(action)

Translates a Voodoo action name to an x86 mnemonic

at_expr?(value)

Test if a value is an at-expression

begin_block(*code)

Begins a new block.

begin_function(*formals)

Emit function preamble and declare formals as function arguments

binop(op, target, x, y)

Emit code for a binary operation

binop2(op, target, y)

Emit code for a binary operation where the first operand is also the target

binop?(op)

Test if op is a binary operation

byte(value)

Define a byte with the given value

common_if(branch, x, y = nil)

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

div(target, x, y)

Divide x by y and store the quotient in target

div2(target, x)

Divide target by x and store the quotient in target

dword(value)

Define a dword with the given value

end_block()

Ends the current block.

end_function()

End a function body

end_if()

End a conditional.

end_if()

End a conditional body

eval_div(x, y)

Perform division. The quotient is stored in @AX, the remainder in @DX.

eval_expr(words, register = @RETURN_REG)

Evaluate an expression. The result is stored in register (@RETURN_REG by default). The following registers may be clobbered: @AX, @BX, @CX, @DX

eval_mul(x, y, register = @AX)

Multiply x by y. The result is stored in @AX by default, but a different register can be specified by passing a third argument.

export(*symbols)

Export symbols from the current section

global?(symbol)

Test if a symbol refers to a global

goto(value)

Continue execution at the given address

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

immediate_operand?(operand)

Tests if an operand is an immediate operand

import(*symbols)

Import labels into the current section

integer?(value)

Test if a value is an integer

label(name)

Define a label in the current section

load_address(base, offset, scale)

Create a value reference to an address. Invoking this code may clobber @BX and/or @CX

load_at(address, reg = @SCRATCH_REG)

Load the value at the given address. Invoking this code may clobber @BX.

load_symbol(symbol, reg = @SCRATCH_REG)

Load the value associated with the given symbol. Returns a string that can be used to refer to the loaded value.

load_value(value, reg = @SCRATCH_REG)

Load a value. Returns a string that can be used to refer to the loaded value.

load_value_into_register(value, register)

Load a value into a register

load_value_into_register(value, register)

Load a value into a register.

memory_operand?(operand)

Tests if an operand is a memory operand

mod(target, x, y)

Divide x by y and store the remainder in target

mod2(target, x)

Divide target by x and store the remainder in target

mul(target, x, y)

Multiply x by y and store the result in target

mul2(target, x)

Multiply target by x and store the result in target

qword(value)

Define a qword with the given value

ret(*words)

Return a from a function.

words may contain an expression to be evaluated. The result of the evaluation is returned from the function.

set(target, *words)

Evaluate the expr in words and store the result in target

set_byte(base, offset, value)

Set the byte at base + offset to value

set_register(register, value_ref)

Set a register to a value. The value must be a valid operand to the mov instruction.

set_word(base, offset, value)

Set the word at base + offset * +@WORDSIZE+ to value

string(value)

Define a string with the given value

symbol?(value)

Test if a value is a symbol

symmetric_operation?(op)

Test if op is a symmetric operation (i.e. it will yield the same result if the order of its source operands is changed).

write(io)

Write generated code to the given IO object.

[Validate]