de-rust phase-0: archive Rust LLVM backend to archive/rust-llvm-backend (RESTORE documented); defaults unaffected
This commit is contained in:
nyash-codex
@ -0,0 +1,358 @@
|
||||
use std::collections::HashMap;
|
||||
|
||||
use inkwell::values::BasicValueEnum;
|
||||
|
||||
use super::builder_cursor::BuilderCursor;
|
||||
use crate::backend::llvm::context::CodegenContext;
|
||||
use crate::mir::{function::MirFunction, BasicBlockId, CompareOp, ValueId};
|
||||
|
||||
/// Compare lowering: return the resulting BasicValueEnum (i1)
|
||||
pub(in super::super) fn lower_compare<'ctx, 'b>(
|
||||
codegen: &CodegenContext<'ctx>,
|
||||
cursor: &mut BuilderCursor<'ctx, 'b>,
|
||||
resolver: &mut super::Resolver<'ctx>,
|
||||
cur_bid: BasicBlockId,
|
||||
func: &MirFunction,
|
||||
vmap: &HashMap<ValueId, BasicValueEnum<'ctx>>,
|
||||
op: &CompareOp,
|
||||
lhs: &ValueId,
|
||||
rhs: &ValueId,
|
||||
bb_map: &std::collections::HashMap<
|
||||
crate::mir::BasicBlockId,
|
||||
inkwell::basic_block::BasicBlock<'ctx>,
|
||||
>,
|
||||
preds: &std::collections::HashMap<crate::mir::BasicBlockId, Vec<crate::mir::BasicBlockId>>,
|
||||
block_end_values: &std::collections::HashMap<
|
||||
crate::mir::BasicBlockId,
|
||||
std::collections::HashMap<ValueId, BasicValueEnum<'ctx>>,
|
||||
>,
|
||||
) -> Result<BasicValueEnum<'ctx>, String> {
|
||||
use crate::backend::llvm::compiler::helpers::{as_float, as_int};
|
||||
// Synthesize proxy values via Resolver according to metadata
|
||||
let lv: BasicValueEnum<'ctx> = match func.metadata.value_types.get(lhs) {
|
||||
Some(crate::mir::MirType::Float) => resolver
|
||||
.resolve_f64(
|
||||
codegen,
|
||||
cursor,
|
||||
cur_bid,
|
||||
*lhs,
|
||||
bb_map,
|
||||
preds,
|
||||
block_end_values,
|
||||
vmap,
|
||||
)?
|
||||
.into(),
|
||||
Some(crate::mir::MirType::String) | Some(crate::mir::MirType::Box(_)) => resolver
|
||||
.resolve_ptr(
|
||||
codegen,
|
||||
cursor,
|
||||
cur_bid,
|
||||
*lhs,
|
||||
bb_map,
|
||||
preds,
|
||||
block_end_values,
|
||||
vmap,
|
||||
)?
|
||||
.into(),
|
||||
_ => resolver
|
||||
.resolve_i64(
|
||||
codegen,
|
||||
cursor,
|
||||
cur_bid,
|
||||
*lhs,
|
||||
bb_map,
|
||||
preds,
|
||||
block_end_values,
|
||||
vmap,
|
||||
)?
|
||||
.into(),
|
||||
};
|
||||
let rv: BasicValueEnum<'ctx> = match func.metadata.value_types.get(rhs) {
|
||||
Some(crate::mir::MirType::Float) => resolver
|
||||
.resolve_f64(
|
||||
codegen,
|
||||
cursor,
|
||||
cur_bid,
|
||||
*rhs,
|
||||
bb_map,
|
||||
preds,
|
||||
block_end_values,
|
||||
vmap,
|
||||
)?
|
||||
.into(),
|
||||
Some(crate::mir::MirType::String) | Some(crate::mir::MirType::Box(_)) => resolver
|
||||
.resolve_ptr(
|
||||
codegen,
|
||||
cursor,
|
||||
cur_bid,
|
||||
*rhs,
|
||||
bb_map,
|
||||
preds,
|
||||
block_end_values,
|
||||
vmap,
|
||||
)?
|
||||
.into(),
|
||||
_ => resolver
|
||||
.resolve_i64(
|
||||
codegen,
|
||||
cursor,
|
||||
cur_bid,
|
||||
*rhs,
|
||||
bb_map,
|
||||
preds,
|
||||
block_end_values,
|
||||
vmap,
|
||||
)?
|
||||
.into(),
|
||||
};
|
||||
// String equality/inequality by content when annotated as String/StringBox
|
||||
if matches!(op, CompareOp::Eq | CompareOp::Ne) {
|
||||
let l_is_str = match func.metadata.value_types.get(lhs) {
|
||||
Some(crate::mir::MirType::String) => true,
|
||||
Some(crate::mir::MirType::Box(b)) if b == "StringBox" => true,
|
||||
_ => false,
|
||||
};
|
||||
let r_is_str = match func.metadata.value_types.get(rhs) {
|
||||
Some(crate::mir::MirType::String) => true,
|
||||
Some(crate::mir::MirType::Box(b)) if b == "StringBox" => true,
|
||||
_ => false,
|
||||
};
|
||||
if l_is_str && r_is_str {
|
||||
let i64t = codegen.context.i64_type();
|
||||
// Convert both sides to handles if needed
|
||||
let mut to_handle =
|
||||
|v: BasicValueEnum<'ctx>| -> Result<inkwell::values::IntValue<'ctx>, String> {
|
||||
match v {
|
||||
BasicValueEnum::IntValue(iv) => {
|
||||
if iv.get_type() == i64t {
|
||||
Ok(iv)
|
||||
} else {
|
||||
cursor
|
||||
.emit_instr(cur_bid, |b| {
|
||||
b.build_int_s_extend(iv, i64t, "i2i64")
|
||||
})
|
||||
.map_err(|e| e.to_string())
|
||||
}
|
||||
}
|
||||
BasicValueEnum::PointerValue(pv) => {
|
||||
let fnty = i64t.fn_type(
|
||||
&[codegen
|
||||
.context
|
||||
.ptr_type(inkwell::AddressSpace::from(0))
|
||||
.into()],
|
||||
false,
|
||||
);
|
||||
let callee = codegen
|
||||
.module
|
||||
.get_function("nyash.box.from_i8_string")
|
||||
.unwrap_or_else(|| {
|
||||
codegen.module.add_function(
|
||||
"nyash.box.from_i8_string",
|
||||
fnty,
|
||||
None,
|
||||
)
|
||||
});
|
||||
let call = cursor
|
||||
.emit_instr(cur_bid, |b| {
|
||||
b.build_call(callee, &[pv.into()], "str_ptr_to_handle_cmp")
|
||||
})
|
||||
.map_err(|e| e.to_string())?;
|
||||
let rv = call
|
||||
.try_as_basic_value()
|
||||
.left()
|
||||
.ok_or("from_i8_string returned void".to_string())?;
|
||||
Ok(rv.into_int_value())
|
||||
}
|
||||
_ => Err("unsupported value for string compare".to_string()),
|
||||
}
|
||||
};
|
||||
let lh = to_handle(lv)?;
|
||||
let rh = to_handle(rv)?;
|
||||
let fnty = i64t.fn_type(&[i64t.into(), i64t.into()], false);
|
||||
let callee = codegen
|
||||
.module
|
||||
.get_function("nyash.string.eq_hh")
|
||||
.unwrap_or_else(|| {
|
||||
codegen
|
||||
.module
|
||||
.add_function("nyash.string.eq_hh", fnty, None)
|
||||
});
|
||||
let call = cursor
|
||||
.emit_instr(cur_bid, |b| {
|
||||
b.build_call(callee, &[lh.into(), rh.into()], "str_eq_hh")
|
||||
})
|
||||
.map_err(|e| e.to_string())?;
|
||||
let iv = call
|
||||
.try_as_basic_value()
|
||||
.left()
|
||||
.ok_or("eq_hh returned void".to_string())?
|
||||
.into_int_value();
|
||||
let zero = i64t.const_zero();
|
||||
let pred = if matches!(op, CompareOp::Eq) {
|
||||
inkwell::IntPredicate::NE
|
||||
} else {
|
||||
inkwell::IntPredicate::EQ
|
||||
};
|
||||
let b = cursor
|
||||
.emit_instr(cur_bid, |bd| {
|
||||
bd.build_int_compare(pred, iv, zero, "str_eq_to_bool")
|
||||
})
|
||||
.map_err(|e| e.to_string())?;
|
||||
return Ok(b.into());
|
||||
}
|
||||
}
|
||||
let out = if let (Some(_li0), Some(_ri0)) = (as_int(lv), as_int(rv)) {
|
||||
// Localize integer operands into current block to satisfy dominance
|
||||
let mut li = resolver
|
||||
.resolve_i64(
|
||||
codegen,
|
||||
cursor,
|
||||
cur_bid,
|
||||
*lhs,
|
||||
bb_map,
|
||||
preds,
|
||||
block_end_values,
|
||||
vmap,
|
||||
)
|
||||
.unwrap_or_else(|_| as_int(lv).unwrap());
|
||||
let mut ri = resolver
|
||||
.resolve_i64(
|
||||
codegen,
|
||||
cursor,
|
||||
cur_bid,
|
||||
*rhs,
|
||||
bb_map,
|
||||
preds,
|
||||
block_end_values,
|
||||
vmap,
|
||||
)
|
||||
.unwrap_or_else(|_| as_int(rv).unwrap());
|
||||
// Normalize integer widths: extend the narrower to match the wider to satisfy LLVM
|
||||
let lw = li.get_type().get_bit_width();
|
||||
let rw = ri.get_type().get_bit_width();
|
||||
if lw != rw {
|
||||
if lw < rw {
|
||||
li = cursor
|
||||
.emit_instr(cur_bid, |b| {
|
||||
b.build_int_z_extend(li, ri.get_type(), "icmp_zext_l")
|
||||
})
|
||||
.map_err(|e| e.to_string())?;
|
||||
} else {
|
||||
ri = cursor
|
||||
.emit_instr(cur_bid, |b| {
|
||||
b.build_int_z_extend(ri, li.get_type(), "icmp_zext_r")
|
||||
})
|
||||
.map_err(|e| e.to_string())?;
|
||||
}
|
||||
}
|
||||
use CompareOp as C;
|
||||
let pred = match op {
|
||||
C::Eq => inkwell::IntPredicate::EQ,
|
||||
C::Ne => inkwell::IntPredicate::NE,
|
||||
C::Lt => inkwell::IntPredicate::SLT,
|
||||
C::Le => inkwell::IntPredicate::SLE,
|
||||
C::Gt => inkwell::IntPredicate::SGT,
|
||||
C::Ge => inkwell::IntPredicate::SGE,
|
||||
};
|
||||
cursor
|
||||
.emit_instr(cur_bid, |b| b.build_int_compare(pred, li, ri, "icmp"))
|
||||
.map_err(|e| e.to_string())?
|
||||
.into()
|
||||
} else if let (Some(lf), Some(rf)) = (as_float(lv), as_float(rv)) {
|
||||
use CompareOp as C;
|
||||
let pred = match op {
|
||||
C::Eq => inkwell::FloatPredicate::OEQ,
|
||||
C::Ne => inkwell::FloatPredicate::ONE,
|
||||
C::Lt => inkwell::FloatPredicate::OLT,
|
||||
C::Le => inkwell::FloatPredicate::OLE,
|
||||
C::Gt => inkwell::FloatPredicate::OGT,
|
||||
C::Ge => inkwell::FloatPredicate::OGE,
|
||||
};
|
||||
cursor
|
||||
.emit_instr(cur_bid, |b| b.build_float_compare(pred, lf, rf, "fcmp"))
|
||||
.map_err(|e| e.to_string())?
|
||||
.into()
|
||||
} else if let (BasicValueEnum::PointerValue(lp), BasicValueEnum::PointerValue(rp)) = (lv, rv) {
|
||||
// Support pointer equality/inequality comparisons
|
||||
use CompareOp as C;
|
||||
match op {
|
||||
C::Eq | C::Ne => {
|
||||
let i64t = codegen.context.i64_type();
|
||||
let li = cursor
|
||||
.emit_instr(cur_bid, |b| b.build_ptr_to_int(lp, i64t, "pi_l"))
|
||||
.map_err(|e| e.to_string())?;
|
||||
let ri = cursor
|
||||
.emit_instr(cur_bid, |b| b.build_ptr_to_int(rp, i64t, "pi_r"))
|
||||
.map_err(|e| e.to_string())?;
|
||||
let pred = if matches!(op, C::Eq) {
|
||||
inkwell::IntPredicate::EQ
|
||||
} else {
|
||||
inkwell::IntPredicate::NE
|
||||
};
|
||||
cursor
|
||||
.emit_instr(cur_bid, |b| b.build_int_compare(pred, li, ri, "pcmp"))
|
||||
.map_err(|e| e.to_string())?
|
||||
.into()
|
||||
}
|
||||
_ => return Err("unsupported pointer comparison (only Eq/Ne)".to_string()),
|
||||
}
|
||||
} else if let (BasicValueEnum::PointerValue(lp), BasicValueEnum::IntValue(ri)) = (lv, rv) {
|
||||
use CompareOp as C;
|
||||
let i64t = codegen.context.i64_type();
|
||||
let li = cursor
|
||||
.emit_instr(cur_bid, |b| b.build_ptr_to_int(lp, i64t, "pi_l"))
|
||||
.map_err(|e| e.to_string())?;
|
||||
let pred = match op {
|
||||
C::Eq => inkwell::IntPredicate::EQ,
|
||||
C::Ne => inkwell::IntPredicate::NE,
|
||||
C::Lt => inkwell::IntPredicate::SLT,
|
||||
C::Le => inkwell::IntPredicate::SLE,
|
||||
C::Gt => inkwell::IntPredicate::SGT,
|
||||
C::Ge => inkwell::IntPredicate::SGE,
|
||||
};
|
||||
cursor
|
||||
.emit_instr(cur_bid, |b| b.build_int_compare(pred, li, ri, "pcmpi"))
|
||||
.map_err(|e| e.to_string())?
|
||||
.into()
|
||||
} else if let (BasicValueEnum::IntValue(li), BasicValueEnum::PointerValue(rp)) = (lv, rv) {
|
||||
use CompareOp as C;
|
||||
let i64t = codegen.context.i64_type();
|
||||
let ri = cursor
|
||||
.emit_instr(cur_bid, |b| b.build_ptr_to_int(rp, i64t, "pi_r"))
|
||||
.map_err(|e| e.to_string())?;
|
||||
let pred = match op {
|
||||
C::Eq => inkwell::IntPredicate::EQ,
|
||||
C::Ne => inkwell::IntPredicate::NE,
|
||||
C::Lt => inkwell::IntPredicate::SLT,
|
||||
C::Le => inkwell::IntPredicate::SLE,
|
||||
C::Gt => inkwell::IntPredicate::SGT,
|
||||
C::Ge => inkwell::IntPredicate::SGE,
|
||||
};
|
||||
cursor
|
||||
.emit_instr(cur_bid, |b| b.build_int_compare(pred, li, ri, "pcmpi"))
|
||||
.map_err(|e| e.to_string())?
|
||||
.into()
|
||||
} else {
|
||||
return Err("compare type mismatch".to_string());
|
||||
};
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
fn guessed_zero<'ctx>(
|
||||
codegen: &CodegenContext<'ctx>,
|
||||
func: &MirFunction,
|
||||
vid: &crate::mir::ValueId,
|
||||
) -> BasicValueEnum<'ctx> {
|
||||
use crate::mir::MirType as MT;
|
||||
match func.metadata.value_types.get(vid) {
|
||||
Some(MT::Bool) => codegen.context.bool_type().const_zero().into(),
|
||||
Some(MT::Integer) => codegen.context.i64_type().const_zero().into(),
|
||||
Some(MT::Float) => codegen.context.f64_type().const_zero().into(),
|
||||
Some(MT::String) | Some(MT::Box(_)) | Some(MT::Array(_)) | Some(MT::Future(_))
|
||||
| Some(MT::Unknown) | Some(MT::Void) | None => codegen
|
||||
.context
|
||||
.ptr_type(inkwell::AddressSpace::from(0))
|
||||
.const_zero()
|
||||
.into(),
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user