Struct FunctionBuilder 

pub struct FunctionBuilder<'a> { /* private fields */ }

A builder for constructing MIR functions.

Implementations

impl<'a> FunctionBuilder<'a>

pub fn new(func: &'a mut Function) -> FunctionBuilder<'a>

Creates a new function builder.

pub const fn current_block(&self) -> BlockId

Returns the current block.

pub fn switch_to_block(&mut self, block: BlockId)

Switches to a different block.

pub fn create_block(&mut self) -> BlockId

Creates a new basic block.

pub fn add_param(&mut self, ty: MirType) -> ValueId

Adds an argument to the function.

pub fn add_return(&mut self, ty: MirType)

Adds a return type to the function.

pub fn imm_u256(&mut self, value: Uint<256, 4>) -> ValueId

Creates an immediate value.

pub fn imm_u64(&mut self, value: u64) -> ValueId

Creates a u64 immediate value.

pub fn imm_bool(&mut self, value: bool) -> ValueId

Creates a boolean immediate.

pub fn undef(&mut self, ty: MirType) -> ValueId

Creates an undefined value.

pub fn error_value(&mut self, guar: ErrorGuaranteed) -> ValueId

Creates an error sentinel value for an already-reported lowering error.

pub fn add(&mut self, a: ValueId, b: ValueId) -> ValueId

Emits an add instruction.

pub fn sub(&mut self, a: ValueId, b: ValueId) -> ValueId

Emits a sub instruction.

pub fn mul(&mut self, a: ValueId, b: ValueId) -> ValueId

Emits a mul instruction.

pub fn div(&mut self, a: ValueId, b: ValueId) -> ValueId

Emits a div instruction.

pub fn sdiv(&mut self, a: ValueId, b: ValueId) -> ValueId

Emits a sdiv instruction.

pub fn mod_(&mut self, a: ValueId, b: ValueId) -> ValueId

Emits a mod instruction.

pub fn addmod(&mut self, a: ValueId, b: ValueId, n: ValueId) -> ValueId

Emits an addmod instruction.

pub fn mulmod(&mut self, a: ValueId, b: ValueId, n: ValueId) -> ValueId

Emits a mulmod instruction.

pub fn smod(&mut self, a: ValueId, b: ValueId) -> ValueId

Emits a smod instruction.

pub fn exp(&mut self, a: ValueId, b: ValueId) -> ValueId

Emits an exp instruction.

pub fn and(&mut self, a: ValueId, b: ValueId) -> ValueId

Emits an and instruction.

pub fn or(&mut self, a: ValueId, b: ValueId) -> ValueId

Emits an or instruction.

pub fn xor(&mut self, a: ValueId, b: ValueId) -> ValueId

Emits a xor instruction.

pub fn not(&mut self, a: ValueId) -> ValueId

Emits a not instruction.

pub fn shl(&mut self, shift: ValueId, value: ValueId) -> ValueId

Emits a shl instruction.

pub fn shr(&mut self, shift: ValueId, value: ValueId) -> ValueId

Emits a shr instruction.

pub fn sar(&mut self, shift: ValueId, value: ValueId) -> ValueId

Emits a sar instruction.

pub fn lt(&mut self, a: ValueId, b: ValueId) -> ValueId

Emits a lt instruction.

pub fn gt(&mut self, a: ValueId, b: ValueId) -> ValueId

Emits a gt instruction.

pub fn slt(&mut self, a: ValueId, b: ValueId) -> ValueId

Emits a slt instruction.

pub fn sgt(&mut self, a: ValueId, b: ValueId) -> ValueId

Emits a sgt instruction.

pub fn eq(&mut self, a: ValueId, b: ValueId) -> ValueId

Emits an eq instruction.

pub fn iszero(&mut self, a: ValueId) -> ValueId

Emits an iszero instruction.

pub fn byte(&mut self, index: ValueId, value: ValueId) -> ValueId

Emits a byte instruction.

pub fn signextend(&mut self, size: ValueId, value: ValueId) -> ValueId

Emits a signextend instruction.

pub fn mload(&mut self, offset: ValueId) -> ValueId

Emits an mload instruction.

pub fn mstore(&mut self, offset: ValueId, value: ValueId)

Emits an mstore instruction.

pub fn mstore8(&mut self, offset: ValueId, value: ValueId)

Emits an mstore8 instruction.

pub fn msize(&mut self) -> ValueId

Emits an msize instruction.

pub fn mcopy(&mut self, dest: ValueId, src: ValueId, len: ValueId)

Emits an mcopy instruction.

pub fn sload(&mut self, slot: ValueId) -> ValueId

Emits an sload instruction.

pub fn sstore(&mut self, slot: ValueId, value: ValueId)

Emits an sstore instruction.

pub fn tload(&mut self, slot: ValueId) -> ValueId

Emits a tload instruction.

pub fn tstore(&mut self, slot: ValueId, value: ValueId)

Emits a tstore instruction.

pub fn calldataload(&mut self, offset: ValueId) -> ValueId

Emits a calldataload instruction.

pub fn calldatasize(&mut self) -> ValueId

Emits a calldatasize instruction.

pub fn calldatacopy(&mut self, dest: ValueId, offset: ValueId, size: ValueId)

Emits a calldatacopy instruction.

pub fn codesize(&mut self) -> ValueId

Emits a codesize instruction.

pub fn extcodesize(&mut self, addr: ValueId) -> ValueId

Emits an extcodesize instruction.

pub fn load_immutable(&mut self, offset: u32) -> ValueId

Emits a loadimmutable instruction for the immutable at offset.

pub fn extcodecopy( &mut self, addr: ValueId, dest: ValueId, offset: ValueId, size: ValueId, )

Emits an extcodecopy instruction.

pub fn extcodehash(&mut self, addr: ValueId) -> ValueId

Emits an extcodehash instruction.

pub fn returndatasize(&mut self) -> ValueId

Emits a returndatasize instruction.

pub fn returndatacopy(&mut self, dest: ValueId, offset: ValueId, size: ValueId)

Emits a returndatacopy instruction.

pub fn internal_call( &mut self, function: FunctionId, args: Vec<ValueId>, result_ty: MirType, returns: usize, ) -> ValueId

Emits an internal function call.

pub fn internal_call_void( &mut self, function: FunctionId, args: Vec<ValueId>, returns: usize, )

Emits an internal function call whose result, if any, is not used as a value.

pub fn internal_frame_addr(&mut self, offset: u64) -> ValueId

Emits an address inside the current internal-call frame.

pub fn caller(&mut self) -> ValueId

Emits a caller instruction.

pub fn callvalue(&mut self) -> ValueId

Emits a callvalue instruction.

pub fn origin(&mut self) -> ValueId

Emits an origin instruction.

pub fn gasprice(&mut self) -> ValueId

Emits a gasprice instruction.

pub fn blockhash(&mut self, block_num: ValueId) -> ValueId

Emits a blockhash instruction.

pub fn coinbase(&mut self) -> ValueId

Emits a coinbase instruction.

pub fn timestamp(&mut self) -> ValueId

Emits a timestamp instruction.

pub fn number(&mut self) -> ValueId

Emits a number instruction.

pub fn prevrandao(&mut self) -> ValueId

Emits a prevrandao instruction.

pub fn gaslimit(&mut self) -> ValueId

Emits a gaslimit instruction.

pub fn chainid(&mut self) -> ValueId

Emits a chainid instruction.

pub fn address(&mut self) -> ValueId

Emits an address instruction.

pub fn balance(&mut self, addr: ValueId) -> ValueId

Emits a balance instruction.

pub fn selfbalance(&mut self) -> ValueId

Emits a selfbalance instruction.

pub fn gas(&mut self) -> ValueId

Emits a gas instruction.

pub fn keccak256(&mut self, offset: ValueId, size: ValueId) -> ValueId

Emits a keccak256 instruction.

pub fn basefee(&mut self) -> ValueId

Emits a basefee instruction.

pub fn blobbasefee(&mut self) -> ValueId

Emits a blobbasefee instruction.

pub fn blobhash(&mut self, index: ValueId) -> ValueId

Emits a blobhash instruction.

pub fn call( &mut self, gas: ValueId, addr: ValueId, value: ValueId, args_offset: ValueId, args_size: ValueId, ret_offset: ValueId, ret_size: ValueId, ) -> ValueId

Emits a call instruction (external call).

pub fn staticcall( &mut self, gas: ValueId, addr: ValueId, args_offset: ValueId, args_size: ValueId, ret_offset: ValueId, ret_size: ValueId, ) -> ValueId

Emits a staticcall instruction (read-only external call).

pub fn delegatecall( &mut self, gas: ValueId, addr: ValueId, args_offset: ValueId, args_size: ValueId, ret_offset: ValueId, ret_size: ValueId, ) -> ValueId

Emits a delegatecall instruction (call with caller’s context).

pub fn create( &mut self, value: ValueId, offset: ValueId, size: ValueId, ) -> ValueId

Emits a create instruction (deploy a contract).

pub fn create2( &mut self, value: ValueId, offset: ValueId, size: ValueId, salt: ValueId, ) -> ValueId

Emits a create2 instruction (deploy a contract with salt).

pub fn codecopy(&mut self, dest: ValueId, offset: ValueId, size: ValueId)

Emits a codecopy instruction.

pub fn log0(&mut self, offset: ValueId, size: ValueId)

Emits a log0 instruction (event with no topics).

pub fn log1(&mut self, offset: ValueId, size: ValueId, topic1: ValueId)

Emits a log1 instruction (event with 1 topic).

pub fn log2( &mut self, offset: ValueId, size: ValueId, topic1: ValueId, topic2: ValueId, )

Emits a log2 instruction (event with 2 topics).

pub fn log3( &mut self, offset: ValueId, size: ValueId, topic1: ValueId, topic2: ValueId, topic3: ValueId, )

Emits a log3 instruction (event with 3 topics).

pub fn log4( &mut self, offset: ValueId, size: ValueId, topic1: ValueId, topic2: ValueId, topic3: ValueId, topic4: ValueId, )

Emits a log4 instruction (event with 4 topics).

pub fn select( &mut self, cond: ValueId, then_val: ValueId, else_val: ValueId, ) -> ValueId

Emits a select instruction.

pub fn phi(&mut self, incoming: Vec<(BlockId, ValueId)>) -> ValueId

Emits a phi instruction. incoming pairs each predecessor block of the current block with the value the phi takes when control arrives from that block. Emit phis before any other instruction in their block.

pub fn add_phi_incoming(&mut self, phi: ValueId, block: BlockId, value: ValueId)

Adds an incoming (block, value) edge to an existing phi. This is used to patch loop-carried phis whose back-edge values are only known after the loop body has been built.

Panics

Panics if phi does not refer to a phi instruction result.

pub fn jump(&mut self, target: BlockId)

Sets a jump terminator.

pub fn branch( &mut self, condition: ValueId, then_block: BlockId, else_block: BlockId, )

Sets a branch terminator.

pub fn switch( &mut self, value: ValueId, default: BlockId, cases: Vec<(ValueId, BlockId)>, )

Sets a switch terminator.

pub fn ret(&mut self, values: impl IntoIterator<Item = ValueId>)

Sets a return terminator.

pub fn revert(&mut self, offset: ValueId, size: ValueId)

Sets a revert terminator.

pub fn ret_data(&mut self, offset: ValueId, size: ValueId)

Sets a return-data terminator: RETURN(offset, size).

pub fn stop(&mut self)

Sets a stop terminator.

pub fn invalid(&mut self)

Sets an invalid terminator.

pub fn selfdestruct(&mut self, recipient: ValueId)

Sets a selfdestruct terminator.

pub fn func(&self) -> &Function

Returns a reference to the function.

pub fn func_mut(&mut self) -> &mut Function

Returns a mutable reference to the function.