Struct Compiled 

pub struct Compiled { /* private fields */ }

A compiled module: machine code, every function’s place and call-site records, the relocations against symbols defined elsewhere, and the module’s data.

The code refers to globals and imports through relocations (relocations); calls between the module’s own functions are already resolved. A linker places the code and data and patches the relocations (object-lang writes them into an ELF relocatable as they are).

Examples

use backend_lang::Options;
use ir_lang::{Linkage, Module, Overflow, Signature, Type};

let mut m = Module::new("m");
let f = m.declare_function("add", &Signature::new(&[Type::I64, Type::I64], &[Type::I64]), Linkage::Export)?;
let mut b = m.build(f)?;
let (x, y) = (b.param(0)?, b.param(1)?);
let s = b.add(x, y, Overflow::Wrap)?;
b.ret(&[s])?;

let c = backend_lang::compile(&m, &Options::sysv().with_frame_pointer(false))?;
assert_eq!(c.function("add").unwrap().offset(), 0);
assert!(c.relocations().is_empty());
assert_eq!(c.code().last(), Some(&0xC3)); // ret

Implementations

impl Compiled

pub fn code(&self) -> &[u8]

The machine code of every function, back to back.

Examples

See Compiled.

pub fn program(&self) -> &Program

The emitted program (code, functions, relocations).

Examples

See Compiled.

pub fn functions(&self) -> &[EmittedFunction]

Every function, in module order.

Examples

See Compiled.

pub fn function(&self, name: &str) -> Option<&EmittedFunction>

The function named name.

Examples

See Compiled.

pub fn relocations(&self) -> &[Reloc]

The code’s relocations against globals, imports, and runtime entry points.

Examples

See Compiled.

pub fn data(&self) -> &[DataObject]

The module’s globals (imported globals excluded).

Examples

See DataObject.

pub fn imports(&self) -> &[String]

The symbols the code and data refer to that the module does not define (imports and runtime entry points), in name order.

Examples

use backend_lang::Options;
use ir_lang::{Linkage, Module, Signature};

let mut m = Module::new("m");
let f = m.declare_function("f", &Signature::new(&[], &[]), Linkage::Export)?;
let mut b = m.build(f)?;
b.trap(1)?;
let c = backend_lang::compile(&m, &Options::sysv())?;
assert_eq!(c.imports(), ["__lexersketch_trap"]);

pub fn exports(&self) -> &[String]

The functions and globals with export linkage, in name order.

Examples

See Compiled::imports.

Trait Implementations

impl Clone for Compiled

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Compiled

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Compiled

impl PartialEq for Compiled

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Compiled