use crate::compiler::LLVMCompiler;
use inkwell::targets::{
CodeModel, InitializationConfig, RelocMode, Target as InkwellTarget, TargetMachine,
TargetTriple,
};
pub use inkwell::OptimizationLevel as LLVMOptLevel;
use itertools::Itertools;
use std::fmt::Debug;
use std::sync::Arc;
use target_lexicon::Architecture;
use wasmer_compiler::{Compiler, CompilerConfig, Engine, EngineBuilder, ModuleMiddleware};
use wasmer_types::{FunctionType, LocalFunctionIndex, Target, Triple};
pub type InkwellModule<'ctx> = inkwell::module::Module<'ctx>;
pub type InkwellMemoryBuffer = inkwell::memory_buffer::MemoryBuffer;
#[derive(Debug, Clone)]
pub enum CompiledKind {
Local(LocalFunctionIndex),
FunctionCallTrampoline(FunctionType),
DynamicFunctionTrampoline(FunctionType),
Module,
}
pub trait LLVMCallbacks: Debug + Send + Sync {
fn preopt_ir(&self, function: &CompiledKind, module: &InkwellModule);
fn postopt_ir(&self, function: &CompiledKind, module: &InkwellModule);
fn obj_memory_buffer(&self, function: &CompiledKind, memory_buffer: &InkwellMemoryBuffer);
}
#[derive(Debug, Clone)]
pub struct LLVM {
pub(crate) enable_nan_canonicalization: bool,
pub(crate) enable_verifier: bool,
pub(crate) opt_level: LLVMOptLevel,
is_pic: bool,
pub(crate) callbacks: Option<Arc<dyn LLVMCallbacks>>,
pub(crate) middlewares: Vec<Arc<dyn ModuleMiddleware>>,
}
impl LLVM {
pub fn new() -> Self {
Self {
enable_nan_canonicalization: false,
enable_verifier: false,
opt_level: LLVMOptLevel::Aggressive,
is_pic: false,
callbacks: None,
middlewares: vec![],
}
}
pub fn opt_level(&mut self, opt_level: LLVMOptLevel) -> &mut Self {
self.opt_level = opt_level;
self
}
pub fn callbacks(&mut self, callbacks: Option<Arc<dyn LLVMCallbacks>>) -> &mut Self {
self.callbacks = callbacks;
self
}
fn reloc_mode(&self) -> RelocMode {
if self.is_pic {
RelocMode::PIC
} else {
RelocMode::Static
}
}
fn code_model(&self) -> CodeModel {
if self.is_pic {
CodeModel::Small
} else {
CodeModel::Large
}
}
fn target_triple(&self, target: &Target) -> TargetTriple {
let operating_system = if target.triple().operating_system
== wasmer_types::OperatingSystem::Darwin
&& !self.is_pic
{
#[allow(clippy::match_single_binding)]
match target.triple().architecture {
_ => wasmer_types::OperatingSystem::Linux,
}
} else {
target.triple().operating_system
};
let binary_format = if self.is_pic {
target.triple().binary_format
} else {
target_lexicon::BinaryFormat::Elf
};
let triple = Triple {
architecture: target.triple().architecture,
vendor: target.triple().vendor.clone(),
operating_system,
environment: target.triple().environment,
binary_format,
};
TargetTriple::create(&triple.to_string())
}
pub fn target_machine(&self, target: &Target) -> TargetMachine {
let triple = target.triple();
let cpu_features = &target.cpu_features();
match triple.architecture {
Architecture::X86_64 | Architecture::X86_32(_) => {
InkwellTarget::initialize_x86(&InitializationConfig {
asm_parser: true,
asm_printer: true,
base: true,
disassembler: true,
info: true,
machine_code: true,
})
}
Architecture::Aarch64(_) => InkwellTarget::initialize_aarch64(&InitializationConfig {
asm_parser: true,
asm_printer: true,
base: true,
disassembler: true,
info: true,
machine_code: true,
}),
_ => unimplemented!("target {} not yet supported in Wasmer", triple),
}
let llvm_cpu_features = cpu_features
.iter()
.map(|feature| format!("+{}", feature.to_string()))
.join(",");
let target_triple = self.target_triple(target);
let llvm_target = InkwellTarget::from_triple(&target_triple).unwrap();
llvm_target
.create_target_machine(
&target_triple,
"generic",
&llvm_cpu_features,
self.opt_level,
self.reloc_mode(),
self.code_model(),
)
.unwrap()
}
}
impl CompilerConfig for LLVM {
fn enable_pic(&mut self) {
self.is_pic = true;
}
fn enable_verifier(&mut self) {
self.enable_verifier = true;
}
fn enable_nan_canonicalization(&mut self) {
self.enable_nan_canonicalization = true;
}
fn canonicalize_nans(&mut self, enable: bool) {
self.enable_nan_canonicalization = enable;
}
fn compiler(self: Box<Self>) -> Box<dyn Compiler> {
Box::new(LLVMCompiler::new(*self))
}
fn push_middleware(&mut self, middleware: Arc<dyn ModuleMiddleware>) {
self.middlewares.push(middleware);
}
}
impl Default for LLVM {
fn default() -> LLVM {
Self::new()
}
}
impl From<LLVM> for Engine {
fn from(config: LLVM) -> Self {
EngineBuilder::new(config).engine()
}
}