Struct EvmLlvmBackend 

pub struct EvmLlvmBackend {

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

Available on crate feature llvm only.

The LLVM-based EVM bytecode compiler backend.

Fields

cx: &'static Context

_dh: DiagnosticHandlerGuard

bcx: Builder<'static>

module: Module<'static>

exec_engine: Option<ExecutionEngine<'static>>

machine: TargetMachine

ty_void: VoidType<'static>

ty_ptr: PointerType<'static>

ty_i1: IntType<'static>

ty_i8: IntType<'static>

ty_i32: IntType<'static>

ty_i64: IntType<'static>

ty_i256: IntType<'static>

ty_isize: IntType<'static>

aot: bool

debug_assertions: bool

opt_level: OptimizationLevel

function_counter: u32

functions: HashMap<u32, (String, FunctionValue<'static>), FxBuildHasher>

mapped_symbols: HashSet<String, FxBuildHasher>

Implementations

impl EvmLlvmBackend

pub fn new( aot: bool, opt_level: OptimizationLevel, ) -> Result<EvmLlvmBackend, Report>

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( aot: bool, opt_level: OptimizationLevel, target: &Target, ) -> Result<EvmLlvmBackend, Report>

Creates a new LLVM backend for the given target.

pub fn cx(&self) -> &Context

Returns the LLVM context.

Trait Implementations

impl Backend for EvmLlvmBackend

type Builder<'a> = EvmLlvmBuilder<'a> where EvmLlvmBackend: '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<(), Report>

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

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

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

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

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

where W: Write,

fn jit_function( &mut self, id: <EvmLlvmBackend as Backend>::FuncId, ) -> Result<usize, Report>

fn clear_ir(&mut self) -> Result<(), Report>

Clears the IR module, freeing memory used by IR representations.

unsafe fn free_function( &mut self, id: <EvmLlvmBackend as Backend>::FuncId, ) -> Result<(), Report>

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

impl BackendTypes for EvmLlvmBackend

type Type = BasicTypeEnum<'static>

type Value = BasicValueEnum<'static>

type StackSlot = PointerValue<'static>

type BasicBlock = BasicBlock<'static>

type Function = FunctionValue<'static>

impl Debug for EvmLlvmBackend

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

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) -> <EvmLlvmBackend as BackendTypes>::Type

fn type_ptr_sized_int(&self) -> <EvmLlvmBackend as BackendTypes>::Type

fn type_int(&self, bits: u32) -> <EvmLlvmBackend as BackendTypes>::Type

fn type_array( &self, ty: <EvmLlvmBackend as BackendTypes>::Type, size: u32, ) -> <EvmLlvmBackend as BackendTypes>::Type

fn type_bit_width(&self, ty: <EvmLlvmBackend as BackendTypes>::Type) -> u32

impl Send for EvmLlvmBackend

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: 304 bytes