Struct State

pub struct State<'a> {
    pub stmts: &'a mut Vec<Stmt>,
    pub target: &'a str,
    pub file_data: &'a mut DynasmData,
}

This struct contains all non-parsing state that dynasm! requires while parsing and compiling

Fields

stmts: &'a mut Vec<Stmt>

target: &'a str

file_data: &'a mut DynasmData

Trait Implementations

impl AssembleX64 for State<'_>

fn compile_instruction( &mut self, arch: &Archx64, instruction: InstructionX64, ) -> Result<(), Error>

Turn an expression into binary format. May error when dynamic data is present at bad locations such as memory address scaling.

fn build_instruction( &mut self, _: &Archx64, _: InstructionX64, ) -> Result<(), Error>

where Self: BasicExprBuilder,

Create an instruction composed from dynamic data. Only available when the type is also capable of building new composite expressions.

impl AssembleX86 for State<'_>

fn compile_instruction( &mut self, arch: &Archx86, instruction: InstructionX86, ) -> Result<(), Error>

Turn an expression into binary format. May error when dynamic data is present at bad locations such as memory address scaling.

fn build_instruction( &mut self, _: &Archx86, _: InstructionX86, ) -> Result<(), Error>

where Self: BasicExprBuilder,

Create an instruction composed from dynamic data. Only available when the type is also capable of building new composite expressions.

impl BasicExprBuilder for State<'_>

A simple implementation of a BasicExprBuilder.

It can not combine any expressions, pushes statements into a Vec and emits errors onto standard error directly.

fn emit_error_at(&mut self, _: ErrorSpan, args: Arguments<'_>)

Emits the error message on stderr.

fn push(&mut self, stmt: Stmt)

Append a new statement.

fn bit_or(&mut self, _: Expr, _: Value) -> Option<Expr>

a | b

fn bit_and(&mut self, _: Expr, _: Value) -> Option<Expr>

a & b

fn bit_xor(&mut self, _: Expr, _: Value) -> Option<Expr>

a ^ b

fn add(&mut self, _: Expr, _: Value) -> Option<Expr>

a + b

fn mul(&mut self, _: Expr, _: Value) -> Option<Expr>

a * b

fn neg(&mut self, _: Expr) -> Option<Expr>

!a

fn log2(&mut self, _: Expr) -> Option<Expr>

Log2, mostly used to encode scalings.

fn mask_shift(&mut self, _: Expr, _: u64, _: i8) -> Option<Expr>

(val & mask) << shift