tomoaki/hakorune
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

🔧 Add sealed SSA mode for PHI debugging (ChatGPT5)

Browse Source 
Added NYASH_LLVM_PHI_SEALED env var to toggle PHI wiring modes:
- NYASH_LLVM_PHI_SEALED=0 (default): immediate PHI wiring
- NYASH_LLVM_PHI_SEALED=1: sealed SSA style (wire after block completion)
- Added seal_block() function for deferred PHI incoming setup
- Enhanced PHI tracing with NYASH_LLVM_TRACE_PHI=1

This helps debug 'phi incoming value missing' errors by
comparing immediate vs sealed wiring approaches.
This commit is contained in:
Selfhosting Dev
2025-09-12 12:30:42 +09:00
parent 4fe1212d36
commit a28fcac368
3 changed files with 86 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
src/backend/llvm/compiler/codegen/instructions/flow.rs
View File

@ -54,6 +54,8 @@ pub(in super::super) fn emit_jump<'ctx>(
>,
vmap: &HashMap<ValueId, BasicValueEnum<'ctx>>,
) -> Result<(), String> {
let sealed = std::env::var("NYASH_LLVM_PHI_SEALED").ok().as_deref() == Some("1");
if !sealed {
if let Some(list) = phis_by_block.get(target) {
for (_dst, phi, inputs) in list {
if let Some((_, in_vid)) = inputs.iter().find(|(pred, _)| pred == &bid) {
@ -83,6 +85,7 @@ pub(in super::super) fn emit_jump<'ctx>(
}
}
}
}
let tbb = *bb_map.get(target).ok_or("target bb missing")?;
codegen
.builder
@ -106,7 +109,9 @@ pub(in super::super) fn emit_branch<'ctx>(
) -> Result<(), String> {
let cond_v = *vmap.get(condition).ok_or("cond missing")?;
let b = to_bool(codegen.context, cond_v, &codegen.builder)?;
let sealed = std::env::var("NYASH_LLVM_PHI_SEALED").ok().as_deref() == Some("1");
// then
if !sealed {
if let Some(list) = phis_by_block.get(then_bb) {
for (_dst, phi, inputs) in list {
if let Some((_, in_vid)) = inputs.iter().find(|(pred, _)| pred == &bid) {
@ -137,7 +142,9 @@ pub(in super::super) fn emit_branch<'ctx>(
}
}
}
}
// else
if !sealed {
if let Some(list) = phis_by_block.get(else_bb) {
for (_dst, phi, inputs) in list {
if let Some((_, in_vid)) = inputs.iter().find(|(pred, _)| pred == &bid) {
@ -168,6 +175,7 @@ pub(in super::super) fn emit_branch<'ctx>(
}
}
}
}
let tbb = *bb_map.get(then_bb).ok_or("then bb missing")?;
let ebb = *bb_map.get(else_bb).ok_or("else bb missing")?;
codegen
@ -233,3 +241,50 @@ fn coerce_to_type<'ctx>(
(_, v) => Ok(v),
}
}
/// Sealed-SSA style: when a block is finalized, add PHI incoming for all successor blocks.
pub(in super::super) fn seal_block<'ctx>(
codegen: &CodegenContext<'ctx>,
bid: BasicBlockId,
succs: &HashMap<BasicBlockId, Vec<BasicBlockId>>,
bb_map: &HashMap<BasicBlockId, BasicBlock<'ctx>>,
phis_by_block: &HashMap<
BasicBlockId,
Vec<(ValueId, PhiValue<'ctx>, Vec<(BasicBlockId, ValueId)>)>,
>,
vmap: &HashMap<ValueId, BasicValueEnum<'ctx>>,
) -> Result<(), String> {
if let Some(slist) = succs.get(&bid) {
for sb in slist {
if let Some(pl) = phis_by_block.get(sb) {
for (_dst, phi, inputs) in pl {
if let Some((_, in_vid)) = inputs.iter().find(|(pred, _)| pred == &bid) {
let mut val = *vmap.get(in_vid).ok_or("phi incoming (seal) value missing")?;
let pred_bb = *bb_map.get(&bid).ok_or("pred bb missing")?;
val = coerce_to_type(codegen, phi, val)?;
if std::env::var("NYASH_CLI_VERBOSE").ok().as_deref() == Some("1") {
let tys = phi
.as_basic_value()
.get_type()
.print_to_string()
.to_string();
eprintln!(
"[PHI] sealed add pred_bb={} val={} ty={}",
bid.as_u32(),
in_vid.as_u32(),
tys
);
}
match val {
BasicValueEnum::IntValue(iv) => phi.add_incoming(&[(&iv, pred_bb)]),
BasicValueEnum::FloatValue(fv) => phi.add_incoming(&[(&fv, pred_bb)]),
BasicValueEnum::PointerValue(pv) => phi.add_incoming(&[(&pv, pred_bb)]),
_ => return Err("unsupported phi incoming value (seal)".to_string()),
}
}
}
}
}
}
Ok(())
}

2
src/backend/llvm/compiler/codegen/instructions/mod.rs
View File

@ -1,5 +1,5 @@
mod blocks;
mod flow;
pub mod flow;
mod externcall;
mod newbox;
mod boxcall;

31
src/backend/llvm/compiler/codegen/mod.rs
View File

@ -122,6 +122,12 @@ impl LLVMCompiler {
crate::mir::BasicBlockId,
Vec<(ValueId, PhiValue, Vec<(crate::mir::BasicBlockId, ValueId)>)>,
> = HashMap::new();
// Build successors map (for optional sealed-SSA PHI wiring)
let mut succs: HashMap<crate::mir::BasicBlockId, Vec<crate::mir::BasicBlockId>> = HashMap::new();
for (bid, block) in &func.blocks {
let v: Vec<crate::mir::BasicBlockId> = block.successors.iter().copied().collect();
succs.insert(*bid, v);
}
// Bind parameters
for (i, pid) in func.params.iter().enumerate() {
if let Some(av) = llvm_func.get_nth_param(i as u32) {
@ -160,6 +166,25 @@ impl LLVMCompiler {
.entry(*bid)
.or_default()
.push((*dst, phi, inputs.clone()));
if std::env::var("NYASH_LLVM_TRACE_PHI").ok().as_deref() == Some("1") {
let ty_str = phi
.as_basic_value()
.get_type()
.print_to_string()
.to_string();
let mut pairs: Vec<String> = Vec::new();
for (pb, vid) in inputs {
pairs.push(format!("({}->{})", pb.as_u32(), vid.as_u32()));
}
eprintln!(
"[PHI:new] fn={} bb={} dst={} ty={} inputs={}",
fn_label,
bid.as_u32(),
dst.as_u32(),
ty_str,
pairs.join(",")
);
}
}
}
}
@ -168,6 +193,7 @@ impl LLVMCompiler {
let const_strs = build_const_str_map(func);
// Lower body
let sealed_mode = std::env::var("NYASH_LLVM_PHI_SEALED").ok().as_deref() == Some("1");
for (bi, bid) in block_ids.iter().enumerate() {
let bb = *bb_map.get(bid).unwrap();
if codegen
@ -319,7 +345,10 @@ impl LLVMCompiler {
instructions::emit_jump(&codegen, *bid, &entry_first, &bb_map, &phis_by_block, &vmap)?;
}
}
}
if sealed_mode {
instructions::flow::seal_block(&codegen, *bid, &succs, &bb_map, &phis_by_block, &vmap)?;
}
}
// Verify the fully-lowered function once, after all blocks
if !llvm_func.verify(true) {
return Err(format!("Function verification failed: {}", name));