Struct BodyBuilder

pub struct BodyBuilder {
    pub body: FunctionBody,
    /* private fields */
}

Fields

body: FunctionBody

Implementations

impl BodyBuilder

pub fn new(fid: FunctionId, source: SourceInfo) -> Self

pub fn build(self) -> FunctionBody

pub fn func_id(&self) -> FunctionId

pub fn make_block(&mut self) -> BasicBlockId

pub fn make_value(&mut self, value: impl Into<Value>) -> ValueId

pub fn map_result(&mut self, inst: InstId, result: AssignableValue)

pub fn inst_result(&mut self, inst: InstId) -> Option<&AssignableValue>

pub fn move_to_block(&mut self, block: BasicBlockId)

pub fn move_to_block_top(&mut self, block: BasicBlockId)

pub fn make_unit(&mut self, unit_ty: TypeId) -> ValueId

pub fn make_imm(&mut self, imm: BigInt, ty: TypeId) -> ValueId

pub fn make_imm_from_bool(&mut self, imm: bool, ty: TypeId) -> ValueId

pub fn make_constant(&mut self, constant: ConstantId, ty: TypeId) -> ValueId

pub fn declare(&mut self, local: Local) -> ValueId

pub fn store_func_arg(&mut self, local: Local) -> ValueId

pub fn not(&mut self, value: ValueId, source: SourceInfo) -> InstId

pub fn neg(&mut self, value: ValueId, source: SourceInfo) -> InstId

pub fn inv(&mut self, value: ValueId, source: SourceInfo) -> InstId

pub fn add(&mut self, lhs: ValueId, rhs: ValueId, source: SourceInfo) -> InstId

pub fn sub(&mut self, lhs: ValueId, rhs: ValueId, source: SourceInfo) -> InstId

pub fn mul(&mut self, lhs: ValueId, rhs: ValueId, source: SourceInfo) -> InstId

pub fn div(&mut self, lhs: ValueId, rhs: ValueId, source: SourceInfo) -> InstId

pub fn modulo( &mut self, lhs: ValueId, rhs: ValueId, source: SourceInfo, ) -> InstId

pub fn pow(&mut self, lhs: ValueId, rhs: ValueId, source: SourceInfo) -> InstId

pub fn shl(&mut self, lhs: ValueId, rhs: ValueId, source: SourceInfo) -> InstId

pub fn shr(&mut self, lhs: ValueId, rhs: ValueId, source: SourceInfo) -> InstId

pub fn bit_or( &mut self, lhs: ValueId, rhs: ValueId, source: SourceInfo, ) -> InstId

pub fn bit_xor( &mut self, lhs: ValueId, rhs: ValueId, source: SourceInfo, ) -> InstId

pub fn bit_and( &mut self, lhs: ValueId, rhs: ValueId, source: SourceInfo, ) -> InstId

pub fn logical_and( &mut self, lhs: ValueId, rhs: ValueId, source: SourceInfo, ) -> InstId

pub fn logical_or( &mut self, lhs: ValueId, rhs: ValueId, source: SourceInfo, ) -> InstId

pub fn eq(&mut self, lhs: ValueId, rhs: ValueId, source: SourceInfo) -> InstId

pub fn ne(&mut self, lhs: ValueId, rhs: ValueId, source: SourceInfo) -> InstId

pub fn ge(&mut self, lhs: ValueId, rhs: ValueId, source: SourceInfo) -> InstId

pub fn gt(&mut self, lhs: ValueId, rhs: ValueId, source: SourceInfo) -> InstId

pub fn le(&mut self, lhs: ValueId, rhs: ValueId, source: SourceInfo) -> InstId

pub fn lt(&mut self, lhs: ValueId, rhs: ValueId, source: SourceInfo) -> InstId

pub fn primitive_cast( &mut self, value: ValueId, result_ty: TypeId, source: SourceInfo, ) -> InstId

pub fn untag_cast( &mut self, value: ValueId, result_ty: TypeId, source: SourceInfo, ) -> InstId

pub fn aggregate_construct( &mut self, ty: TypeId, args: Vec<ValueId>, source: SourceInfo, ) -> InstId

pub fn bind(&mut self, src: ValueId, source: SourceInfo) -> InstId

pub fn mem_copy(&mut self, src: ValueId, source: SourceInfo) -> InstId

pub fn load(&mut self, src: ValueId, source: SourceInfo) -> InstId

pub fn aggregate_access( &mut self, value: ValueId, indices: Vec<ValueId>, source: SourceInfo, ) -> InstId

pub fn map_access( &mut self, value: ValueId, key: ValueId, source: SourceInfo, ) -> InstId

pub fn call( &mut self, func: FunctionId, args: Vec<ValueId>, call_type: CallType, source: SourceInfo, ) -> InstId

pub fn keccak256(&mut self, arg: ValueId, source: SourceInfo) -> InstId

pub fn abi_encode(&mut self, arg: ValueId, source: SourceInfo) -> InstId

pub fn create( &mut self, value: ValueId, contract: ContractId, source: SourceInfo, ) -> InstId

pub fn create2( &mut self, value: ValueId, salt: ValueId, contract: ContractId, source: SourceInfo, ) -> InstId

pub fn yul_intrinsic( &mut self, op: YulIntrinsicOp, args: Vec<ValueId>, source: SourceInfo, ) -> InstId

pub fn jump(&mut self, dest: BasicBlockId, source: SourceInfo) -> InstId

pub fn branch( &mut self, cond: ValueId, then: BasicBlockId, else_: BasicBlockId, source: SourceInfo, ) -> InstId

pub fn switch( &mut self, disc: ValueId, table: SwitchTable, default: Option<BasicBlockId>, source: SourceInfo, ) -> InstId

pub fn revert(&mut self, arg: Option<ValueId>, source: SourceInfo) -> InstId

pub fn emit(&mut self, arg: ValueId, source: SourceInfo) -> InstId

pub fn ret(&mut self, arg: ValueId, source: SourceInfo) -> InstId

pub fn nop(&mut self, source: SourceInfo) -> InstId

pub fn value_ty(&mut self, value: ValueId) -> TypeId

pub fn value_data(&mut self, value: ValueId) -> &Value

pub fn is_block_terminated(&mut self, block: BasicBlockId) -> bool

Returns true if current block is terminated.

pub fn is_current_block_terminated(&mut self) -> bool

pub fn current_block(&mut self) -> BasicBlockId

pub fn remove_inst(&mut self, inst: InstId)

pub fn inst_data(&self, inst: InstId) -> &Inst

Trait Implementations

impl Debug for BodyBuilder

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

Formats the value using the given formatter.