Struct Bytecode 

pub struct Bytecode;

The reference backend: lowers a function to a flat, register-based Program.

Bytecode is the concrete target shipped with the crate and the one compile uses. It validates the function, then lowers each block in order to a linear op stream — small enough to read, serialize, and execute, which makes it the natural target for testing a front-end’s output before a native backend exists.

It is a zero-sized type with no configuration; construct it directly or with Default.

Examples

use codegen_lang::{Backend, Bytecode};
use ir_lang::{Builder, BinOp, Type};

// fn inc(x: int) -> int { x + 1 }
let mut b = Builder::new("inc", &[Type::Int], Type::Int);
let x = b.block_params(b.entry())[0];
let one = b.iconst(1);
let sum = b.bin(BinOp::Add, x, one);
b.ret(Some(sum));

let program = Bytecode.compile(&b.finish()).expect("inc is well-formed");
assert_eq!(program.register_count(), 3); // x, the constant, the sum

Trait Implementations

impl Backend for Bytecode

type Output = Program

The representation this backend emits.

fn compile(&self, func: &Function) -> Result<Program, CodegenError>

Lowers func to this backend’s Output.

impl Clone for Bytecode

fn clone(&self) -> Bytecode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Bytecode

impl Debug for Bytecode

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

Formats the value using the given formatter.

impl Default for Bytecode

fn default() -> Bytecode

Returns the “default value” for a type.

impl Eq for Bytecode

impl Hash for Bytecode

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Bytecode

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Bytecode