Struct EvmLlvmBackend

pub struct EvmLlvmBackend<'ctx> {

    pub(crate) cx: &'ctx Context,
    pub(crate) _dh: DiagnosticHandlerGuard<'ctx>,
    pub(crate) bcx: Builder<'ctx>,
    pub(crate) module: Module<'ctx>,
    pub(crate) exec_engine: Option<ExecutionEngine<'ctx>>,
    pub(crate) machine: TargetMachine,
    pub(crate) ty_void: VoidType<'ctx>,
    pub(crate) ty_ptr: PointerType<'ctx>,
    pub(crate) ty_i1: IntType<'ctx>,
    pub(crate) ty_i8: IntType<'ctx>,
    pub(crate) ty_i32: IntType<'ctx>,
    pub(crate) ty_i64: IntType<'ctx>,
    pub(crate) ty_i256: IntType<'ctx>,
    pub(crate) ty_isize: IntType<'ctx>,
    pub(crate) aot: bool,
    pub(crate) debug_assertions: bool,
    pub(crate) opt_level: OptimizationLevel,
    pub(crate) function_counter: u32,
    pub(crate) functions: FxHashMap<u32, (String, FunctionValue<'ctx>)>,
}

The LLVM-based EVM bytecode compiler backend.

Fields

cx: &'ctx Context

_dh: DiagnosticHandlerGuard<'ctx>

bcx: Builder<'ctx>

module: Module<'ctx>

exec_engine: Option<ExecutionEngine<'ctx>>

machine: TargetMachine

ty_void: VoidType<'ctx>

ty_ptr: PointerType<'ctx>

ty_i1: IntType<'ctx>

ty_i8: IntType<'ctx>

ty_i32: IntType<'ctx>

ty_i64: IntType<'ctx>

ty_i256: IntType<'ctx>

ty_isize: IntType<'ctx>

aot: bool

debug_assertions: bool

opt_level: OptimizationLevel

function_counter: u32

Separate from functions to have always increasing IDs.

functions: FxHashMap<u32, (String, FunctionValue<'ctx>)>

Implementations

impl<'ctx> EvmLlvmBackend<'ctx>

pub fn new( cx: &'ctx Context, aot: bool, opt_level: OptimizationLevel, ) -> Result<Self>

Creates a new LLVM backend for the host machine.

Use new_for_target to create a backend for a specific target.

pub fn new_for_target( cx: &'ctx Context, aot: bool, opt_level: OptimizationLevel, target: &Target, ) -> Result<Self>

Creates a new LLVM backend for the given target.

pub fn cx(&self) -> &'ctx Context

Returns the LLVM context.

pub(crate) fn exec_engine(&self) -> &ExecutionEngine<'ctx>

pub(crate) fn fn_type( &self, ret: Option<BasicTypeEnum<'ctx>>, params: &[BasicTypeEnum<'ctx>], ) -> FunctionType<'ctx>

pub(crate) fn id_to_name(&self, id: u32) -> &str

pub(crate) fn clear_module(&mut self)

Trait Implementations

impl<'ctx> Backend for EvmLlvmBackend<'ctx>

type Builder<'a> = EvmLlvmBuilder<'a, 'ctx> where Self: 'a

type FuncId = u32

fn ir_extension(&self) -> &'static str

fn set_module_name(&mut self, name: &str)

fn set_is_dumping(&mut self, yes: bool)

fn set_debug_assertions(&mut self, yes: bool)

fn opt_level(&self) -> OptimizationLevel

fn set_opt_level(&mut self, level: OptimizationLevel)

fn is_aot(&self) -> bool

fn function_name_is_unique(&self, name: &str) -> bool

fn dump_ir(&mut self, path: &Path) -> Result<()>

fn dump_disasm(&mut self, path: &Path) -> Result<()>

fn build_function( &mut self, name: &str, ret: Option<Self::Type>, params: &[Self::Type], param_names: &[&str], linkage: Linkage, ) -> Result<(Self::Builder<'_>, Self::FuncId)>

fn verify_module(&mut self) -> Result<()>

fn optimize_module(&mut self) -> Result<()>

fn write_object<W: Write>(&mut self, w: W) -> Result<()>

fn jit_function(&mut self, id: Self::FuncId) -> Result<usize>

unsafe fn free_function(&mut self, id: Self::FuncId) -> Result<()>

unsafe fn free_all_functions(&mut self) -> Result<()>

impl<'ctx> BackendTypes for EvmLlvmBackend<'ctx>

type Type = BasicTypeEnum<'ctx>

type Value = BasicValueEnum<'ctx>

type StackSlot = PointerValue<'ctx>

type BasicBlock = BasicBlock<'ctx>

type Function = FunctionValue<'ctx>

impl<'ctx> Debug for EvmLlvmBackend<'ctx>

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

Formats the value using the given formatter.

impl Drop for EvmLlvmBackend<'_>

fn drop(&mut self)

Executes the destructor for this type.

impl TypeMethods for EvmLlvmBackend<'_>

fn type_ptr(&self) -> Self::Type

fn type_ptr_sized_int(&self) -> Self::Type

fn type_int(&self, bits: u32) -> Self::Type

fn type_array(&self, ty: Self::Type, size: u32) -> Self::Type

fn type_bit_width(&self, ty: Self::Type) -> u32

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 272 bytes