359 lines
14 KiB
Rust
359 lines
14 KiB
Rust
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(),
|
|
}
|
|
}
|