94b51cdb17
This change substitutes the string based emission mechanism with
cranelift-codegen's x64 backend.
This change _does not_:
* Introduce new functionality in terms of supported instructions.
* Change the semantics of the assembler/macroassembler in terms of the logic to
emit instructions.
The most notable differences between this change and the previous version are:
* Handling of shared flags and ISA-specific flags, which for now are left with
the default value.
* Simplification of instruction emission per operand size: previously the
assembler defined different methods depending on the operand size (e.g. `mov`
for 64 bits, and `movl` for 32 bits). This change updates such approach so that
each assembler method takes an operand size as a parameter, reducing duplication
and making the code more concise and easier to integrate with the x64's `Inst` enum.
* Introduction of a disassembler for testing purposes.
As of this change, Winch generates the following code for the following test
programs:
```wat
(module
(export "main" (func $main))
(func $main (result i32)
(i32.const 10)
(i32.const 20)
i32.add
))
```
```asm
0: 55 push rbp
1: 48 89 e5 mov rbp, rsp
4: b8 0a 00 00 00 mov eax, 0xa
9: 83 c0 14 add eax, 0x14
c: 5d pop rbp
d: c3 ret
```
```wat
(module
(export "main" (func $main))
(func $main (result i32)
(local $foo i32)
(local $bar i32)
(i32.const 10)
(local.set $foo)
(i32.const 20)
(local.set $bar)
(local.get $foo)
(local.get $bar)
i32.add
))
```
```asm
0: 55 push rbp
1: 48 89 e5 mov rbp, rsp
4: 48 83 ec 08 sub rsp, 8
8: 48 c7 04 24 00 00 00 00 mov qword ptr [rsp], 0
10: b8 0a 00 00 00 mov eax, 0xa
15: 89 44 24 04 mov dword ptr [rsp + 4], eax
19: b8 14 00 00 00 mov eax, 0x14
1e: 89 04 24 mov dword ptr [rsp], eax
21: 8b 04 24 mov eax, dword ptr [rsp]
24: 8b 4c 24 04 mov ecx, dword ptr [rsp + 4]
28: 01 c1 add ecx, eax
2a: 48 89 c8 mov rax, rcx
2d: 48 83 c4 08 add rsp, 8
31: 5d pop rbp
32: c3 ret
```
```wat
(module
(export "main" (func $main))
(func $main (param i32) (param i32) (result i32)
(local.get 0)
(local.get 1)
i32.add
))
```
```asm
0: 55 push rbp
1: 48 89 e5 mov rbp, rsp
4: 48 83 ec 08 sub rsp, 8
8: 89 7c 24 04 mov dword ptr [rsp + 4], edi
c: 89 34 24 mov dword ptr [rsp], esi
f: 8b 04 24 mov eax, dword ptr [rsp]
12: 8b 4c 24 04 mov ecx, dword ptr [rsp + 4]
16: 01 c1 add ecx, eax
18: 48 89 c8 mov rax, rcx
1b: 48 83 c4 08 add rsp, 8
1f: 5d pop rbp
20: c3 ret
```
92 lines
2.3 KiB
Rust
92 lines
2.3 KiB
Rust
use anyhow::Result;
|
|
use object::write::{Object, SymbolId};
|
|
use std::any::Any;
|
|
use wasmtime_environ::{
|
|
CompileError, DefinedFuncIndex, FuncIndex, FunctionBodyData, FunctionLoc, ModuleTranslation,
|
|
ModuleTypes, PrimaryMap, Tunables, WasmFunctionInfo,
|
|
};
|
|
use winch_codegen::TargetIsa;
|
|
|
|
pub(crate) struct Compiler {
|
|
isa: Box<dyn TargetIsa>,
|
|
}
|
|
|
|
impl Compiler {
|
|
pub fn new(isa: Box<dyn TargetIsa>) -> Self {
|
|
Self { isa }
|
|
}
|
|
}
|
|
|
|
impl wasmtime_environ::Compiler for Compiler {
|
|
fn compile_function(
|
|
&self,
|
|
_translation: &ModuleTranslation<'_>,
|
|
_index: DefinedFuncIndex,
|
|
_data: FunctionBodyData<'_>,
|
|
_tunables: &Tunables,
|
|
_types: &ModuleTypes,
|
|
) -> Result<(WasmFunctionInfo, Box<dyn Any + Send>), CompileError> {
|
|
todo!()
|
|
}
|
|
|
|
fn compile_host_to_wasm_trampoline(
|
|
&self,
|
|
_ty: &wasmtime_environ::WasmFuncType,
|
|
) -> Result<Box<dyn Any + Send>, CompileError> {
|
|
todo!()
|
|
}
|
|
|
|
fn append_code(
|
|
&self,
|
|
_obj: &mut Object<'static>,
|
|
_funcs: &[(String, Box<dyn Any + Send>)],
|
|
_tunables: &Tunables,
|
|
_resolve_reloc: &dyn Fn(usize, FuncIndex) -> usize,
|
|
) -> Result<Vec<(SymbolId, FunctionLoc)>> {
|
|
todo!()
|
|
}
|
|
|
|
fn emit_trampoline_obj(
|
|
&self,
|
|
_ty: &wasmtime_environ::WasmFuncType,
|
|
_host_fn: usize,
|
|
_obj: &mut wasmtime_environ::object::write::Object<'static>,
|
|
) -> Result<(FunctionLoc, FunctionLoc)> {
|
|
todo!()
|
|
}
|
|
|
|
fn triple(&self) -> &target_lexicon::Triple {
|
|
self.isa.triple()
|
|
}
|
|
|
|
fn page_size_align(&self) -> u64 {
|
|
todo!()
|
|
}
|
|
|
|
fn flags(&self) -> std::collections::BTreeMap<String, wasmtime_environ::FlagValue> {
|
|
todo!()
|
|
}
|
|
|
|
fn isa_flags(&self) -> std::collections::BTreeMap<String, wasmtime_environ::FlagValue> {
|
|
todo!()
|
|
}
|
|
|
|
fn is_branch_protection_enabled(&self) -> bool {
|
|
todo!()
|
|
}
|
|
|
|
#[cfg(feature = "component-model")]
|
|
fn component_compiler(&self) -> &dyn wasmtime_environ::component::ComponentCompiler {
|
|
todo!()
|
|
}
|
|
|
|
fn append_dwarf(
|
|
&self,
|
|
_obj: &mut Object<'_>,
|
|
_translation: &ModuleTranslation<'_>,
|
|
_funcs: &PrimaryMap<DefinedFuncIndex, (SymbolId, &(dyn Any + Send))>,
|
|
) -> Result<()> {
|
|
todo!()
|
|
}
|
|
}
|