Struct Block 

pub struct Block<'a> {
    pub label: String,
    pub items: Vec<BlockItem<'a>>,
}

A block of QBE instructions with a label.

Blocks are the basic units of control flow in QBE. Each block has a label that can be the target of jumps, and contains a sequence of instructions. A block typically ends with a control flow instruction like jump or return.

Examples

use qbe::{Block, BlockItem, Instr, Statement, Type, Value};

// Create a block for a loop body
let mut block = Block {
    label: "loop".to_string(),
    items: Vec::new(),
};

// Add a helpful comment
block.add_comment("Loop body - increment counter and accumulate sum");

// Increment loop counter: %i = %i + 1
block.assign_instr(
    Value::Temporary("i".to_string()),
    Type::Word,
    Instr::Add(
        Value::Temporary("i".to_string()),
        Value::Const(1),
    ),
);

// Update sum: %sum = %sum + %value
block.assign_instr(
    Value::Temporary("sum".to_string()),
    Type::Word,
    Instr::Add(
        Value::Temporary("sum".to_string()),
        Value::Temporary("value".to_string()),
    ),
);

// Jump to condition check block
block.add_instr(Instr::Jmp("cond".to_string()));

// Check if block ends with a jump (it does)
assert!(block.jumps());

Fields

label: String

Label before the block

items: Vec<BlockItem<'a>>

A list of statements in the block

Implementations

impl<'a> Block<'a>

pub fn add_comment(&mut self, contents: impl Into<String>)

pub fn add_instr(&mut self, instr: Instr<'a>)

Adds a new instruction to the block

pub fn assign_instr(&mut self, temp: Value, ty: Type<'a>, instr: Instr<'a>)

Adds a new instruction assigned to a temporary

pub fn jumps(&self) -> bool

Returns true if the block’s last instruction is a jump

Trait Implementations

impl<'a> Clone for Block<'a>

fn clone(&self) -> Block<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Block<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Block<'a>

fn default() -> Block<'a>

Returns the “default value” for a type.

impl Display for Block<'_>

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

Formats the value using the given formatter.

impl<'a> Hash for Block<'a>

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<'a> Ord for Block<'a>

fn cmp(&self, other: &Block<'a>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a> PartialEq for Block<'a>

fn eq(&self, other: &Block<'a>) -> 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<'a> PartialOrd for Block<'a>

fn partial_cmp(&self, other: &Block<'a>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> Eq for Block<'a>

impl<'a> StructuralPartialEq for Block<'a>