2024-12-29 06:30:29 -06:00
|
|
|
#![feature(if_let_guard)]
|
|
|
|
#![feature(slice_take)]
|
|
|
|
use {
|
2024-12-29 09:37:24 -06:00
|
|
|
core::panic,
|
2024-12-29 06:30:29 -06:00
|
|
|
cranelift_codegen::{
|
|
|
|
CodegenError, Final, FinalizedMachReloc, MachBufferFinalized,
|
2024-12-29 09:37:24 -06:00
|
|
|
ir::{InstBuilder, MemFlags, UserExternalName},
|
|
|
|
isa::{LookupError, TargetIsa},
|
2024-12-29 06:30:29 -06:00
|
|
|
settings::Configurable,
|
|
|
|
},
|
|
|
|
cranelift_frontend::FunctionBuilder,
|
|
|
|
cranelift_module::{Module, ModuleError},
|
|
|
|
hblang::{
|
2024-12-29 09:37:24 -06:00
|
|
|
lexer::TokenKind,
|
2024-12-29 06:30:29 -06:00
|
|
|
nodes::Kind,
|
|
|
|
utils::{Ent, EntVec},
|
|
|
|
},
|
2024-12-29 09:37:24 -06:00
|
|
|
std::{fmt::Display, ops::Range, usize},
|
2024-12-29 06:30:29 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
mod x86_64;
|
|
|
|
|
|
|
|
pub struct Backend {
|
|
|
|
ctx: cranelift_codegen::Context,
|
|
|
|
dt_ctx: cranelift_module::DataDescription,
|
|
|
|
fb_ctx: cranelift_frontend::FunctionBuilderContext,
|
|
|
|
module: Option<cranelift_object::ObjectModule>,
|
|
|
|
ctrl_plane: cranelift_codegen::control::ControlPlane,
|
|
|
|
funcs: Functions,
|
|
|
|
globals: EntVec<hblang::ty::Global, Global>,
|
|
|
|
asm: Assembler,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Backend {
|
|
|
|
pub fn new(triple: target_lexicon::Triple) -> Result<Self, BackendCreationError> {
|
|
|
|
Ok(Self {
|
|
|
|
ctx: cranelift_codegen::Context::new(),
|
|
|
|
dt_ctx: cranelift_module::DataDescription::new(),
|
|
|
|
fb_ctx: cranelift_frontend::FunctionBuilderContext::default(),
|
|
|
|
ctrl_plane: cranelift_codegen::control::ControlPlane::default(),
|
|
|
|
module: cranelift_object::ObjectModule::new(cranelift_object::ObjectBuilder::new(
|
|
|
|
cranelift_codegen::isa::lookup(triple)?.finish(
|
|
|
|
cranelift_codegen::settings::Flags::new({
|
|
|
|
let mut bl = cranelift_codegen::settings::builder();
|
|
|
|
bl.set("enable_verifier", "true").unwrap();
|
|
|
|
bl
|
|
|
|
}),
|
|
|
|
)?,
|
|
|
|
"main",
|
|
|
|
cranelift_module::default_libcall_names(),
|
|
|
|
)?)
|
|
|
|
.into(),
|
|
|
|
funcs: Default::default(),
|
|
|
|
globals: Default::default(),
|
|
|
|
asm: Default::default(),
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl hblang::backend::Backend for Backend {
|
|
|
|
fn assemble_reachable(
|
|
|
|
&mut self,
|
|
|
|
from: hblang::ty::Func,
|
|
|
|
types: &hblang::ty::Types,
|
|
|
|
files: &hblang::utils::EntSlice<hblang::ty::Module, hblang::parser::Ast>,
|
|
|
|
to: &mut Vec<u8>,
|
|
|
|
) -> hblang::backend::AssemblySpec {
|
|
|
|
debug_assert!(self.asm.frontier.is_empty());
|
|
|
|
debug_assert!(self.asm.funcs.is_empty());
|
|
|
|
debug_assert!(self.asm.globals.is_empty());
|
|
|
|
|
|
|
|
let mut module = self.module.take().expect("backend can assemble only once");
|
|
|
|
|
|
|
|
fn clif_name_to_ty(name: UserExternalName) -> hblang::ty::Id {
|
|
|
|
match name.namespace {
|
|
|
|
0 => hblang::ty::Kind::Func(hblang::ty::Func::new(name.index as _)),
|
|
|
|
1 => hblang::ty::Kind::Global(hblang::ty::Global::new(name.index as _)),
|
|
|
|
_ => unreachable!(),
|
|
|
|
}
|
|
|
|
.compress()
|
|
|
|
}
|
|
|
|
|
|
|
|
self.globals.shadow(types.ins.globals.len());
|
|
|
|
|
|
|
|
self.asm.frontier.push(from.into());
|
|
|
|
while let Some(itm) = self.asm.frontier.pop() {
|
|
|
|
match itm.expand() {
|
|
|
|
hblang::ty::Kind::Func(func) => {
|
|
|
|
let fuc = &mut self.funcs.headers[func];
|
2024-12-29 09:37:24 -06:00
|
|
|
if fuc.module_id.is_some() {
|
|
|
|
continue;
|
|
|
|
}
|
2024-12-29 06:30:29 -06:00
|
|
|
self.asm.funcs.push(func);
|
|
|
|
self.asm.frontier.extend(
|
|
|
|
fuc.external_names.clone().map(|r| {
|
|
|
|
clif_name_to_ty(self.funcs.external_names[r as usize].clone())
|
|
|
|
}),
|
|
|
|
);
|
|
|
|
self.asm.name.clear();
|
|
|
|
if func == from {
|
|
|
|
self.asm.name.push_str("main");
|
|
|
|
} else {
|
|
|
|
let file = &files[types.ins.funcs[func].file];
|
2024-12-29 09:37:24 -06:00
|
|
|
self.asm.name.push_str(hblang::strip_cwd(&file.path));
|
2024-12-29 06:30:29 -06:00
|
|
|
self.asm.name.push('.');
|
|
|
|
self.asm.name.push_str(file.ident_str(types.ins.funcs[func].name));
|
|
|
|
}
|
|
|
|
let linkage = if func == from {
|
|
|
|
cranelift_module::Linkage::Export
|
|
|
|
} else {
|
|
|
|
cranelift_module::Linkage::Local
|
|
|
|
};
|
|
|
|
build_signature(
|
|
|
|
module.isa().default_call_conv(),
|
|
|
|
types.ins.funcs[func].sig,
|
|
|
|
types,
|
|
|
|
&mut self.ctx.func.signature,
|
|
|
|
&mut vec![],
|
|
|
|
);
|
|
|
|
fuc.module_id = Some(
|
|
|
|
module
|
|
|
|
.declare_function(&self.asm.name, linkage, &self.ctx.func.signature)
|
|
|
|
.unwrap(),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
hblang::ty::Kind::Global(glob) => {
|
2024-12-29 09:37:24 -06:00
|
|
|
if self.globals[glob].module_id.is_some() {
|
|
|
|
continue;
|
|
|
|
}
|
2024-12-29 06:30:29 -06:00
|
|
|
self.asm.globals.push(glob);
|
|
|
|
self.asm.name.clear();
|
|
|
|
let file = &files[types.ins.globals[glob].file];
|
2024-12-29 09:37:24 -06:00
|
|
|
self.asm.name.push_str(hblang::strip_cwd(&file.path));
|
2024-12-29 06:30:29 -06:00
|
|
|
self.asm.name.push('.');
|
|
|
|
self.asm.name.push_str(file.ident_str(types.ins.globals[glob].name));
|
|
|
|
self.globals[glob].module_id = Some(
|
|
|
|
module
|
|
|
|
.declare_data(
|
|
|
|
&self.asm.name,
|
|
|
|
cranelift_module::Linkage::Local,
|
|
|
|
true,
|
|
|
|
false,
|
|
|
|
)
|
|
|
|
.unwrap(),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
_ => unreachable!(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for &func in &self.asm.funcs {
|
|
|
|
let fuc = &self.funcs.headers[func];
|
|
|
|
debug_assert!(!fuc.code.is_empty());
|
|
|
|
let names = &mut self.funcs.external_names
|
|
|
|
[fuc.external_names.start as usize..fuc.external_names.end as usize];
|
|
|
|
names.iter_mut().for_each(|nm| {
|
2024-12-29 09:37:24 -06:00
|
|
|
nm.index = self.funcs.headers[hblang::ty::Func::new(nm.index as _)]
|
|
|
|
.module_id
|
|
|
|
.unwrap()
|
|
|
|
.as_u32();
|
2024-12-29 06:30:29 -06:00
|
|
|
self.ctx.func.params.ensure_user_func_name(nm.clone());
|
|
|
|
});
|
|
|
|
module
|
|
|
|
.define_function_bytes(
|
|
|
|
fuc.module_id.unwrap(),
|
|
|
|
&self.ctx.func,
|
|
|
|
fuc.alignment as _,
|
|
|
|
&self.funcs.code[fuc.code.start as usize..fuc.code.end as usize],
|
|
|
|
&self.funcs.relocs[fuc.relocs.start as usize..fuc.relocs.end as usize],
|
|
|
|
)
|
|
|
|
.unwrap();
|
|
|
|
}
|
|
|
|
|
|
|
|
for global in self.asm.globals.drain(..) {
|
|
|
|
let glob = &self.globals[global];
|
|
|
|
self.dt_ctx.clear();
|
|
|
|
self.dt_ctx.define(types.ins.globals[global].data.clone().into());
|
|
|
|
module.define_data(glob.module_id.unwrap(), &self.dt_ctx).unwrap();
|
|
|
|
}
|
|
|
|
|
|
|
|
module.finish().object.write_stream(to).unwrap();
|
|
|
|
|
|
|
|
hblang::backend::AssemblySpec { code_length: 0, data_length: 0, entry: 0 }
|
|
|
|
}
|
|
|
|
|
|
|
|
fn disasm<'a>(
|
|
|
|
&'a self,
|
|
|
|
_sluce: &[u8],
|
|
|
|
_eca_handler: &mut dyn FnMut(&mut &[u8]),
|
|
|
|
_types: &'a hblang::ty::Types,
|
|
|
|
_files: &'a hblang::utils::EntSlice<hblang::ty::Module, hblang::parser::Ast>,
|
|
|
|
_output: &mut String,
|
|
|
|
) -> Result<(), std::boxed::Box<dyn core::error::Error + Send + Sync + 'a>> {
|
|
|
|
unimplemented!()
|
|
|
|
}
|
|
|
|
|
|
|
|
fn emit_body(
|
|
|
|
&mut self,
|
|
|
|
id: hblang::ty::Func,
|
|
|
|
nodes: &hblang::nodes::Nodes,
|
|
|
|
tys: &hblang::ty::Types,
|
|
|
|
files: &hblang::utils::EntSlice<hblang::ty::Module, hblang::parser::Ast>,
|
|
|
|
) {
|
|
|
|
self.ctx.clear();
|
2024-12-29 09:37:24 -06:00
|
|
|
let isa = self.module.as_ref().unwrap().isa();
|
2024-12-29 06:30:29 -06:00
|
|
|
|
|
|
|
let mut lens = vec![];
|
|
|
|
let stack_ret = build_signature(
|
2024-12-29 09:37:24 -06:00
|
|
|
isa.default_call_conv(),
|
2024-12-29 06:30:29 -06:00
|
|
|
tys.ins.funcs[id].sig,
|
|
|
|
tys,
|
|
|
|
&mut self.ctx.func.signature,
|
|
|
|
&mut lens,
|
|
|
|
);
|
|
|
|
|
|
|
|
FuncBuilder {
|
|
|
|
bl: FunctionBuilder::new(&mut self.ctx.func, &mut self.fb_ctx),
|
2024-12-29 09:37:24 -06:00
|
|
|
isa,
|
2024-12-29 06:30:29 -06:00
|
|
|
nodes,
|
|
|
|
tys,
|
|
|
|
files,
|
|
|
|
values: &mut vec![None; nodes.len()],
|
|
|
|
}
|
|
|
|
.build(tys.ins.funcs[id].sig, &lens, stack_ret);
|
|
|
|
|
2024-12-29 09:37:24 -06:00
|
|
|
self.ctx.func.name =
|
|
|
|
cranelift_codegen::ir::UserFuncName::User(cranelift_codegen::ir::UserExternalName {
|
|
|
|
namespace: 0,
|
|
|
|
index: id.index() as _,
|
|
|
|
});
|
|
|
|
|
|
|
|
std::eprintln!("{}", self.ctx.func.display());
|
|
|
|
|
|
|
|
self.ctx.compile(isa, &mut self.ctrl_plane).unwrap();
|
2024-12-29 06:30:29 -06:00
|
|
|
let code = self.ctx.compiled_code().unwrap();
|
|
|
|
self.funcs.push(id, &self.ctx.func, &code.buffer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn build_signature(
|
|
|
|
call_conv: cranelift_codegen::isa::CallConv,
|
|
|
|
sig: hblang::ty::Sig,
|
|
|
|
types: &hblang::ty::Types,
|
|
|
|
signature: &mut cranelift_codegen::ir::Signature,
|
|
|
|
arg_lens: &mut Vec<usize>,
|
|
|
|
) -> bool {
|
|
|
|
signature.clear(call_conv);
|
|
|
|
match call_conv {
|
|
|
|
cranelift_codegen::isa::CallConv::SystemV => {
|
|
|
|
x86_64::build_systemv_signature(sig, types, signature, arg_lens)
|
|
|
|
}
|
|
|
|
_ => todo!(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
struct FuncBuilder<'a, 'b> {
|
|
|
|
bl: cranelift_frontend::FunctionBuilder<'b>,
|
2024-12-29 09:37:24 -06:00
|
|
|
isa: &'a dyn TargetIsa,
|
2024-12-29 06:30:29 -06:00
|
|
|
nodes: &'a hblang::nodes::Nodes,
|
|
|
|
tys: &'a hblang::ty::Types,
|
|
|
|
files: &'a hblang::utils::EntSlice<hblang::ty::Module, hblang::parser::Ast>,
|
|
|
|
values: &'b mut [Option<Result<cranelift_codegen::ir::Value, cranelift_codegen::ir::Block>>],
|
|
|
|
}
|
|
|
|
|
|
|
|
impl FuncBuilder<'_, '_> {
|
|
|
|
pub fn build(mut self, sig: hblang::ty::Sig, arg_lens: &[usize], stack_ret: bool) {
|
|
|
|
let entry = self.bl.create_block();
|
|
|
|
self.bl.append_block_params_for_function_params(entry);
|
|
|
|
self.bl.switch_to_block(entry);
|
|
|
|
let mut arg_vals = self.bl.block_params(entry);
|
|
|
|
|
|
|
|
if stack_ret {
|
|
|
|
let ret_ptr = *arg_vals.take_first().unwrap();
|
|
|
|
self.values[hblang::nodes::MEM as usize] = Some(Ok(ret_ptr));
|
|
|
|
}
|
|
|
|
|
|
|
|
let Self { nodes, tys, .. } = self;
|
|
|
|
|
|
|
|
let mut parama_len = arg_lens.iter();
|
|
|
|
let mut typs = sig.args.args();
|
|
|
|
let mut args = nodes[hblang::nodes::VOID].outputs[hblang::nodes::ARG_START..].iter();
|
|
|
|
while let Some(aty) = typs.next(tys) {
|
|
|
|
let hblang::ty::Arg::Value(ty) = aty else { continue };
|
|
|
|
let loc = arg_vals.take(..*parama_len.next().unwrap()).unwrap();
|
|
|
|
let &arg = args.next().unwrap();
|
|
|
|
if ty.is_aggregate(tys) {
|
|
|
|
todo!()
|
|
|
|
} else {
|
2024-12-29 09:37:24 -06:00
|
|
|
debug_assert_eq!(loc.len(), 1);
|
2024-12-29 06:30:29 -06:00
|
|
|
self.values[arg as usize] = Some(Ok(loc[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
self.values[hblang::nodes::ENTRY as usize] = Some(Err(entry));
|
|
|
|
|
|
|
|
self.emit_node(hblang::nodes::VOID, hblang::nodes::VOID);
|
|
|
|
|
|
|
|
self.bl.finalize();
|
|
|
|
}
|
|
|
|
|
|
|
|
fn value_of(&self, nid: hblang::nodes::Nid) -> cranelift_codegen::ir::Value {
|
2024-12-29 09:37:24 -06:00
|
|
|
self.values[nid as usize].unwrap_or_else(|| panic!("{:?}", self.nodes[nid])).unwrap()
|
2024-12-29 06:30:29 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
fn block_of(&self, nid: hblang::nodes::Nid) -> cranelift_codegen::ir::Block {
|
|
|
|
self.values[nid as usize].unwrap().unwrap_err()
|
|
|
|
}
|
|
|
|
|
|
|
|
fn close_block(&mut self, nid: hblang::nodes::Nid) {
|
2024-12-29 09:37:24 -06:00
|
|
|
if matches!(self.nodes[nid].kind, Kind::Loop) {
|
2024-12-29 06:30:29 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
self.bl.seal_block(self.block_of(nid));
|
|
|
|
}
|
|
|
|
|
|
|
|
fn emit_node(&mut self, nid: hblang::nodes::Nid, block: hblang::nodes::Nid) {
|
|
|
|
use hblang::nodes::*;
|
|
|
|
|
|
|
|
let mut args = vec![];
|
|
|
|
if matches!(self.nodes[nid].kind, Kind::Region | Kind::Loop) {
|
|
|
|
let side = 1 + self.values[nid as usize].is_some() as usize;
|
|
|
|
for &o in self.nodes[nid].outputs.iter() {
|
|
|
|
if self.nodes[o].is_data_phi() {
|
2024-12-29 09:37:24 -06:00
|
|
|
args.push(self.value_of(self.nodes[o].inputs[side]));
|
2024-12-29 06:30:29 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
match (self.nodes[nid].kind, self.values[nid as usize]) {
|
|
|
|
(Kind::Loop, Some(blck)) => {
|
|
|
|
self.bl.ins().jump(blck.unwrap_err(), &args);
|
|
|
|
self.bl.seal_block(blck.unwrap_err());
|
2024-12-29 09:37:24 -06:00
|
|
|
self.close_block(block);
|
2024-12-29 06:30:29 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
(Kind::Region, None) => {
|
|
|
|
let next = self.bl.create_block();
|
|
|
|
for &o in self.nodes[nid].outputs.iter() {
|
|
|
|
if self.nodes[o].is_data_phi() {
|
|
|
|
self.values[o as usize] = Some(Ok(self.bl.append_block_param(
|
|
|
|
next,
|
|
|
|
ty_to_clif_ty(self.nodes[o].ty, self.tys),
|
|
|
|
)));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
self.bl.ins().jump(next, &args);
|
2024-12-29 09:37:24 -06:00
|
|
|
self.close_block(block);
|
2024-12-29 06:30:29 -06:00
|
|
|
self.values[nid as usize] = Some(Err(next));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
_ => {}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
let node = &self.nodes[nid];
|
|
|
|
self.values[nid as usize] = Some(match node.kind {
|
|
|
|
Kind::Start => {
|
|
|
|
debug_assert_eq!(self.nodes[node.outputs[0]].kind, Kind::Entry);
|
|
|
|
self.emit_node(node.outputs[0], block);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
Kind::If => {
|
|
|
|
let &[_, cnd] = node.inputs.as_slice() else { unreachable!() };
|
|
|
|
let &[then, else_] = node.outputs.as_slice() else { unreachable!() };
|
|
|
|
|
|
|
|
let then_bl = self.bl.create_block();
|
|
|
|
let else_bl = self.bl.create_block();
|
|
|
|
let c = self.value_of(cnd);
|
|
|
|
self.bl.ins().brif(c, then_bl, &[], else_bl, &[]);
|
|
|
|
self.values[then as usize] = Some(Err(then_bl));
|
|
|
|
self.values[else_ as usize] = Some(Err(else_bl));
|
|
|
|
|
|
|
|
self.close_block(block);
|
|
|
|
self.bl.switch_to_block(then_bl);
|
|
|
|
self.emit_node(then, then);
|
|
|
|
self.bl.switch_to_block(else_bl);
|
|
|
|
self.emit_node(else_, else_);
|
|
|
|
Err(self.block_of(block))
|
|
|
|
}
|
2024-12-29 09:37:24 -06:00
|
|
|
Kind::Loop => {
|
|
|
|
let next = self.bl.create_block();
|
|
|
|
for &o in self.nodes[nid].outputs.iter() {
|
|
|
|
if self.nodes[o].is_data_phi() {
|
|
|
|
self.values[o as usize] = Some(Ok(self
|
|
|
|
.bl
|
|
|
|
.append_block_param(next, ty_to_clif_ty(self.nodes[o].ty, self.tys))));
|
2024-12-29 06:30:29 -06:00
|
|
|
}
|
|
|
|
}
|
2024-12-29 09:37:24 -06:00
|
|
|
self.values[nid as usize] = Some(Err(next));
|
2024-12-29 06:30:29 -06:00
|
|
|
self.bl.ins().jump(self.values[nid as usize].unwrap().unwrap_err(), &args);
|
|
|
|
self.close_block(block);
|
|
|
|
self.bl.switch_to_block(self.values[nid as usize].unwrap().unwrap_err());
|
|
|
|
for &o in node.outputs.iter().rev() {
|
|
|
|
self.emit_node(o, nid);
|
|
|
|
}
|
|
|
|
Err(self.block_of(block))
|
|
|
|
}
|
2024-12-29 09:37:24 -06:00
|
|
|
Kind::Region => {
|
|
|
|
self.bl.ins().jump(self.values[nid as usize].unwrap().unwrap_err(), &args);
|
|
|
|
self.close_block(block);
|
|
|
|
self.bl.switch_to_block(self.values[nid as usize].unwrap().unwrap_err());
|
|
|
|
for &o in node.outputs.iter().rev() {
|
|
|
|
self.emit_node(o, nid);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
2024-12-29 06:30:29 -06:00
|
|
|
Kind::Return { .. } | Kind::Die => {
|
|
|
|
let ret = self.value_of(node.inputs[1]);
|
|
|
|
self.bl.ins().return_(&[ret]);
|
|
|
|
self.close_block(block);
|
|
|
|
self.emit_node(node.outputs[0], block);
|
|
|
|
Err(self.block_of(block))
|
|
|
|
}
|
|
|
|
Kind::Entry => {
|
|
|
|
for &o in node.outputs.iter().rev() {
|
|
|
|
self.emit_node(o, nid);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
Kind::Then | Kind::Else => {
|
|
|
|
for &o in node.outputs.iter().rev() {
|
|
|
|
self.emit_node(o, block);
|
|
|
|
}
|
|
|
|
Err(self.block_of(block))
|
|
|
|
}
|
2024-12-29 09:37:24 -06:00
|
|
|
Kind::Call { func, unreachable, args } => {
|
2024-12-29 06:30:29 -06:00
|
|
|
if unreachable {
|
|
|
|
todo!()
|
|
|
|
} else {
|
2024-12-29 09:37:24 -06:00
|
|
|
let mut arg_lens = vec![];
|
|
|
|
let mut signature =
|
|
|
|
cranelift_codegen::ir::Signature::new(self.isa.default_call_conv());
|
|
|
|
let stack_ret = build_signature(
|
|
|
|
self.isa.default_call_conv(),
|
|
|
|
self.tys.ins.funcs[func].sig,
|
|
|
|
self.tys,
|
|
|
|
&mut signature,
|
|
|
|
&mut arg_lens,
|
|
|
|
);
|
|
|
|
assert!(!stack_ret, "TODO");
|
|
|
|
let func_ref = 'b: {
|
|
|
|
let user_name_ref = self.bl.func.declare_imported_user_function(
|
|
|
|
cranelift_codegen::ir::UserExternalName {
|
|
|
|
namespace: 0,
|
|
|
|
index: func.index() as _,
|
|
|
|
},
|
|
|
|
);
|
|
|
|
|
|
|
|
if let Some(id) = self.bl.func.dfg.ext_funcs.keys().find(|&k| {
|
|
|
|
self.bl.func.dfg.ext_funcs[k].name
|
|
|
|
== cranelift_codegen::ir::ExternalName::user(user_name_ref)
|
|
|
|
}) {
|
|
|
|
break 'b id;
|
|
|
|
}
|
|
|
|
|
|
|
|
let signature = self.bl.func.import_signature(signature);
|
|
|
|
|
|
|
|
self.bl.func.import_function(cranelift_codegen::ir::ExtFuncData {
|
|
|
|
name: cranelift_codegen::ir::ExternalName::user(user_name_ref),
|
|
|
|
signature,
|
|
|
|
colocated: true,
|
|
|
|
})
|
|
|
|
};
|
|
|
|
|
|
|
|
let args = node.inputs[1..][..args.len()]
|
|
|
|
.iter()
|
|
|
|
.map(|&n| self.value_of(n))
|
|
|
|
.collect::<Vec<_>>();
|
|
|
|
let inst = self.bl.ins().call(func_ref, &args);
|
|
|
|
match *self.bl.inst_results(inst) {
|
|
|
|
[] => {}
|
|
|
|
[scala] => self.values[nid as usize] = Some(Ok(scala)),
|
|
|
|
_ => todo!(),
|
|
|
|
}
|
|
|
|
for &o in node.outputs.iter().rev() {
|
|
|
|
if self.nodes[o].inputs[0] == nid
|
|
|
|
|| (matches!(self.nodes[o].kind, Kind::Loop | Kind::Region)
|
|
|
|
&& self.nodes[o].inputs[1] == nid)
|
|
|
|
{
|
|
|
|
self.emit_node(o, block);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
2024-12-29 06:30:29 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
Kind::CInt { value } if self.nodes[nid].ty.is_integer() => Ok(self.bl.ins().iconst(
|
|
|
|
cranelift_codegen::ir::Type::int(self.tys.size_of(self.nodes[nid].ty) as u16 * 8)
|
|
|
|
.unwrap(),
|
|
|
|
value,
|
|
|
|
)),
|
|
|
|
Kind::CInt { value } => Ok(match self.tys.size_of(self.nodes[nid].ty) {
|
|
|
|
4 => self.bl.ins().f32const(f64::from_bits(value as _) as f32),
|
|
|
|
8 => self.bl.ins().f64const(f64::from_bits(value as _)),
|
|
|
|
_ => unimplemented!(),
|
|
|
|
}),
|
2024-12-29 09:37:24 -06:00
|
|
|
Kind::BinOp { op } => {
|
|
|
|
let &[_, lhs, rhs] = node.inputs.as_slice() else { unreachable!() };
|
|
|
|
let [lhs, rhs] = [self.value_of(lhs), self.value_of(rhs)];
|
|
|
|
assert!(
|
|
|
|
node.ty.is_integer() || node.ty == hblang::ty::Id::BOOL,
|
|
|
|
"TODO: unsupported binary type {}",
|
|
|
|
hblang::ty::Display::new(self.tys, self.files, node.ty)
|
|
|
|
);
|
|
|
|
|
|
|
|
use cranelift_codegen::ir::condcodes::IntCC as ICC;
|
|
|
|
fn icc_of(op: TokenKind, signed: bool) -> ICC {
|
|
|
|
match op {
|
|
|
|
TokenKind::Lt if signed => ICC::SignedLessThan,
|
|
|
|
TokenKind::Gt if signed => ICC::SignedGreaterThan,
|
|
|
|
TokenKind::Le if signed => ICC::SignedLessThanOrEqual,
|
|
|
|
TokenKind::Ge if signed => ICC::SignedGreaterThanOrEqual,
|
|
|
|
|
|
|
|
TokenKind::Lt => ICC::UnsignedLessThan,
|
|
|
|
TokenKind::Gt => ICC::UnsignedGreaterThan,
|
|
|
|
TokenKind::Le => ICC::UnsignedLessThanOrEqual,
|
|
|
|
TokenKind::Ge => ICC::UnsignedGreaterThanOrEqual,
|
|
|
|
|
|
|
|
TokenKind::Eq => ICC::Equal,
|
|
|
|
TokenKind::Ne => ICC::NotEqual,
|
|
|
|
_ => unreachable!(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
use cranelift_codegen::ir::condcodes::FloatCC as FCC;
|
|
|
|
fn fcc_of(op: TokenKind) -> FCC {
|
|
|
|
match op {
|
|
|
|
TokenKind::Lt => FCC::LessThan,
|
|
|
|
TokenKind::Gt => FCC::GreaterThan,
|
|
|
|
TokenKind::Le => FCC::LessThanOrEqual,
|
|
|
|
TokenKind::Ge => FCC::GreaterThanOrEqual,
|
|
|
|
TokenKind::Eq => FCC::Equal,
|
|
|
|
TokenKind::Ne => FCC::NotEqual,
|
|
|
|
_ => unreachable!(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(if node.ty.is_integer() {
|
|
|
|
let signed = node.ty.is_signed();
|
|
|
|
match op {
|
|
|
|
TokenKind::Add => self.bl.ins().iadd(lhs, rhs),
|
|
|
|
TokenKind::Sub => self.bl.ins().isub(lhs, rhs),
|
|
|
|
TokenKind::Mul => self.bl.ins().imul(lhs, rhs),
|
|
|
|
TokenKind::Shl => self.bl.ins().ishl(lhs, rhs),
|
|
|
|
TokenKind::Xor => self.bl.ins().bxor(lhs, rhs),
|
|
|
|
TokenKind::Band => self.bl.ins().band(lhs, rhs),
|
|
|
|
TokenKind::Bor => self.bl.ins().bor(lhs, rhs),
|
|
|
|
|
|
|
|
TokenKind::Div if signed => self.bl.ins().sdiv(lhs, rhs),
|
|
|
|
TokenKind::Mod if signed => self.bl.ins().srem(lhs, rhs),
|
|
|
|
TokenKind::Shr if signed => self.bl.ins().sshr(lhs, rhs),
|
|
|
|
|
|
|
|
TokenKind::Div => self.bl.ins().udiv(lhs, rhs),
|
|
|
|
TokenKind::Mod => self.bl.ins().urem(lhs, rhs),
|
|
|
|
TokenKind::Shr => self.bl.ins().ushr(lhs, rhs),
|
|
|
|
|
|
|
|
TokenKind::Lt
|
|
|
|
| TokenKind::Gt
|
|
|
|
| TokenKind::Le
|
|
|
|
| TokenKind::Ge
|
|
|
|
| TokenKind::Eq
|
|
|
|
| TokenKind::Ne => self.bl.ins().icmp(icc_of(op, signed), lhs, rhs),
|
|
|
|
op => todo!("{op}"),
|
|
|
|
}
|
|
|
|
} else if node.ty.is_float() {
|
|
|
|
match op {
|
|
|
|
TokenKind::Add => self.bl.ins().fadd(lhs, rhs),
|
|
|
|
TokenKind::Sub => self.bl.ins().fsub(lhs, rhs),
|
|
|
|
TokenKind::Mul => self.bl.ins().fmul(lhs, rhs),
|
|
|
|
TokenKind::Div => self.bl.ins().fdiv(lhs, rhs),
|
|
|
|
|
|
|
|
TokenKind::Lt
|
|
|
|
| TokenKind::Gt
|
|
|
|
| TokenKind::Le
|
|
|
|
| TokenKind::Ge
|
|
|
|
| TokenKind::Eq
|
|
|
|
| TokenKind::Ne => self.bl.ins().fcmp(fcc_of(op), lhs, rhs),
|
|
|
|
op => todo!("{op}"),
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
todo!()
|
|
|
|
})
|
|
|
|
}
|
|
|
|
Kind::RetVal => Ok(self.value_of(node.inputs[0])),
|
|
|
|
Kind::UnOp { op } => {
|
|
|
|
let oper = self.value_of(node.inputs[1]);
|
|
|
|
let dst = node.ty;
|
|
|
|
let src = self
|
|
|
|
.tys
|
|
|
|
.inner_of(self.nodes[node.inputs[1]].ty)
|
|
|
|
.unwrap_or(self.nodes[node.inputs[1]].ty);
|
|
|
|
|
|
|
|
let dty = ty_to_clif_ty(dst, self.tys);
|
|
|
|
Ok(match op {
|
|
|
|
TokenKind::Sub => self.bl.ins().ineg(oper),
|
|
|
|
TokenKind::Not => self.bl.ins().bnot(oper),
|
|
|
|
TokenKind::Float if dst.is_float() && src.is_unsigned() => {
|
|
|
|
self.bl.ins().fcvt_from_uint(dty, oper)
|
|
|
|
}
|
|
|
|
TokenKind::Float if dst.is_float() && src.is_signed() => {
|
|
|
|
self.bl.ins().fcvt_from_sint(dty, oper)
|
|
|
|
}
|
|
|
|
TokenKind::Number if src.is_float() && dst.is_unsigned() => {
|
|
|
|
self.bl.ins().fcvt_to_uint(dty, oper)
|
|
|
|
}
|
|
|
|
TokenKind::Number
|
|
|
|
if src.is_signed() && (dst.is_integer() || dst.is_pointer()) =>
|
|
|
|
{
|
|
|
|
self.bl.ins().sextend(dty, oper)
|
|
|
|
}
|
|
|
|
TokenKind::Number
|
|
|
|
if (src.is_unsigned() || src == hblang::ty::Id::BOOL)
|
|
|
|
&& (dst.is_integer() || dst.is_pointer()) =>
|
|
|
|
{
|
|
|
|
self.bl.ins().uextend(dty, oper)
|
|
|
|
}
|
|
|
|
TokenKind::Float if dst == hblang::ty::Id::F64 && src.is_float() => {
|
|
|
|
self.bl.ins().fpromote(dty, oper)
|
|
|
|
}
|
|
|
|
TokenKind::Float if dst == hblang::ty::Id::F32 && src.is_float() => {
|
|
|
|
self.bl.ins().fdemote(dty, oper)
|
|
|
|
}
|
|
|
|
_ => todo!(),
|
|
|
|
})
|
|
|
|
}
|
|
|
|
Kind::Stck => {
|
|
|
|
let slot = self.bl.create_sized_stack_slot(cranelift_codegen::ir::StackSlotData {
|
|
|
|
kind: cranelift_codegen::ir::StackSlotKind::ExplicitSlot,
|
|
|
|
size: self.tys.size_of(node.ty),
|
|
|
|
align_shift: self.tys.align_of(node.ty).ilog2() as _,
|
|
|
|
});
|
|
|
|
|
|
|
|
Ok(self.bl.ins().stack_addr(cranelift_codegen::ir::types::I64, slot, 0))
|
|
|
|
}
|
|
|
|
Kind::Global { global } => {
|
|
|
|
let glob_ref = {
|
|
|
|
// already deduplicated by the SoN
|
|
|
|
let colocated = true;
|
|
|
|
let user_name_ref = self.bl.func.declare_imported_user_function(
|
|
|
|
cranelift_codegen::ir::UserExternalName {
|
|
|
|
namespace: 1,
|
|
|
|
index: global.index() as u32,
|
|
|
|
},
|
|
|
|
);
|
|
|
|
self.bl.func.create_global_value(
|
|
|
|
cranelift_codegen::ir::GlobalValueData::Symbol {
|
|
|
|
name: cranelift_codegen::ir::ExternalName::user(user_name_ref),
|
|
|
|
offset: cranelift_codegen::ir::immediates::Imm64::new(0),
|
|
|
|
colocated,
|
|
|
|
tls: false,
|
|
|
|
},
|
|
|
|
)
|
|
|
|
};
|
|
|
|
|
|
|
|
Ok(self.bl.ins().global_value(cranelift_codegen::ir::types::I64, glob_ref))
|
|
|
|
}
|
|
|
|
Kind::Load if node.ty.is_aggregate(self.tys) => return,
|
|
|
|
Kind::Load => {
|
|
|
|
let ptr = self.value_of(node.inputs[1]);
|
|
|
|
Ok(self.bl.ins().load(ty_to_clif_ty(node.ty, self.tys), MemFlags::new(), ptr, 0))
|
|
|
|
}
|
|
|
|
Kind::Stre if node.ty.is_aggregate(self.tys) => {
|
|
|
|
let src = self.value_of(self.nodes[node.inputs[1]].inputs[1]);
|
|
|
|
let dest = self.value_of(node.inputs[2]);
|
|
|
|
self.bl.emit_small_memory_copy(
|
|
|
|
self.isa.frontend_config(),
|
|
|
|
dest,
|
|
|
|
src,
|
|
|
|
self.tys.size_of(node.ty) as _,
|
|
|
|
self.tys.align_of(node.ty) as _,
|
|
|
|
self.tys.align_of(node.ty) as _,
|
|
|
|
false,
|
|
|
|
MemFlags::new(),
|
|
|
|
);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
Kind::Stre => {
|
|
|
|
let value = self.value_of(node.inputs[1]);
|
|
|
|
let ptr = self.value_of(node.inputs[2]);
|
|
|
|
self.bl.ins().store(MemFlags::new(), value, ptr, 0);
|
|
|
|
return;
|
|
|
|
}
|
2024-12-29 06:30:29 -06:00
|
|
|
Kind::End | Kind::Phi | Kind::Arg | Kind::Mem | Kind::Loops | Kind::Join => return,
|
|
|
|
Kind::Assert { .. } => unreachable!(),
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn ty_to_clif_ty(ty: hblang::ty::Id, tys: &hblang::ty::Types) -> cranelift_codegen::ir::Type {
|
|
|
|
if ty.is_integer() {
|
|
|
|
cranelift_codegen::ir::Type::int(tys.size_of(ty) as u16 * 8).unwrap()
|
|
|
|
} else {
|
|
|
|
unimplemented!()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Default)]
|
|
|
|
struct Global {
|
|
|
|
module_id: Option<cranelift_module::DataId>,
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Default)]
|
|
|
|
struct FuncHeaders {
|
|
|
|
module_id: Option<cranelift_module::FuncId>,
|
|
|
|
alignment: u32,
|
|
|
|
code: Range<u32>,
|
|
|
|
relocs: Range<u32>,
|
|
|
|
external_names: Range<u32>,
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Default)]
|
|
|
|
struct Functions {
|
|
|
|
headers: EntVec<hblang::ty::Func, FuncHeaders>,
|
|
|
|
code: Vec<u8>,
|
|
|
|
relocs: Vec<FinalizedMachReloc>,
|
|
|
|
external_names: Vec<UserExternalName>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Functions {
|
|
|
|
fn push(
|
|
|
|
&mut self,
|
|
|
|
id: hblang::ty::Func,
|
|
|
|
func: &cranelift_codegen::ir::Function,
|
|
|
|
code: &MachBufferFinalized<Final>,
|
|
|
|
) {
|
|
|
|
self.headers.shadow(id.index() + 1);
|
|
|
|
self.headers[id] = FuncHeaders {
|
|
|
|
module_id: None,
|
|
|
|
alignment: code.alignment,
|
|
|
|
code: self.code.len() as u32..self.code.len() as u32 + code.data().len() as u32,
|
|
|
|
relocs: self.relocs.len() as u32..self.relocs.len() as u32 + code.relocs().len() as u32,
|
|
|
|
external_names: self.external_names.len() as u32
|
|
|
|
..self.external_names.len() as u32 + func.params.user_named_funcs().len() as u32,
|
|
|
|
};
|
|
|
|
self.code.extend(code.data());
|
|
|
|
self.relocs.extend(code.relocs().iter().cloned());
|
|
|
|
self.external_names.extend(func.params.user_named_funcs().values().cloned());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Default)]
|
|
|
|
struct Assembler {
|
|
|
|
name: String,
|
|
|
|
frontier: Vec<hblang::ty::Id>,
|
|
|
|
globals: Vec<hblang::ty::Global>,
|
|
|
|
funcs: Vec<hblang::ty::Func>,
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Debug)]
|
|
|
|
pub enum BackendCreationError {
|
|
|
|
UnsupportedTriplet(LookupError),
|
|
|
|
InvalidFlags(CodegenError),
|
|
|
|
UnsupportedModuleConfig(ModuleError),
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Display for BackendCreationError {
|
|
|
|
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
|
|
|
|
match self {
|
|
|
|
BackendCreationError::UnsupportedTriplet(err) => {
|
|
|
|
write!(f, "Unsupported triplet: {}", err)
|
|
|
|
}
|
|
|
|
BackendCreationError::InvalidFlags(err) => {
|
|
|
|
write!(f, "Invalid flags: {}", err)
|
|
|
|
}
|
|
|
|
BackendCreationError::UnsupportedModuleConfig(err) => {
|
|
|
|
write!(f, "Unsupported module configuration: {}", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl core::error::Error for BackendCreationError {}
|
|
|
|
|
|
|
|
impl From<LookupError> for BackendCreationError {
|
|
|
|
fn from(value: LookupError) -> Self {
|
|
|
|
Self::UnsupportedTriplet(value)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl From<CodegenError> for BackendCreationError {
|
|
|
|
fn from(value: CodegenError) -> Self {
|
|
|
|
Self::InvalidFlags(value)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl From<ModuleError> for BackendCreationError {
|
|
|
|
fn from(value: ModuleError) -> Self {
|
|
|
|
Self::UnsupportedModuleConfig(value)
|
|
|
|
}
|
|
|
|
}
|