Struct Singlepass 

pub struct Singlepass {
    pub(crate) enable_nan_canonicalization: bool,
    pub(crate) allow_experimental_unaligned_memory_accesses: bool,
    pub(crate) debugger: Option<Debugger>,
    pub(crate) experimental_artifact: bool,
    pub(crate) middlewares: Vec<Arc<dyn ModuleMiddleware>>,
    pub(crate) callbacks: Option<SinglepassCallbacks>,
    pub num_threads: NonZero<usize>,
}

Fields

enable_nan_canonicalization: bool

allow_experimental_unaligned_memory_accesses: bool

debugger: Option<Debugger>

experimental_artifact: bool

middlewares: Vec<Arc<dyn ModuleMiddleware>>

The middleware chain.

callbacks: Option<SinglepassCallbacks>

num_threads: NonZero<usize>

The number of threads to use for compilation.

Implementations

impl Singlepass

pub fn new() -> Self

Creates a new configuration object with the default configuration specified.

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

Enable the experimental artifact format.

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

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

Enable run-time handling of potentially unaligned memory accesses. Unaligned memory accesses occur when you try to read N bytes of data starting from an address that is not evenly divisible by N.

This feature is experimental and currently supports only Cranelift scalar types and Singlepass on RISC-V for integral types.

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

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

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

Set the number of threads to use for compilation.

Trait Implementations

impl Clone for Singlepass

fn clone(&self) -> Singlepass

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CompilerConfig for Singlepass

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

Transform it into the compiler

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

Gets the supported features for this compiler in the given target

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

Pushes a middleware onto the back of the middleware chain.

fn experimental_artifact(&mut self, enable: bool)

Enable the experimental artifact format.

fn enable_pic(&mut self)

Enable Position Independent Code (PIC).

fn enable_debugger(&mut self, debugger: Debugger)

Enable generation of a debugger command file for JIT compiled frames.

fn enable_verifier(&mut self)

Enable compiler IR verification.

fn enable_perfmap(&mut self)

Enable generation of perfmaps to sample the JIT compiled frames.

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_experimental_unaligned_memory_accesses(&mut self)

Enable run-time handling of potentially unaligned memory accesses.

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 canonicalize_nans(&mut self, _enable: bool)

Enable NaN canonicalization.

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

Gets the default features for this compiler in the given target

impl Debug for Singlepass

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

Formats the value using the given formatter.

impl Default for Singlepass

fn default() -> Singlepass

Returns the “default value” for a type.

impl From<Singlepass> for Engine

fn from(config: Singlepass) -> Self

Converts to this type from the input type.