refactor: レガシーコード大掃除完了！ChatGPT効率化のため
✅ 削除完了（約700行のレガシー削除） - src/jit_stub.rs 完全削除（134行の何もしないスタブ） - src/backend/llvm_legacy/ アーカイブ化（壊れたLLVMバックエンド） - vm-legacy feature全削除（5ファイルの混乱する二重パス） - コメントアウトされたインタープリター削除 - JIT関連の巨大コメントブロック削除（350行以上） ✅ ChatGPTへの効果 - 完璧主義による掃除タイム削減 - 本質的な実装に集中可能 - 混乱する二重パスの排除 🤖 Generated with Claude Code Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Selfhosting Dev
@ -217,53 +217,17 @@ impl NyashRunner {
|
||||
|
||||
// init_runtime_and_plugins moved to runner/plugins.rs
|
||||
|
||||
/// Configure backend knobs (VM/JIT) from CLI flags and env, merging with runtime capabilities.
|
||||
/// Side effects: writes environment variables for flags and applies JIT config via nyash_rust::jit::config.
|
||||
/// Configure backend knobs (VM) from CLI flags and env.
|
||||
/// JIT configuration removed with JIT/Cranelift archival.
|
||||
fn configure_backend(&self, groups: &crate::cli::CliGroups) {
|
||||
if groups.backend.vm_stats { std::env::set_var("NYASH_VM_STATS", "1"); }
|
||||
if groups.backend.vm_stats_json { std::env::set_var("NYASH_VM_STATS_JSON", "1"); }
|
||||
{
|
||||
if groups.backend.jit.events { std::env::set_var("NYASH_JIT_EVENTS", "1"); }
|
||||
if groups.backend.jit.events_compile { std::env::set_var("NYASH_JIT_EVENTS_COMPILE", "1"); }
|
||||
if groups.backend.jit.events_runtime { std::env::set_var("NYASH_JIT_EVENTS_RUNTIME", "1"); }
|
||||
if let Some(ref p) = groups.backend.jit.events_path { std::env::set_var("NYASH_JIT_EVENTS_PATH", p); }
|
||||
let mut jc = nyash_rust::jit::config::JitConfig::from_env();
|
||||
jc.exec |= groups.backend.jit.exec;
|
||||
jc.stats |= groups.backend.jit.stats;
|
||||
jc.stats_json |= groups.backend.jit.stats_json;
|
||||
jc.dump |= groups.backend.jit.dump;
|
||||
if groups.backend.jit.threshold.is_some() { jc.threshold = groups.backend.jit.threshold; }
|
||||
jc.phi_min |= groups.backend.jit.phi_min;
|
||||
jc.hostcall |= groups.backend.jit.hostcall;
|
||||
jc.handle_debug |= groups.backend.jit.handle_debug;
|
||||
jc.native_f64 |= groups.backend.jit.native_f64;
|
||||
jc.native_bool |= groups.backend.jit.native_bool;
|
||||
let events_on = std::env::var("NYASH_JIT_EVENTS").ok().as_deref() == Some("1")
|
||||
|| std::env::var("NYASH_JIT_EVENTS_COMPILE").ok().as_deref() == Some("1")
|
||||
|| std::env::var("NYASH_JIT_EVENTS_RUNTIME").ok().as_deref() == Some("1");
|
||||
if events_on && jc.threshold.is_none() { jc.threshold = Some(1); }
|
||||
if groups.backend.jit.only { std::env::set_var("NYASH_JIT_ONLY", "1"); }
|
||||
let caps = nyash_rust::jit::config::probe_capabilities();
|
||||
jc = nyash_rust::jit::config::apply_runtime_caps(jc, caps);
|
||||
if let Some(path) = &groups.emit.emit_cfg { std::env::set_var("NYASH_JIT_DOT", path); jc.dump = true; }
|
||||
jc.apply_env();
|
||||
nyash_rust::jit::config::set_current(jc.clone());
|
||||
}
|
||||
if std::env::var("NYASH_JIT_STRICT").ok().as_deref() == Some("1") {
|
||||
if std::env::var("NYASH_JIT_ARGS_HANDLE_ONLY").ok().is_none() { std::env::set_var("NYASH_JIT_ARGS_HANDLE_ONLY", "1"); }
|
||||
if std::env::var("NYASH_JIT_ONLY").ok().is_none() { std::env::set_var("NYASH_JIT_ONLY", "1"); }
|
||||
}
|
||||
// JIT configuration removed - archived to archive/jit-cranelift/
|
||||
}
|
||||
|
||||
/// Enforce runtime policy for JIT execution when AOT object output is absent.
|
||||
/// Side effects: may set `NYASH_JIT_EXEC=0` when policy requires.
|
||||
fn enforce_runtime_jit_policy(&self, groups: &crate::cli::CliGroups) {
|
||||
if !groups.compile_native && !groups.backend.jit.direct {
|
||||
let aot_obj = std::env::var("NYASH_AOT_OBJECT_OUT").ok();
|
||||
if aot_obj.is_none() || aot_obj.as_deref() == Some("") {
|
||||
std::env::set_var("NYASH_JIT_EXEC", "0");
|
||||
}
|
||||
}
|
||||
/// JIT runtime policy enforcement removed with JIT/Cranelift archival.
|
||||
fn enforce_runtime_jit_policy(&self, _groups: &crate::cli::CliGroups) {
|
||||
// JIT policy enforcement removed - archived to archive/jit-cranelift/
|
||||
}
|
||||
|
||||
/// Optionally run the benchmark suite and exit, depending on CLI flags.
|
||||
@ -274,10 +238,9 @@ impl NyashRunner {
|
||||
println!("====================================");
|
||||
println!("Running {} iterations per test...", groups.iterations);
|
||||
println!();
|
||||
#[cfg(feature = "vm-legacy")]
|
||||
{ self.execute_benchmark_mode(); return true; }
|
||||
#[cfg(not(feature = "vm-legacy"))]
|
||||
{ eprintln!("❌ Benchmark mode requires VM backend. Rebuild with --features vm-legacy."); std::process::exit(1); }
|
||||
// VM-legacy removed - benchmark mode no longer available
|
||||
eprintln!("❌ Benchmark mode removed with vm-legacy. Use regular execution modes instead.");
|
||||
std::process::exit(1);
|
||||
}
|
||||
false
|
||||
}
|
||||
@ -299,373 +262,8 @@ impl NyashRunner {
|
||||
eprintln!(" Use VM backend instead: nyash {}", filename);
|
||||
eprintln!(" Or use LLVM backend: nyash --backend llvm {}", filename);
|
||||
std::process::exit(1);
|
||||
|
||||
// Original JIT implementation archived - commented out for Phase 15
|
||||
/*
|
||||
use nyash_rust::{mir::MirCompiler, parser::NyashParser};
|
||||
use std::fs;
|
||||
// Small helper for unified error output (text or JSON)
|
||||
let emit_err = |phase: &str, code: &str, msg: &str| {
|
||||
if std::env::var("NYASH_JIT_STATS_JSON").ok().as_deref() == Some("1")
|
||||
|| std::env::var("NYASH_JIT_ERROR_JSON").ok().as_deref() == Some("1")
|
||||
{
|
||||
let payload = serde_json::json!({
|
||||
"kind": "jit_direct_error",
|
||||
"phase": phase,
|
||||
"code": code,
|
||||
"message": msg,
|
||||
"file": filename,
|
||||
});
|
||||
println!("{}", payload.to_string());
|
||||
} else {
|
||||
eprintln!("[JIT-direct][{}][{}] {}", phase, code, msg);
|
||||
}
|
||||
};
|
||||
// Require cranelift feature at runtime by attempting compile; if unavailable compile_function returns None
|
||||
let code = match fs::read_to_string(filename) {
|
||||
Ok(s) => s,
|
||||
Err(e) => {
|
||||
emit_err("read_file", "IO", &format!("{}", e));
|
||||
std::process::exit(1);
|
||||
}
|
||||
};
|
||||
let ast = match NyashParser::parse_from_string(&code) {
|
||||
Ok(a) => a,
|
||||
Err(e) => {
|
||||
emit_err("parse", "SYNTAX", &format!("{}", e));
|
||||
std::process::exit(1);
|
||||
}
|
||||
};
|
||||
let mut mc = MirCompiler::new();
|
||||
let cr = match mc.compile(ast) {
|
||||
Ok(m) => m,
|
||||
Err(e) => {
|
||||
emit_err("mir", "MIR_COMPILE", &format!("{}", e));
|
||||
std::process::exit(1);
|
||||
}
|
||||
};
|
||||
let func = match cr.module.functions.get("main") {
|
||||
Some(f) => f,
|
||||
None => {
|
||||
emit_err("mir", "NO_MAIN", "No main function found");
|
||||
std::process::exit(1);
|
||||
}
|
||||
};
|
||||
|
||||
// Guard: refuse write-effects in jit-direct when policy.read_only
|
||||
{
|
||||
use nyash_rust::mir::effect::Effect;
|
||||
let policy = nyash_rust::jit::policy::current();
|
||||
let mut writes = 0usize;
|
||||
for (_bbid, bb) in func.blocks.iter() {
|
||||
for inst in bb.instructions.iter() {
|
||||
let mask = inst.effects();
|
||||
if mask.contains(Effect::WriteHeap) {
|
||||
writes += 1;
|
||||
}
|
||||
}
|
||||
if let Some(term) = &bb.terminator {
|
||||
if term.effects().contains(Effect::WriteHeap) {
|
||||
writes += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
if policy.read_only && writes > 0 {
|
||||
emit_err(
|
||||
"policy",
|
||||
"WRITE_EFFECTS",
|
||||
&format!(
|
||||
"write-effects detected ({} ops). jit-direct is read-only at this stage.",
|
||||
writes
|
||||
),
|
||||
);
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
// jit-direct 安定化: 分岐合流(PHI)は明示ブロック引数で配線
|
||||
{
|
||||
let mut cfg = nyash_rust::jit::config::current();
|
||||
cfg.phi_min = true; // enable multi-PHI arg passing/join
|
||||
nyash_rust::jit::config::set_current(cfg);
|
||||
}
|
||||
// Prepare minimal runtime hooks so JIT externs (checkpoint/await) can reach GC/scheduler
|
||||
{
|
||||
let rt = nyash_rust::runtime::NyashRuntime::new();
|
||||
nyash_rust::runtime::global_hooks::set_from_runtime(&rt);
|
||||
}
|
||||
let mut engine = nyash_rust::jit::engine::JitEngine::new();
|
||||
match engine.compile_function("main", func) {
|
||||
Some(h) => {
|
||||
// Optional event: compile
|
||||
nyash_rust::jit::events::emit(
|
||||
"compile",
|
||||
&func.signature.name,
|
||||
Some(h),
|
||||
None,
|
||||
serde_json::json!({}),
|
||||
);
|
||||
// Parse JIT args from env: NYASH_JIT_ARGS (comma-separated), with optional type prefixes
|
||||
// Formats per arg: i:123, f:3.14, b:true/false, h:42 (handle), or bare numbers (int), true/false (bool)
|
||||
let mut jit_args: Vec<nyash_rust::jit::abi::JitValue> = Vec::new();
|
||||
if let Ok(s) = std::env::var("NYASH_JIT_ARGS") {
|
||||
for raw in s.split(',') {
|
||||
let t = raw.trim();
|
||||
if t.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let v = if let Some(rest) = t.strip_prefix("i:") {
|
||||
rest.parse::<i64>()
|
||||
.ok()
|
||||
.map(nyash_rust::jit::abi::JitValue::I64)
|
||||
} else if let Some(rest) = t.strip_prefix("f:") {
|
||||
rest.parse::<f64>()
|
||||
.ok()
|
||||
.map(nyash_rust::jit::abi::JitValue::F64)
|
||||
} else if let Some(rest) = t.strip_prefix("b:") {
|
||||
let b = matches!(rest, "1" | "true" | "True" | "TRUE");
|
||||
Some(nyash_rust::jit::abi::JitValue::Bool(b))
|
||||
} else if let Some(rest) = t.strip_prefix("h:") {
|
||||
rest.parse::<u64>()
|
||||
.ok()
|
||||
.map(nyash_rust::jit::abi::JitValue::Handle)
|
||||
} else if t.eq_ignore_ascii_case("true") || t == "1" {
|
||||
Some(nyash_rust::jit::abi::JitValue::Bool(true))
|
||||
} else if t.eq_ignore_ascii_case("false") || t == "0" {
|
||||
Some(nyash_rust::jit::abi::JitValue::Bool(false))
|
||||
} else if let Ok(iv) = t.parse::<i64>() {
|
||||
Some(nyash_rust::jit::abi::JitValue::I64(iv))
|
||||
} else if let Ok(fv) = t.parse::<f64>() {
|
||||
Some(nyash_rust::jit::abi::JitValue::F64(fv))
|
||||
} else {
|
||||
None
|
||||
};
|
||||
if let Some(jv) = v {
|
||||
jit_args.push(jv);
|
||||
}
|
||||
}
|
||||
}
|
||||
// Coerce args to expected MIR types
|
||||
use nyash_rust::mir::MirType;
|
||||
let expected = &func.signature.params;
|
||||
if expected.len() != jit_args.len() {
|
||||
emit_err(
|
||||
"args",
|
||||
"COUNT_MISMATCH",
|
||||
&format!("expected={}, passed={}", expected.len(), jit_args.len()),
|
||||
);
|
||||
eprintln!("Hint: set NYASH_JIT_ARGS as comma-separated values, e.g., i:42,f:3.14,b:true");
|
||||
std::process::exit(1);
|
||||
}
|
||||
let mut coerced: Vec<nyash_rust::jit::abi::JitValue> =
|
||||
Vec::with_capacity(jit_args.len());
|
||||
for (i, (exp, got)) in expected.iter().zip(jit_args.iter()).enumerate() {
|
||||
let cv = match exp {
|
||||
MirType::Integer => match got {
|
||||
nyash_rust::jit::abi::JitValue::I64(v) => {
|
||||
nyash_rust::jit::abi::JitValue::I64(*v)
|
||||
}
|
||||
nyash_rust::jit::abi::JitValue::F64(f) => {
|
||||
nyash_rust::jit::abi::JitValue::I64(*f as i64)
|
||||
}
|
||||
nyash_rust::jit::abi::JitValue::Bool(b) => {
|
||||
nyash_rust::jit::abi::JitValue::I64(if *b { 1 } else { 0 })
|
||||
}
|
||||
_ => {
|
||||
emit_err(
|
||||
"args",
|
||||
"TYPE_MISMATCH",
|
||||
&format!("param#{} expects Integer", i),
|
||||
);
|
||||
std::process::exit(1);
|
||||
}
|
||||
},
|
||||
MirType::Float => match got {
|
||||
nyash_rust::jit::abi::JitValue::F64(f) => {
|
||||
nyash_rust::jit::abi::JitValue::F64(*f)
|
||||
}
|
||||
nyash_rust::jit::abi::JitValue::I64(v) => {
|
||||
nyash_rust::jit::abi::JitValue::F64(*v as f64)
|
||||
}
|
||||
nyash_rust::jit::abi::JitValue::Bool(b) => {
|
||||
nyash_rust::jit::abi::JitValue::F64(if *b { 1.0 } else { 0.0 })
|
||||
}
|
||||
_ => {
|
||||
emit_err(
|
||||
"args",
|
||||
"TYPE_MISMATCH",
|
||||
&format!("param#{} expects Float", i),
|
||||
);
|
||||
std::process::exit(1);
|
||||
}
|
||||
},
|
||||
MirType::Bool => match got {
|
||||
nyash_rust::jit::abi::JitValue::Bool(b) => {
|
||||
nyash_rust::jit::abi::JitValue::Bool(*b)
|
||||
}
|
||||
nyash_rust::jit::abi::JitValue::I64(v) => {
|
||||
nyash_rust::jit::abi::JitValue::Bool(*v != 0)
|
||||
}
|
||||
nyash_rust::jit::abi::JitValue::F64(f) => {
|
||||
nyash_rust::jit::abi::JitValue::Bool(*f != 0.0)
|
||||
}
|
||||
_ => {
|
||||
emit_err(
|
||||
"args",
|
||||
"TYPE_MISMATCH",
|
||||
&format!("param#{} expects Bool", i),
|
||||
);
|
||||
std::process::exit(1);
|
||||
}
|
||||
},
|
||||
MirType::String
|
||||
| MirType::Box(_)
|
||||
| MirType::Array(_)
|
||||
| MirType::Future(_) => match got {
|
||||
nyash_rust::jit::abi::JitValue::Handle(h) => {
|
||||
nyash_rust::jit::abi::JitValue::Handle(*h)
|
||||
}
|
||||
_ => {
|
||||
emit_err(
|
||||
"args",
|
||||
"TYPE_MISMATCH",
|
||||
&format!("param#{} expects handle (h:<id>)", i),
|
||||
);
|
||||
std::process::exit(1);
|
||||
}
|
||||
},
|
||||
MirType::Void | MirType::Unknown => {
|
||||
// Keep as-is
|
||||
*got
|
||||
}
|
||||
};
|
||||
coerced.push(cv);
|
||||
}
|
||||
nyash_rust::jit::rt::set_current_jit_args(&coerced);
|
||||
let t0 = std::time::Instant::now();
|
||||
let out = engine.execute_handle(h, &coerced);
|
||||
match out {
|
||||
Some(v) => {
|
||||
let ms = t0.elapsed().as_millis();
|
||||
nyash_rust::jit::events::emit(
|
||||
"execute",
|
||||
&func.signature.name,
|
||||
Some(h),
|
||||
Some(ms),
|
||||
serde_json::json!({}),
|
||||
);
|
||||
// Normalize result according to MIR return type for friendly output
|
||||
use nyash_rust::mir::MirType;
|
||||
let ret_ty = &func.signature.return_type;
|
||||
let vmv = match (ret_ty, v) {
|
||||
(MirType::Bool, nyash_rust::jit::abi::JitValue::I64(i)) => {
|
||||
nyash_rust::backend::vm::VMValue::Bool(i != 0)
|
||||
}
|
||||
(MirType::Bool, nyash_rust::jit::abi::JitValue::Bool(b)) => {
|
||||
nyash_rust::backend::vm::VMValue::Bool(b)
|
||||
}
|
||||
(MirType::Float, nyash_rust::jit::abi::JitValue::F64(f)) => {
|
||||
nyash_rust::backend::vm::VMValue::Float(f)
|
||||
}
|
||||
(MirType::Float, nyash_rust::jit::abi::JitValue::I64(i)) => {
|
||||
nyash_rust::backend::vm::VMValue::Float(i as f64)
|
||||
}
|
||||
// Default adapter for other combos
|
||||
_ => nyash_rust::jit::abi::adapter::from_jit_value(v),
|
||||
};
|
||||
println!("✅ JIT-direct execution completed successfully!");
|
||||
// Pretty print with expected type tag
|
||||
let (ety, sval) = match (ret_ty, &vmv) {
|
||||
(MirType::Bool, nyash_rust::backend::vm::VMValue::Bool(b)) => {
|
||||
("Bool", b.to_string())
|
||||
}
|
||||
(MirType::Float, nyash_rust::backend::vm::VMValue::Float(f)) => {
|
||||
("Float", format!("{}", f))
|
||||
}
|
||||
(MirType::Integer, nyash_rust::backend::vm::VMValue::Integer(i)) => {
|
||||
("Integer", i.to_string())
|
||||
}
|
||||
// Fallbacks
|
||||
(_, nyash_rust::backend::vm::VMValue::Integer(i)) => {
|
||||
("Integer", i.to_string())
|
||||
}
|
||||
(_, nyash_rust::backend::vm::VMValue::Float(f)) => {
|
||||
("Float", format!("{}", f))
|
||||
}
|
||||
(_, nyash_rust::backend::vm::VMValue::Bool(b)) => {
|
||||
("Bool", b.to_string())
|
||||
}
|
||||
(_, nyash_rust::backend::vm::VMValue::String(s)) => {
|
||||
("String", s.clone())
|
||||
}
|
||||
(_, nyash_rust::backend::vm::VMValue::BoxRef(arc)) => {
|
||||
("BoxRef", arc.type_name().to_string())
|
||||
}
|
||||
(_, nyash_rust::backend::vm::VMValue::Future(_)) => {
|
||||
("Future", "<future>".to_string())
|
||||
}
|
||||
(_, nyash_rust::backend::vm::VMValue::Void) => {
|
||||
("Void", "void".to_string())
|
||||
}
|
||||
};
|
||||
println!("ResultType(MIR): {}", ety);
|
||||
println!("Result: {}", sval);
|
||||
// Optional JSON stats
|
||||
if std::env::var("NYASH_JIT_STATS_JSON").ok().as_deref() == Some("1") {
|
||||
let cfg = nyash_rust::jit::config::current();
|
||||
let caps = nyash_rust::jit::config::probe_capabilities();
|
||||
let (phi_t, phi_b1, ret_b) = engine.last_lower_stats();
|
||||
let abi_mode = if cfg.native_bool_abi && caps.supports_b1_sig {
|
||||
"b1_bool"
|
||||
} else {
|
||||
"i64_bool"
|
||||
};
|
||||
let payload = serde_json::json!({
|
||||
"version": 1,
|
||||
"function": func.signature.name,
|
||||
"abi_mode": abi_mode,
|
||||
"abi_b1_enabled": cfg.native_bool_abi,
|
||||
"abi_b1_supported": caps.supports_b1_sig,
|
||||
"b1_norm_count": nyash_rust::jit::rt::b1_norm_get(),
|
||||
"ret_bool_hint_count": nyash_rust::jit::rt::ret_bool_hint_get(),
|
||||
"phi_total_slots": phi_t,
|
||||
"phi_b1_slots": phi_b1,
|
||||
"ret_bool_hint_used": ret_b,
|
||||
});
|
||||
println!("{}", payload.to_string());
|
||||
}
|
||||
}
|
||||
None => {
|
||||
nyash_rust::jit::events::emit(
|
||||
"fallback",
|
||||
&func.signature.name,
|
||||
Some(h),
|
||||
None,
|
||||
serde_json::json!({"reason":"trap_or_missing"}),
|
||||
);
|
||||
emit_err(
|
||||
"execute",
|
||||
"TRAP_OR_MISSING",
|
||||
"execution failed (trap or missing handle)",
|
||||
);
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
None => {
|
||||
emit_err(
|
||||
"compile",
|
||||
"UNAVAILABLE",
|
||||
"Build with --features cranelift-jit",
|
||||
);
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
*/ // End of archived JIT implementation
|
||||
}
|
||||
}
|
||||
|
||||
// Demo functions (moved from main.rs)
|
||||
// moved to demos.rs
|
||||
|
||||
// moved to demos.rs
|
||||
|
||||
@ -1,10 +1,8 @@
|
||||
#[cfg(feature = "vm-legacy")]
|
||||
pub mod bench;
|
||||
// bench module removed with vm-legacy
|
||||
pub mod llvm;
|
||||
pub mod mir;
|
||||
pub mod vm_fallback;
|
||||
#[cfg(feature = "vm-legacy")]
|
||||
pub mod vm;
|
||||
// vm module removed with vm-legacy
|
||||
pub mod pyvm;
|
||||
pub mod macro_child;
|
||||
|
||||
|
||||
Reference in New Issue
Block a user