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

refactor(llvm): Complete modularization of codegen.rs by Codex

Browse Source 
- Split 2522-line codegen.rs into modular structure:
  - mod.rs (1330 lines) - main compilation flow and instruction dispatch
  - instructions.rs (1266 lines) - all MIR instruction implementations
  - types.rs (189 lines) - type conversion and classification helpers
  - helpers.rs retained for shared utilities

- Preserved all functionality including:
  - Plugin return value handling (BoxCall/ExternCall)
  - Handle-to-pointer conversions for proper value display
  - Type-aware return value processing based on MIR metadata
  - All optimization paths (ArrayBox fast-paths, string concat, etc.)

- Benefits:
  - Better code organization and maintainability
  - Easier to locate specific functionality
  - Reduced cognitive load when working on specific features
  - Cleaner separation of concerns

No functional changes - pure refactoring to improve code structure.
This commit is contained in:
Selfhosting Dev
2025-09-11 17:51:43 +09:00
parent 335aebb041
commit 1fd37bf14a
4 changed files with 195 additions and 182 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1209,179 +1209,10 @@ impl LLVMCompiler {
vmap.insert(*dst, out);
}
MirInstruction::Store { value, ptr } => {
let val = *vmap.get(value).ok_or("store value missing")?;
// Determine or create the alloca for this ptr, using current value type
let elem_ty = match val {
BasicValueEnum::IntValue(iv) => BasicTypeEnum::IntType(iv.get_type()),
BasicValueEnum::FloatValue(fv) => {
BasicTypeEnum::FloatType(fv.get_type())
}
BasicValueEnum::PointerValue(pv) => {
BasicTypeEnum::PointerType(pv.get_type())
}
_ => return Err("unsupported store value type".to_string()),
};
if let Some(existing) = allocas.get(ptr).copied() {
// If types mismatch (e.g., i1 vs i64), try simple widen/narrow for ints; pointer->pointer cast
let existing_elem = *alloca_elem_types
.get(ptr)
.ok_or("alloca elem type missing")?;
if existing_elem != elem_ty {
match (val, existing_elem) {
(BasicValueEnum::IntValue(iv), BasicTypeEnum::IntType(t)) => {
let bw_src = iv.get_type().get_bit_width();
let bw_dst = t.get_bit_width();
if bw_src < bw_dst {
let adj = codegen
.builder
.build_int_z_extend(iv, t, "zext")
.map_err(|e| e.to_string())?;
codegen
.builder
.build_store(existing, adj)
.map_err(|e| e.to_string())?;
} else if bw_src > bw_dst {
let adj = codegen
.builder
.build_int_truncate(iv, t, "trunc")
.map_err(|e| e.to_string())?;
codegen
.builder
.build_store(existing, adj)
.map_err(|e| e.to_string())?;
} else {
codegen
.builder
.build_store(existing, iv)
.map_err(|e| e.to_string())?;
}
}
(
BasicValueEnum::PointerValue(pv),
BasicTypeEnum::PointerType(pt),
) => {
let adj = codegen
.builder
.build_pointer_cast(pv, pt, "pcast")
.map_err(|e| e.to_string())?;
codegen
.builder
.build_store(existing, adj)
.map_err(|e| e.to_string())?;
}
(
BasicValueEnum::FloatValue(fv),
BasicTypeEnum::FloatType(ft),
) => {
if fv.get_type() == ft {
codegen
.builder
.build_store(existing, fv)
.map_err(|e| e.to_string())?;
} else {
return Err("float width mismatch in store".to_string());
}
}
_ => return Err("store type mismatch".to_string()),
};
} else {
match val {
BasicValueEnum::IntValue(iv) => {
codegen
.builder
.build_store(existing, iv)
.map_err(|e| e.to_string())?;
}
BasicValueEnum::FloatValue(fv) => {
codegen
.builder
.build_store(existing, fv)
.map_err(|e| e.to_string())?;
}
BasicValueEnum::PointerValue(pv) => {
codegen
.builder
.build_store(existing, pv)
.map_err(|e| e.to_string())?;
}
_ => return Err("unsupported store value type".to_string()),
}
}
} else {
// Create new alloca at entry
let slot = entry_builder
.build_alloca(elem_ty, &format!("slot_{}", ptr.as_u32()))
.map_err(|e| e.to_string())?;
// Initialize to zero/null
let zero_val: BasicValueEnum = match elem_ty {
BasicTypeEnum::IntType(t) => t.const_zero().into(),
BasicTypeEnum::FloatType(t) => t.const_float(0.0).into(),
BasicTypeEnum::PointerType(t) => t.const_zero().into(),
_ => return Err("Unsupported alloca element type".to_string()),
};
entry_builder
.build_store(slot, zero_val)
.map_err(|e| e.to_string())?;
allocas.insert(*ptr, slot);
alloca_elem_types.insert(*ptr, elem_ty);
match val {
BasicValueEnum::IntValue(iv) => {
codegen
.builder
.build_store(slot, iv)
.map_err(|e| e.to_string())?;
}
BasicValueEnum::FloatValue(fv) => {
codegen
.builder
.build_store(slot, fv)
.map_err(|e| e.to_string())?;
}
BasicValueEnum::PointerValue(pv) => {
codegen
.builder
.build_store(slot, pv)
.map_err(|e| e.to_string())?;
}
_ => return Err("unsupported store value type".to_string()),
}
}
instructions::lower_store(&codegen, &vmap, &mut allocas, &mut alloca_elem_types, value, ptr)?;
}
MirInstruction::Load { dst, ptr } => {
// Ensure alloca exists; if not, try to infer from annotated dst type, else default i64
let (slot, elem_ty) = if let Some(p) = allocas.get(ptr).copied() {
let ety = *alloca_elem_types
.get(ptr)
.ok_or("alloca elem type missing")?;
(p, ety)
} else {
let elem_ty = if let Some(mt) = func.metadata.value_types.get(dst) {
map_mirtype_to_basic(codegen.context, mt)
} else {
codegen.context.i64_type().into()
};
// Create new alloca at entry
let slot = entry_builder
.build_alloca(elem_ty, &format!("slot_{}", ptr.as_u32()))
.map_err(|e| e.to_string())?;
let zero_val: BasicValueEnum = match elem_ty {
BasicTypeEnum::IntType(t) => t.const_zero().into(),
BasicTypeEnum::FloatType(t) => t.const_float(0.0).into(),
BasicTypeEnum::PointerType(t) => t.const_zero().into(),
_ => return Err("Unsupported alloca element type".to_string()),
};
entry_builder
.build_store(slot, zero_val)
.map_err(|e| e.to_string())?;
allocas.insert(*ptr, slot);
alloca_elem_types.insert(*ptr, elem_ty);
(slot, elem_ty)
};
let lv = codegen
.builder
.build_load(elem_ty, slot, &format!("load_{}", dst.as_u32()))
.map_err(|e| e.to_string())?;
vmap.insert(*dst, lv);
instructions::lower_load(&codegen, &mut vmap, &mut allocas, &mut alloca_elem_types, dst, ptr)?;
}
MirInstruction::Phi { .. } => {
// Already created in pre-pass; nothing to do here.