Struct LLVM 

pub struct LLVM {
    pub(crate) enable_nan_canonicalization: bool,
    pub(crate) enable_non_volatile_memops: bool,
    pub(crate) enable_readonly_funcref_table: bool,
    pub(crate) enable_verifier: bool,
    pub(crate) enable_perfmap: bool,
    pub(crate) opt_level: LLVMOptLevel,
    is_pic: bool,
    pub(crate) callbacks: Option<LLVMCallbacks>,
    pub(crate) middlewares: Vec<Arc<dyn ModuleMiddleware>>,
    pub(crate) num_threads: NonZero<usize>,
    pub(crate) verbose_asm: bool,
}

Fields

enable_nan_canonicalization: bool

enable_non_volatile_memops: bool

enable_readonly_funcref_table: bool

enable_verifier: bool

enable_perfmap: bool

opt_level: LLVMOptLevel

is_pic: bool

callbacks: Option<LLVMCallbacks>

middlewares: Vec<Arc<dyn ModuleMiddleware>>

The middleware chain.

num_threads: NonZero<usize>

Number of threads to use when compiling a module.

verbose_asm: bool

Implementations

impl LLVM

pub fn new() -> Self

Creates a new configuration object with the default configuration specified.

pub fn opt_level(&mut self, opt_level: LLVMOptLevel) -> &mut Self

The optimization levels when optimizing the IR.

pub fn num_threads(&mut self, num_threads: NonZero<usize>) -> &mut Self

pub fn verbose_asm(&mut self, verbose_asm: bool) -> &mut Self

pub fn callbacks(&mut self, callbacks: Option<LLVMCallbacks>) -> &mut Self

Callbacks that will triggered in the different compilation phases in LLVM.

pub fn non_volatile_memops( &mut self, enable_non_volatile_memops: bool, ) -> &mut Self

For the LLVM compiler, we can use non-volatile memory operations which lead to a better performance (but are not 100% SPEC compliant).

pub fn readonly_funcref_table( &mut self, enable_readonly_funcref_table: bool, ) -> &mut Self

Enables treating eligible funcref tables as read-only so the backend can place them in read-only data.

fn reloc_mode(&self, binary_format: BinaryFormat) -> RelocMode

fn code_model(&self, binary_format: BinaryFormat) -> CodeModel

pub(crate) fn target_operating_system(&self, target: &Target) -> OperatingSystem

pub(crate) fn target_binary_format(&self, target: &Target) -> BinaryFormat

fn target_triple(&self, target: &Target) -> TargetTriple

pub fn target_machine(&self, target: &Target) -> TargetMachine

Generates the target machine for the current target

pub(crate) fn target_machine_with_opt( &self, target: &Target, opt_style: OptimizationStyle, ) -> TargetMachine

Trait Implementations

impl Clone for LLVM

fn clone(&self) -> LLVM

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CompilerConfig for LLVM

fn enable_pic(&mut self)

Emit code suitable for dlopen.

fn enable_verifier(&mut self)

Whether to verify compiler IR.

fn enable_non_volatile_memops(&mut self)

For the LLVM compiler, we can use non-volatile memory operations which lead to a better performance (but are not 100% SPEC compliant).

fn enable_readonly_funcref_table(&mut self)

Enables treating eligible funcref tables as read-only so the backend can place them in read-only data.

fn compiler(self: Box<Self>) -> Box<dyn Compiler>

Transform it into the compiler.

fn push_middleware(&mut self, middleware: Arc<dyn ModuleMiddleware>)

Pushes a middleware onto the back of the middleware chain.

fn enable_perfmap(&mut self)

Enable generation of perfmaps to sample the JIT compiled frames.

fn canonicalize_nans(&mut self, enable: bool)

Enable NaN canonicalization.

fn supported_features_for_target(&self, _target: &Target) -> Features

Gets the supported features for this compiler in the given target

fn default_features_for_target(&self, target: &Target) -> Features

Gets the default features for this compiler in the given target

impl Debug for LLVM

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

Formats the value using the given formatter.

impl Default for LLVM

fn default() -> LLVM

Returns the “default value” for a type.

impl From<LLVM> for Engine

fn from(config: LLVM) -> Self

Converts to this type from the input type.