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) machine: TargetMachine,
    pub(crate) orc: Option<OrcJitState>,
    pub(crate) _tscx: Option<ThreadSafeContext>,
    pub(crate) _cx_handle: Option<Box<ManuallyDrop<Context>>>,
    pub(crate) _aot_cx: Option<Box<Context>>,
    pub(crate) di_state: Option<DiState>,
    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) backend_config: BackendConfig,
    pub(crate) scratch: String,
    pub(crate) function_counter: u32,
    pub(crate) function_names: HashMap<u32, 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>

machine: TargetMachine

orc: Option<OrcJitState>

_tscx: Option<ThreadSafeContext>

_cx_handle: Option<Box<ManuallyDrop<Context>>>

_aot_cx: Option<Box<Context>>

di_state: Option<DiState>

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

backend_config: BackendConfig

scratch: String

function_counter: u32

function_names: HashMap<u32, String, FxBuildHasher>

Implementations

impl EvmLlvmBackend

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

Creates a new LLVM backend for the host machine.

pub fn cx(&self) -> &Context

Returns the LLVM context.

pub fn take_last_resource_tracker(&mut self) -> Option<ResourceTracker>

Pops and returns the ResourceTracker for the last committed JIT module.

Each call to jit_function commits a module with its own tracker. The caller takes ownership and is responsible for calling tracker.remove() to free the machine code when it is no longer needed.

The caller must also hold a JitDylibGuard to prevent the owning JITDylib from being recycled before the tracker is removed.

Returns None in AOT mode or if no modules have been committed.

pub fn jit_dylib_guard(&self) -> Arc<JitDylibGuard>

Returns a shared handle that keeps this backend’s JITDylib alive.

The JITDylib will not be cleared or recycled until all JitDylibGuard handles (and the backend itself) are dropped. Callers holding JIT function pointers must retain a guard to prevent the backing code from being freed.

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 config(&self) -> &BackendConfig

Returns the current backend configuration.

fn apply_config(&mut self, config: BackendConfig)

Applies the given configuration snapshot.

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

Finalizes any pending debug info metadata.

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 function_name(&self, id: <EvmLlvmBackend as Backend>::FuncId) -> Option<&str>

Returns the name of a compiled function by its ID.

fn function_sizes(&self) -> Vec<(String, usize)>

Returns the estimated sizes of compiled functions as (name, size) pairs.

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