Struct EvmCompiler

pub struct EvmCompiler<B: Backend> {
    name: Option<String>,
    backend: B,
    out_dir: Option<PathBuf>,
    config: FcxConfig,
    builtins: Builtins<B>,
    dump_assembly: bool,
    dump_unopt_assembly: bool,
    finalized: bool,
}

EVM bytecode compiler.

This currently represents one single-threaded IR context and module, which can be used to compile multiple functions as JIT or AOT.

Functions can be incrementally added with translate, and then either written to an object file with write_object when in AOT mode, or JIT-compiled with jit_function.

Performing either of these operations finalizes the module, and no more functions can be added afterwards until clear is called, which will reset the module to its initial state.

Fields

name: Option<String>

backend: B

out_dir: Option<PathBuf>

config: FcxConfig

builtins: Builtins<B>

dump_assembly: bool

dump_unopt_assembly: bool

finalized: bool

Implementations

impl<B: Backend> EvmCompiler<B>

pub fn new(backend: B) -> Self

Creates a new instance of the compiler with the given backend.

pub fn set_module_name(&mut self, name: impl Into<String>)

Sets the name of the module.

fn is_aot(&self) -> bool

fn is_jit(&self) -> bool

pub fn out_dir(&self) -> Option<&Path>

Returns the output directory.

pub fn set_dump_to(&mut self, output_dir: Option<PathBuf>)

Dumps intermediate outputs and other debug info to the given directory after compilation.

Disables dumping if output_dir is None.

pub fn dump_assembly(&mut self, yes: bool)

Dumps assembly to the output directory.

This can be quite slow.

Defaults to true.

pub fn dump_unopt_assembly(&mut self, yes: bool)

Dumps the unoptimized assembly to the output directory.

This can be quite slow.

Defaults to false.

pub fn opt_level(&self) -> OptimizationLevel

Returns the optimization level.

pub fn set_opt_level(&mut self, level: OptimizationLevel)

Sets the optimization level.

Note that some backends may not support setting the optimization level after initialization.

Defaults to the backend’s initial optimization level.

pub fn debug_assertions(&mut self, yes: bool)

Sets whether to enable debug assertions.

These are useful for debugging, but they do a moderate performance penalty due to the insertion of extra checks and removal of certain assumptions.

Defaults to cfg!(debug_assertions).

pub fn frame_pointers(&mut self, yes: bool)

Sets whether to enable frame pointers.

This is useful for profiling and debugging, but it incurs a very slight performance penalty.

Defaults to cfg!(debug_assertions).

pub fn validate_eof(&mut self, yes: bool)

Sets whether to validate input EOF containers.

An invalid EOF container will likely results in a panic.

Defaults to true.

pub fn local_stack(&mut self, yes: bool)

Sets whether to allocate the stack locally.

If this is set to true, the stack pointer argument will be ignored and the stack will be allocated in the function.

This setting will fail at runtime if the bytecode suspends execution, as it cannot be restored afterwards.

Defaults to false.

pub fn inspect_stack_length(&mut self, yes: bool)

Sets whether to treat the stack length as observable outside the function.

This also implies that the length is loaded in the beginning of the function, meaning that a function can be executed with an initial stack.

If this is set to true, the stack length must be passed in the arguments.

This is useful to inspect the stack length after the function has been executed, but it does incur a performance penalty as the length will be stored at all return sites.

Defaults to false.

pub unsafe fn stack_bound_checks(&mut self, yes: bool)

Sets whether to enable stack bound checks.

Ignored for EOF bytecodes, as they are assumed to be correct.

Defaults to true.

Safety

Removing stack length checks may improve compilation speed and performance, but will result in undefined behavior if the stack length overflows at runtime, rather than a StackUnderflow/StackOverflow result.

pub fn gas_metering(&mut self, yes: bool)

Sets whether to track gas costs.

Disabling this will greatly improves compilation speed and performance, at the cost of not being able to check for gas exhaustion.

Note that this does not disable gas usage in certain instructions, mainly the ones that are implemented as builtins.

Use with care, as executing a function with gas disabled may result in an infinite loop.

Defaults to true.

pub fn translate<'a>( &mut self, name: &str, input: impl Into<EvmCompilerInput<'a>>, spec_id: SpecId, ) -> Result<B::FuncId>

Translates the given EVM bytecode into an internal function.

NOTE: name must be unique for each function, as it is used as the name of the final symbol.

pub unsafe fn jit<'a>( &mut self, name: &str, bytecode: impl Into<EvmCompilerInput<'a>>, spec_id: SpecId, ) -> Result<EvmCompilerFn>

(JIT) Compiles the given EVM bytecode into a JIT function.

See translate for more information.

Safety

The returned function pointer is owned by the module, and must not be called after the module is cleared or the function is freed.

pub unsafe fn jit_function(&mut self, id: B::FuncId) -> Result<EvmCompilerFn>

(JIT) Finalizes the module and JITs the given function.

Safety

The returned function pointer is owned by the module, and must not be called after the module is cleared or the function is freed.

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

(AOT) Writes the compiled object to the given file.

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

(AOT) Finalizes the module and writes the compiled object to the given writer.

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

(JIT) Frees the memory associated with a single function.

Note that this will not reset the state of the internal module even if all functions are freed with this function. Use clear to reset the module.

Safety

Because this function invalidates any pointers retrieved from the corresponding module, it should only be used when none of the functions from that module are currently executing and none of the fn pointers are called afterwards.

pub unsafe fn clear(&mut self) -> Result<()>

Frees all functions and resets the state of the internal module, allowing for new functions to be compiled.

Safety

Because this function invalidates any pointers retrieved from the corresponding module, it should only be used when none of the functions from that module are currently executing and none of the fn pointers are called afterwards.

fn do_validate_eof(&self, eof: &Eof) -> Result<()>

fn translate_inner( &mut self, name: &str, bytecode: &Bytecode<'_>, ) -> Result<B::FuncId>

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

fn make_builder<'a>( backend: &'a mut B, config: &FcxConfig, name: &str, linkage: Linkage, ) -> Result<(B::Builder<'a>, B::FuncId)>

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

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

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

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

fn dump_bytecode(dump_dir: &Path, bytecode: &Bytecode<'_>) -> Result<()>

fn dump_dir(&self) -> Option<PathBuf>

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.