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

de-rust phase-0: archive Rust LLVM backend to archive/rust-llvm-backend (RESTORE documented); defaults unaffected

Browse Source
This commit is contained in:
nyash-codex
2025-11-09 01:00:43 +09:00
parent 024a4fecb7
commit 5d2cd5bad0
37 changed files with 57 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

418
archive/rust-llvm-backend/llvm/compiler/codegen/instructions/strings.rs Normal file
View File

@ -0,0 +1,418 @@
use std::collections::HashMap;
use inkwell::{values::BasicValueEnum as BVE, AddressSpace};
use super::builder_cursor::BuilderCursor;
use super::Resolver;
use crate::backend::llvm::context::CodegenContext;
use crate::mir::{function::MirFunction, BasicBlockId, ValueId};
/// Handle String-specific methods. Returns true if handled, false to let caller continue.
pub(super) fn try_handle_string_method<'ctx, 'b>(
codegen: &CodegenContext<'ctx>,
cursor: &mut BuilderCursor<'ctx, 'b>,
resolver: &mut Resolver<'ctx>,
cur_bid: BasicBlockId,
func: &MirFunction,
vmap: &mut HashMap<ValueId, inkwell::values::BasicValueEnum<'ctx>>,
dst: &Option<ValueId>,
box_val: &ValueId,
method: &str,
args: &[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, inkwell::values::BasicValueEnum<'ctx>>,
>,
) -> Result<bool, String> {
// Receiver annotation check (kept for future diagnostics)
let _is_string_recv = match func.metadata.value_types.get(box_val) {
Some(crate::mir::MirType::String) => true,
Some(crate::mir::MirType::Box(b)) if b == "StringBox" => true,
_ => false,
};
// Do not early-return; method-specific checksで型検証を行う
// concat fast-paths
if method == "concat" {
if args.len() != 1 {
return Err("String.concat expects 1 arg".to_string());
}
let i8p = codegen.context.ptr_type(AddressSpace::from(0));
// Resolve rhs as either pointer (string) or i64 (handle/int)
let rhs_val = match func.metadata.value_types.get(&args[0]) {
Some(crate::mir::MirType::String) => {
let p = resolver.resolve_ptr(
codegen,
cursor,
cur_bid,
args[0],
bb_map,
preds,
block_end_values,
vmap,
)?;
BVE::PointerValue(p)
}
_ => {
// Default to integer form for non-String metadata
let iv = resolver.resolve_i64(
codegen,
cursor,
cur_bid,
args[0],
bb_map,
preds,
block_end_values,
vmap,
)?;
BVE::IntValue(iv)
}
};
let lp = resolver.resolve_ptr(
codegen,
cursor,
cur_bid,
*box_val,
bb_map,
preds,
block_end_values,
vmap,
)?;
match (BVE::PointerValue(lp), rhs_val) {
(BVE::PointerValue(lp), BVE::PointerValue(rp)) => {
let fnty = i8p.fn_type(&[i8p.into(), i8p.into()], false);
let callee = codegen
.module
.get_function("nyash.string.concat_ss")
.unwrap_or_else(|| {
codegen
.module
.add_function("nyash.string.concat_ss", fnty, None)
});
let call = cursor
.emit_instr(cur_bid, |b| {
b.build_call(callee, &[lp.into(), rp.into()], "concat_ss_call")
})
.map_err(|e| e.to_string())?;
if let Some(d) = dst {
let rv = call
.try_as_basic_value()
.left()
.ok_or("concat_ss returned void".to_string())?;
// return as handle (i64) across blocks
let i64t = codegen.context.i64_type();
let h = cursor
.emit_instr(cur_bid, |b| {
b.build_ptr_to_int(rv.into_pointer_value(), i64t, "str_ptr2i")
})
.map_err(|e| e.to_string())?;
vmap.insert(*d, h.into());
}
return Ok(true);
}
(BVE::PointerValue(lp), BVE::IntValue(_ri)) => {
let i64t = codegen.context.i64_type();
// Localize rhs integer in current block via Resolver
let ri = resolver.resolve_i64(
codegen,
cursor,
cur_bid,
args[0],
bb_map,
preds,
block_end_values,
vmap,
)?;
let fnty = i8p.fn_type(&[i8p.into(), i64t.into()], false);
let callee = codegen
.module
.get_function("nyash.string.concat_si")
.unwrap_or_else(|| {
codegen
.module
.add_function("nyash.string.concat_si", fnty, None)
});
let call = cursor
.emit_instr(cur_bid, |b| {
b.build_call(callee, &[lp.into(), ri.into()], "concat_si_call")
})
.map_err(|e| e.to_string())?;
if let Some(d) = dst {
let rv = call
.try_as_basic_value()
.left()
.ok_or("concat_si returned void".to_string())?;
let i64t = codegen.context.i64_type();
let h = cursor
.emit_instr(cur_bid, |b| {
b.build_ptr_to_int(rv.into_pointer_value(), i64t, "str_ptr2i")
})
.map_err(|e| e.to_string())?;
vmap.insert(*d, h.into());
}
return Ok(true);
}
(BVE::PointerValue(_li_as_p), BVE::PointerValue(rp)) => {
let i64t = codegen.context.i64_type();
// Localize receiver integer in current block (box_val)
let li = resolver.resolve_i64(
codegen,
cursor,
cur_bid,
*box_val,
bb_map,
preds,
block_end_values,
vmap,
)?;
let fnty = i8p.fn_type(&[i64t.into(), i8p.into()], false);
let callee = codegen
.module
.get_function("nyash.string.concat_is")
.unwrap_or_else(|| {
codegen
.module
.add_function("nyash.string.concat_is", fnty, None)
});
let call = cursor
.emit_instr(cur_bid, |b| {
b.build_call(callee, &[li.into(), rp.into()], "concat_is_call")
})
.map_err(|e| e.to_string())?;
if let Some(d) = dst {
let rv = call
.try_as_basic_value()
.left()
.ok_or("concat_is returned void".to_string())?;
let i64t = codegen.context.i64_type();
let h = cursor
.emit_instr(cur_bid, |b| {
b.build_ptr_to_int(rv.into_pointer_value(), i64t, "str_ptr2i")
})
.map_err(|e| e.to_string())?;
vmap.insert(*d, h.into());
}
return Ok(true);
}
_ => { /* fall through */ }
}
}
// length/len fast-path
if method == "length" || method == "len" {
let i64t = codegen.context.i64_type();
// Ensure handle for receiver (i8* -> i64 via from_i8_string)
let recv_h = {
// Prefer i64 handle from resolver; if metadata says String but actual is i8*, box it
if let Some(crate::mir::MirType::String) = func.metadata.value_types.get(box_val) {
// Receiver is a String: resolve pointer then box to i64
let p = resolver.resolve_ptr(
codegen,
cursor,
cur_bid,
*box_val,
bb_map,
preds,
block_end_values,
vmap,
)?;
let fnty = i64t.fn_type(
&[codegen.context.ptr_type(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, &[p.into()], "str_ptr_to_handle")
})
.map_err(|e| e.to_string())?;
let rv = call
.try_as_basic_value()
.left()
.ok_or("from_i8_string returned void".to_string())?;
if let BVE::IntValue(iv) = rv {
iv
} else {
return Err("from_i8_string ret expected i64".to_string());
}
} else {
resolver.resolve_i64(
codegen,
cursor,
cur_bid,
*box_val,
bb_map,
preds,
block_end_values,
vmap,
)?
}
};
// call i64 @nyash.string.len_h(i64)
let fnty = i64t.fn_type(&[i64t.into()], false);
let callee = codegen
.module
.get_function("nyash.string.len_h")
.unwrap_or_else(|| {
codegen
.module
.add_function("nyash.string.len_h", fnty, None)
});
let call = cursor
.emit_instr(cur_bid, |b| {
b.build_call(callee, &[recv_h.into()], "strlen_h")
})
.map_err(|e| e.to_string())?;
if let Some(d) = dst {
let rv = call
.try_as_basic_value()
.left()
.ok_or("len_h returned void".to_string())?;
vmap.insert(*d, rv);
}
return Ok(true);
}
// substring(start, end) -> i8*
if method == "substring" {
if args.len() != 2 {
return Err("String.substring expects 2 args (start, end)".to_string());
}
let i64t = codegen.context.i64_type();
let i8p = codegen.context.ptr_type(AddressSpace::from(0));
// receiver pointer via Resolver
let recv_p = resolver.resolve_ptr(
codegen,
cursor,
cur_bid,
*box_val,
bb_map,
preds,
block_end_values,
vmap,
)?;
// Localize start/end indices to current block via sealed snapshots (i64)
let s = resolver.resolve_i64(
codegen,
cursor,
cur_bid,
args[0],
bb_map,
preds,
block_end_values,
vmap,
)?;
let e = resolver.resolve_i64(
codegen,
cursor,
cur_bid,
args[1],
bb_map,
preds,
block_end_values,
vmap,
)?;
let fnty = i8p.fn_type(&[i8p.into(), i64t.into(), i64t.into()], false);
let callee = codegen
.module
.get_function("nyash.string.substring_sii")
.unwrap_or_else(|| {
codegen
.module
.add_function("nyash.string.substring_sii", fnty, None)
});
let call = cursor
.emit_instr(cur_bid, |b| {
b.build_call(
callee,
&[recv_p.into(), s.into(), e.into()],
"substring_call",
)
})
.map_err(|e| e.to_string())?;
if let Some(d) = dst {
let rv = call
.try_as_basic_value()
.left()
.ok_or("substring returned void".to_string())?;
let i64t = codegen.context.i64_type();
let h = cursor
.emit_instr(cur_bid, |b| {
b.build_ptr_to_int(rv.into_pointer_value(), i64t, "str_ptr2i_sub")
})
.map_err(|e| e.to_string())?;
vmap.insert(*d, h.into());
}
return Ok(true);
}
// lastIndexOf(needle) -> i64
if method == "lastIndexOf" {
if args.len() != 1 {
return Err("String.lastIndexOf expects 1 arg".to_string());
}
let i64t = codegen.context.i64_type();
let i8p = codegen.context.ptr_type(AddressSpace::from(0));
// receiver pointer via Resolver (String fast path)
let recv_p = resolver.resolve_ptr(
codegen,
cursor,
cur_bid,
*box_val,
bb_map,
preds,
block_end_values,
vmap,
)?;
let needle_p = resolver.resolve_ptr(
codegen,
cursor,
cur_bid,
args[0],
bb_map,
preds,
block_end_values,
vmap,
)?;
let fnty = i64t.fn_type(&[i8p.into(), i8p.into()], false);
let callee = codegen
.module
.get_function("nyash.string.lastIndexOf_ss")
.unwrap_or_else(|| {
codegen
.module
.add_function("nyash.string.lastIndexOf_ss", fnty, None)
});
let call = cursor
.emit_instr(cur_bid, |b| {
b.build_call(
callee,
&[recv_p.into(), needle_p.into()],
"lastindexof_call",
)
})
.map_err(|e| e.to_string())?;
if let Some(d) = dst {
let rv = call
.try_as_basic_value()
.left()
.ok_or("lastIndexOf returned void".to_string())?;
vmap.insert(*d, rv);
}
return Ok(true);
}
Ok(false)
}