diff --git a/docs/development/roadmap/phases/phase-10.1/README.md b/docs/development/roadmap/phases/phase-10.1/README.md index 5f420083..4b85d200 100644 --- a/docs/development/roadmap/phases/phase-10.1/README.md +++ b/docs/development/roadmap/phases/phase-10.1/README.md @@ -26,22 +26,22 @@ ## 🚀 実装計画 -### Week 1: ArrayBoxプラグイン化PoC +### Week 1: ArrayBoxプラグイン化PoC（詳細は phase_plan.md 参照） - ArrayBoxをプラグインとして再実装 - JITからのプラグイン呼び出しテスト - パフォーマンス測定（HostCall vs Plugin） -### Week 2: 主要Box移行 +### Week 2: 主要Box移行（詳細は phase_plan.md 参照） - StringBox、IntegerBox、BoolBoxのプラグイン化 - JIT lowering層の統一（plugin_invoke経由） - 既存HostCallとの共存メカニズム -### Week 3: 静的リンク基盤 +### Week 3: 静的リンク基盤（詳細は phase_plan.md 参照） - プラグインの`.a`ライブラリビルド - 最小ランタイム（nyash-runtime）設計 - リンカースクリプト作成 -### Week 4: EXE生成実証 +### Week 4: EXE生成実証（詳細は phase_plan.md 参照） - Hello Worldレベルのスタンドアロン実行 - Linux/macOSでの動作確認 - デバッグ情報とunwind対応 @@ -62,6 +62,8 @@ plugins/ ## 🔗 関連資料 +- フェーズ計画の詳細: [phase_plan.md](./phase_plan.md) + - [革新的アプローチ詳細](../../../ideas/new-features/2025-08-28-jit-exe-via-plugin-unification.md) - [プラグインAPI仕様](../../../../reference/plugin-system/) - [Phase 10.5: Python統合計画](../phase-10.5/) （旧10.1） @@ -90,4 +92,4 @@ plugins/ --- -*"Everything is Box → Everything is Plugin → Everything is Possible"* \ No newline at end of file +*"Everything is Box → Everything is Plugin → Everything is Possible"* diff --git a/docs/development/roadmap/phases/phase-10.1/phase_plan.md b/docs/development/roadmap/phases/phase-10.1/phase_plan.md new file mode 100644 index 00000000..81fc1385 --- /dev/null +++ b/docs/development/roadmap/phases/phase-10.1/phase_plan.md @@ -0,0 +1,77 @@ +# Phase 10.1 – Plugin Unification Path (MIR→JIT/AOT via C ABI) + +This plan refines how we leverage the existing plugin system (BID-FFI) to unify JIT and AOT (EXE) paths using a single C ABI surface. + +## Goals +- Unify calls from JIT and AOT to the same C ABI (`nyrt_*` / `nyplug_*`). +- Convert builtin Boxes to Plugin Boxes in small steps (read-only first). +- Produce a minimal standalone EXE via static linking after unification. + +## Feasibility Summary +- JIT: emit calls to `extern "C"` symbols (no change in semantics, only target). +- AOT: emit `.o` with unresolved `nyrt_*` / `nyplug_*` and link with `libnyrt.a` + plugin `.a`. +- Compatibility: guard with `NYASH_USE_PLUGIN_BUILTINS` and keep HostCall fallback. + +## Phase Breakdown + +### 10.1: Plugin PoC + C ABI base (1 week) +- Deliverables: + - Minimal headers: `nyrt.h` (runtime), `nyplug_array.h` (ArrayBox plugin). + - ArrayBox as a plugin (`cdylib` + `staticlib`), ABI version functions. + - VM loader integration and `NYASH_USE_PLUGIN_BUILTINS` switch. + - Smoke: `new/len/push/get` working via plugin. +- DoD: + - Array plugin works on VM path; perf regression ≤10% on micro bench. + +### 10.2: JIT Lowering unification (Array first) (1–1.5 weeks) +- Deliverables: + - IRBuilder: `emit_plugin_invoke(type_id, method_id, args, sig)`. + - LowerCore BoxCall for Array routes to `plugin_invoke` (events/stats intact). + - Feature-flagged enablement: `NYASH_USE_PLUGIN_BUILTINS=1`. +- DoD: + - JIT execution of Array read/write (policy-constrained) via plugin path. + - Behavior parity with HostCall; no regressions on CI smoke. + +### 10.3: Broaden plugin coverage + Compatibility (2 weeks) +- Targets: String/Integer/Bool/Map (read-only first). +- Deliverables: + - Pluginized Boxes and `plugin_invoke` lowering for BoxCall. + - HostCall route retained; whitelist-driven co-existence. + - Added smoke and microbenches comparing HostCall vs Plugin. +- DoD: + - ≥5 builtin Boxes pluginized; `NYASH_USE_PLUGIN_BUILTINS=1` green on smoke. + +### 10.4: AOT/EXE minimal pipeline (2–3 weeks) +- Deliverables: + - ObjectWriter path to emit `.o` with unresolved `nyrt_*`/`nyplug_*`. + - `libnyrt.a` minimal runtime + selected plugin `.a`. + - Link scripts and `nyc build-aot` proof-of-concept. + - Hello World-level standalone EXE on Linux/macOS. +- DoD: + - `nyc build-aot -o app` runs without JIT/VM. + - Basic debug info and minimal unwind. + +### 10.5: Python Integration (moved; separate phase) +- Python work is deferred to 10.5 and builds on the plugin/AOT foundation. + +## Flags & Compatibility +- `NYASH_USE_PLUGIN_BUILTINS=1` – enables plugin path for builtin Boxes. +- `NYASH_JIT_HOSTCALL=1` – preserves HostCall path for comparison. +- Call conv alignment: x86_64 SysV, aarch64 AAPCS64, Win64. +- ABI version checks: `nyrt_abi_version()`, `nyplug_*_abi_version()` hard-fail on mismatch. + +## Risks & Mitigations +- ABI drift: minimal headers + version checks. +- Linking complexity: start with the smallest set (Array/Print/GC-minimal), expand gradually. +- Performance: keep RO-first; benchmark and fall back to HostCall if needed. +- Windows linkage: prioritize Linux/macOS, then handle Win specifics in a follow-up task. + +## References +- `c_abi_unified_design.md` +- `implementation_steps.md` +- `../phase-10.5/` (Python integration) + +--- + +Everything is Plugin → unified paths for JIT and AOT. + diff --git a/examples/array_plugin_demo.nyash b/examples/array_plugin_demo.nyash new file mode 100644 index 00000000..243384d4 --- /dev/null +++ b/examples/array_plugin_demo.nyash @@ -0,0 +1,22 @@ +// ArrayBox plugin demo +// Requires: plugins/nyash-array-plugin built (release) and nyash.toml updated +// Run: +// NYASH_CLI_VERBOSE=1 ./target/release/nyash --backend vm examples/array_plugin_demo.nyash + +static box Main { + main() { + local a, i + a = new ArrayBox() + // push integers 1..5 + i = 1 + loop (i <= 5) { + a.push(i) + i = i + 1 + } + me.console.log("len=", a.length()) + me.console.log("get(0)=", a.get(0)) + me.console.log("get(4)=", a.get(4)) + return a.length() + } +} + diff --git a/examples/array_plugin_set_demo.nyash b/examples/array_plugin_set_demo.nyash new file mode 100644 index 00000000..f73b95ca --- /dev/null +++ b/examples/array_plugin_set_demo.nyash @@ -0,0 +1,20 @@ +// ArrayBox plugin demo (set) +// Build plugin: +// (cd plugins/nyash-array-plugin && cargo build --release) +// Run (plugin host auto-loads from nyash.toml): +// NYASH_CLI_VERBOSE=1 ./target/release/nyash --backend vm examples/array_plugin_set_demo.nyash + +static box Main { + main() { + local a + a = new ArrayBox() + a.push(10) + a.push(20) + a.push(30) + me.console.log("before set, len=", a.length(), ", get(2)=", a.get(2)) + a.set(2, 42) + me.console.log("after set, len=", a.length(), ", get(2)=", a.get(2)) + return a.get(2) + } +} + diff --git a/examples/map_plugin_ro_demo.nyash b/examples/map_plugin_ro_demo.nyash new file mode 100644 index 00000000..9aa31ad5 --- /dev/null +++ b/examples/map_plugin_ro_demo.nyash @@ -0,0 +1,20 @@ +// MapBox plugin demo (RO via plugin: size/get/has), set is VM path. +// Build plugins: +// (cd plugins/nyash-map-plugin && cargo build --release) +// Run: +// NYASH_CLI_VERBOSE=1 ./target/release/nyash --backend vm examples/map_plugin_ro_demo.nyash + +static box Main { + main() { + local m + m = new MapBox() + // mutating ops (VM path) + m.set(1, 100) + m.set(2, 200) + me.console.log("size=", m.size()) + me.console.log("get(1)=", m.get(1)) + me.console.log("has(2)=", m.has(2)) + return m.get(2) + } +} + diff --git a/nyash.toml b/nyash.toml index f85ef56b..bda0fef5 100644 --- a/nyash.toml +++ b/nyash.toml @@ -128,3 +128,30 @@ search_paths = [ "/usr/local/lib/nyash/plugins", "~/.nyash/plugins" ] +[libraries."libnyash_array_plugin.so"] +boxes = ["ArrayBox"] +path = "./plugins/nyash-array-plugin/target/release/libnyash_array_plugin.so" + +[libraries."libnyash_array_plugin.so".ArrayBox] +type_id = 10 + +[libraries."libnyash_array_plugin.so".ArrayBox.methods] +birth = { method_id = 0 } +length = { method_id = 1 } +get = { method_id = 2, args = ["index"] } +push = { method_id = 3, args = ["value"] } +set = { method_id = 4, args = ["index", "value"] } +fini = { method_id = 4294967295 } +[libraries."libnyash_map_plugin.so"] +boxes = ["MapBox"] +path = "./plugins/nyash-map-plugin/target/release/libnyash_map_plugin.so" + +[libraries."libnyash_map_plugin.so".MapBox] +type_id = 11 + +[libraries."libnyash_map_plugin.so".MapBox.methods] +birth = { method_id = 0 } +size = { method_id = 1 } +get = { method_id = 2, args = ["key"] } +has = { method_id = 3, args = ["key"] } +fini = { method_id = 4294967295 } diff --git a/plugins/nyash-array-plugin/Cargo.toml b/plugins/nyash-array-plugin/Cargo.toml new file mode 100644 index 00000000..9aa35719 --- /dev/null +++ b/plugins/nyash-array-plugin/Cargo.toml @@ -0,0 +1,10 @@ +[package] +name = "nyash-array-plugin" +version = "0.1.0" +edition = "2021" + +[lib] +crate-type = ["cdylib", "staticlib"] + +[dependencies] +once_cell = "1.20" diff --git a/plugins/nyash-array-plugin/src/lib.rs b/plugins/nyash-array-plugin/src/lib.rs new file mode 100644 index 00000000..056c321c --- /dev/null +++ b/plugins/nyash-array-plugin/src/lib.rs @@ -0,0 +1,176 @@ +//! Nyash ArrayBox Plugin - Minimal BID-FFI v1 +//! Methods: birth(0), length(1), get(2), push(3), fini(u32::MAX) + +use once_cell::sync::Lazy; +use std::collections::HashMap; +use std::sync::{Mutex, atomic::{AtomicU32, Ordering}}; + +// ===== Error Codes (aligned with existing plugins) ===== +const NYB_SUCCESS: i32 = 0; +const NYB_E_SHORT_BUFFER: i32 = -1; +const NYB_E_INVALID_TYPE: i32 = -2; +const NYB_E_INVALID_METHOD: i32 = -3; +const NYB_E_INVALID_ARGS: i32 = -4; +const NYB_E_PLUGIN_ERROR: i32 = -5; +const NYB_E_INVALID_HANDLE: i32 = -8; + +// ===== Method IDs ===== +const METHOD_BIRTH: u32 = 0; // constructor -> returns instance_id (u32 LE, no TLV) +const METHOD_LENGTH: u32 = 1; // returns TLV i64 +const METHOD_GET: u32 = 2; // args: i64 index -> returns TLV i64 +const METHOD_PUSH: u32 = 3; // args: i64 value -> returns TLV i64 (new length) +const METHOD_SET: u32 = 4; // args: i64 index, i64 value -> returns TLV i64 (new length) +const METHOD_FINI: u32 = u32::MAX; // destructor + +// Assign a unique type_id for ArrayBox (as declared in nyash.toml) +const TYPE_ID_ARRAY: u32 = 10; + +// ===== Instance state (PoC: store i64 values only) ===== +struct ArrayInstance { data: Vec } + +static INSTANCES: Lazy>> = Lazy::new(|| Mutex::new(HashMap::new())); +static INSTANCE_COUNTER: AtomicU32 = AtomicU32::new(1); + +#[no_mangle] +pub extern "C" fn nyash_plugin_abi() -> u32 { 1 } + +#[no_mangle] +pub extern "C" fn nyash_plugin_init() -> i32 { NYB_SUCCESS } + +#[no_mangle] +pub extern "C" fn nyash_plugin_invoke( + type_id: u32, + method_id: u32, + instance_id: u32, + args: *const u8, + args_len: usize, + result: *mut u8, + result_len: *mut usize, +) -> i32 { + if type_id != TYPE_ID_ARRAY { return NYB_E_INVALID_TYPE; } + + unsafe { + match method_id { + METHOD_BIRTH => { + if result_len.is_null() { return NYB_E_INVALID_ARGS; } + if preflight(result, result_len, 4) { return NYB_E_SHORT_BUFFER; } + let id = INSTANCE_COUNTER.fetch_add(1, Ordering::Relaxed); + if let Ok(mut map) = INSTANCES.lock() { + map.insert(id, ArrayInstance { data: Vec::new() }); + } else { return NYB_E_PLUGIN_ERROR; } + let bytes = id.to_le_bytes(); + std::ptr::copy_nonoverlapping(bytes.as_ptr(), result, 4); + *result_len = 4; + NYB_SUCCESS + } + METHOD_FINI => { + if let Ok(mut map) = INSTANCES.lock() { + map.remove(&instance_id); + NYB_SUCCESS + } else { NYB_E_PLUGIN_ERROR } + } + METHOD_LENGTH => { + if let Ok(map) = INSTANCES.lock() { + if let Some(inst) = map.get(&instance_id) { + return write_tlv_i64(inst.data.len() as i64, result, result_len); + } else { return NYB_E_INVALID_HANDLE; } + } else { return NYB_E_PLUGIN_ERROR; } + } + METHOD_GET => { + let idx = match read_arg_i64(args, args_len, 0) { Some(v) => v, None => return NYB_E_INVALID_ARGS }; + if idx < 0 { return NYB_E_INVALID_ARGS; } + if let Ok(map) = INSTANCES.lock() { + if let Some(inst) = map.get(&instance_id) { + let i = idx as usize; + if i >= inst.data.len() { return NYB_E_INVALID_ARGS; } + return write_tlv_i64(inst.data[i], result, result_len); + } else { return NYB_E_INVALID_HANDLE; } + } else { return NYB_E_PLUGIN_ERROR; } + } + METHOD_PUSH => { + let val = match read_arg_i64(args, args_len, 0) { Some(v) => v, None => return NYB_E_INVALID_ARGS }; + if let Ok(mut map) = INSTANCES.lock() { + if let Some(inst) = map.get_mut(&instance_id) { + inst.data.push(val); + return write_tlv_i64(inst.data.len() as i64, result, result_len); + } else { return NYB_E_INVALID_HANDLE; } + } else { return NYB_E_PLUGIN_ERROR; } + } + METHOD_SET => { + let idx = match read_arg_i64(args, args_len, 0) { Some(v) => v, None => return NYB_E_INVALID_ARGS }; + let val = match read_arg_i64(args, args_len, 1) { Some(v) => v, None => return NYB_E_INVALID_ARGS }; + if idx < 0 { return NYB_E_INVALID_ARGS; } + if let Ok(mut map) = INSTANCES.lock() { + if let Some(inst) = map.get_mut(&instance_id) { + let i = idx as usize; + if i >= inst.data.len() { return NYB_E_INVALID_ARGS; } + inst.data[i] = val; + return write_tlv_i64(inst.data.len() as i64, result, result_len); + } else { return NYB_E_INVALID_HANDLE; } + } else { return NYB_E_PLUGIN_ERROR; } + } + _ => NYB_E_INVALID_METHOD, + } + } +} + +// ===== Minimal TLV helpers (compatible with host expectations) ===== +fn preflight(result: *mut u8, result_len: *mut usize, needed: usize) -> bool { + unsafe { + if result_len.is_null() { return false; } + if result.is_null() || *result_len < needed { + *result_len = needed; + return true; + } + } + false +} + +fn write_tlv_result(payloads: &[(u8, &[u8])], result: *mut u8, result_len: *mut usize) -> i32 { + if result_len.is_null() { return NYB_E_INVALID_ARGS; } + let mut buf: Vec = Vec::with_capacity(4 + payloads.iter().map(|(_,p)| 4 + p.len()).sum::()); + buf.extend_from_slice(&1u16.to_le_bytes()); // version + buf.extend_from_slice(&(payloads.len() as u16).to_le_bytes()); // argc + for (tag, payload) in payloads { + buf.push(*tag); + buf.push(0); + buf.extend_from_slice(&(payload.len() as u16).to_le_bytes()); + buf.extend_from_slice(payload); + } + unsafe { + let needed = buf.len(); + if result.is_null() || *result_len < needed { + *result_len = needed; + return NYB_E_SHORT_BUFFER; + } + std::ptr::copy_nonoverlapping(buf.as_ptr(), result, needed); + *result_len = needed; + } + NYB_SUCCESS +} + +fn write_tlv_i64(v: i64, result: *mut u8, result_len: *mut usize) -> i32 { + write_tlv_result(&[(3u8, &v.to_le_bytes())], result, result_len) +} + +/// Read nth TLV argument as i64 (tag 3) +fn read_arg_i64(args: *const u8, args_len: usize, n: usize) -> Option { + if args.is_null() || args_len < 4 { return None; } + let buf = unsafe { std::slice::from_raw_parts(args, args_len) }; + let mut off = 4usize; // skip header + for i in 0..=n { + if buf.len() < off + 4 { return None; } + let tag = buf[off]; + let _rsv = buf[off+1]; + let size = u16::from_le_bytes([buf[off+2], buf[off+3]]) as usize; + if buf.len() < off + 4 + size { return None; } + if i == n { + if tag != 3 || size != 8 { return None; } + let mut b = [0u8;8]; + b.copy_from_slice(&buf[off+4 .. off+4+8]); + return Some(i64::from_le_bytes(b)); + } + off += 4 + size; + } + None +} diff --git a/plugins/nyash-map-plugin/Cargo.toml b/plugins/nyash-map-plugin/Cargo.toml new file mode 100644 index 00000000..961a6988 --- /dev/null +++ b/plugins/nyash-map-plugin/Cargo.toml @@ -0,0 +1,11 @@ +[package] +name = "nyash-map-plugin" +version = "0.1.0" +edition = "2021" + +[lib] +crate-type = ["cdylib", "staticlib"] + +[dependencies] +once_cell = "1.20" + diff --git a/plugins/nyash-map-plugin/src/lib.rs b/plugins/nyash-map-plugin/src/lib.rs new file mode 100644 index 00000000..f074b7bb --- /dev/null +++ b/plugins/nyash-map-plugin/src/lib.rs @@ -0,0 +1,142 @@ +//! Nyash MapBox Plugin - Minimal BID-FFI v1 (RO path only) +//! Methods: birth(0), size(1), get(2), has(3), fini(u32::MAX) + +use once_cell::sync::Lazy; +use std::collections::HashMap; +use std::sync::{Mutex, atomic::{AtomicU32, Ordering}}; + +// Error codes +const NYB_SUCCESS: i32 = 0; +const NYB_E_SHORT_BUFFER: i32 = -1; +const NYB_E_INVALID_TYPE: i32 = -2; +const NYB_E_INVALID_METHOD: i32 = -3; +const NYB_E_INVALID_ARGS: i32 = -4; +const NYB_E_PLUGIN_ERROR: i32 = -5; +const NYB_E_INVALID_HANDLE: i32 = -8; + +// Methods +const METHOD_BIRTH: u32 = 0; +const METHOD_SIZE: u32 = 1; +const METHOD_GET: u32 = 2; // args: i64 key -> TLV i64 +const METHOD_HAS: u32 = 3; // args: i64 key -> TLV bool +const METHOD_FINI: u32 = u32::MAX; + +// Type id (nyash.toml に合わせる) +const TYPE_ID_MAP: u32 = 11; + +struct MapInstance { data: HashMap } +static INSTANCES: Lazy>> = Lazy::new(|| Mutex::new(HashMap::new())); +static INSTANCE_COUNTER: AtomicU32 = AtomicU32::new(1); + +#[no_mangle] +pub extern "C" fn nyash_plugin_abi() -> u32 { 1 } + +#[no_mangle] +pub extern "C" fn nyash_plugin_init() -> i32 { NYB_SUCCESS } + +#[no_mangle] +pub extern "C" fn nyash_plugin_invoke( + type_id: u32, + method_id: u32, + instance_id: u32, + args: *const u8, + args_len: usize, + result: *mut u8, + result_len: *mut usize, +) -> i32 { + if type_id != TYPE_ID_MAP { return NYB_E_INVALID_TYPE; } + unsafe { + match method_id { + METHOD_BIRTH => { + if result_len.is_null() { return NYB_E_INVALID_ARGS; } + if preflight(result, result_len, 4) { return NYB_E_SHORT_BUFFER; } + let id = INSTANCE_COUNTER.fetch_add(1, Ordering::Relaxed); + if let Ok(mut map) = INSTANCES.lock() { map.insert(id, MapInstance { data: HashMap::new() }); } else { return NYB_E_PLUGIN_ERROR; } + std::ptr::copy_nonoverlapping(id.to_le_bytes().as_ptr(), result, 4); + *result_len = 4; + NYB_SUCCESS + } + METHOD_FINI => { + if let Ok(mut map) = INSTANCES.lock() { map.remove(&instance_id); NYB_SUCCESS } else { NYB_E_PLUGIN_ERROR } + } + METHOD_SIZE => { + if let Ok(map) = INSTANCES.lock() { + if let Some(inst) = map.get(&instance_id) { write_tlv_i64(inst.data.len() as i64, result, result_len) } else { NYB_E_INVALID_HANDLE } + } else { NYB_E_PLUGIN_ERROR } + } + METHOD_GET => { + let key = match read_arg_i64(args, args_len, 0) { Some(v) => v, None => return NYB_E_INVALID_ARGS }; + if let Ok(map) = INSTANCES.lock() { + if let Some(inst) = map.get(&instance_id) { + match inst.data.get(&key).copied() { Some(v) => write_tlv_i64(v, result, result_len), None => NYB_E_INVALID_ARGS } + } else { NYB_E_INVALID_HANDLE } + } else { NYB_E_PLUGIN_ERROR } + } + METHOD_HAS => { + let key = match read_arg_i64(args, args_len, 0) { Some(v) => v, None => return NYB_E_INVALID_ARGS }; + if let Ok(map) = INSTANCES.lock() { + if let Some(inst) = map.get(&instance_id) { write_tlv_bool(inst.data.contains_key(&key), result, result_len) } else { NYB_E_INVALID_HANDLE } + } else { NYB_E_PLUGIN_ERROR } + } + _ => NYB_E_INVALID_METHOD, + } + } +} + +// TLV helpers +fn preflight(result: *mut u8, result_len: *mut usize, needed: usize) -> bool { + unsafe { + if result_len.is_null() { return false; } + if result.is_null() || *result_len < needed { + *result_len = needed; + return true; + } + } + false +} + +fn write_tlv_result(payloads: &[(u8, &[u8])], result: *mut u8, result_len: *mut usize) -> i32 { + if result_len.is_null() { return NYB_E_INVALID_ARGS; } + let mut buf: Vec = Vec::with_capacity(4 + payloads.iter().map(|(_,p)| 4 + p.len()).sum::()); + buf.extend_from_slice(&1u16.to_le_bytes()); + buf.extend_from_slice(&(payloads.len() as u16).to_le_bytes()); + for (tag, payload) in payloads { + buf.push(*tag); + buf.push(0); + buf.extend_from_slice(&(payload.len() as u16).to_le_bytes()); + buf.extend_from_slice(payload); + } + unsafe { + let needed = buf.len(); + if result.is_null() || *result_len < needed { + *result_len = needed; + return NYB_E_SHORT_BUFFER; + } + std::ptr::copy_nonoverlapping(buf.as_ptr(), result, needed); + *result_len = needed; + } + NYB_SUCCESS +} + +fn write_tlv_i64(v: i64, result: *mut u8, result_len: *mut usize) -> i32 { write_tlv_result(&[(3u8, &v.to_le_bytes())], result, result_len) } +fn write_tlv_bool(bv: bool, result: *mut u8, result_len: *mut usize) -> i32 { let b = [if bv {1u8} else {0u8}]; write_tlv_result(&[(1u8, &b)], result, result_len) } + +fn read_arg_i64(args: *const u8, args_len: usize, n: usize) -> Option { + if args.is_null() || args_len < 4 { return None; } + let buf = unsafe { std::slice::from_raw_parts(args, args_len) }; + let mut off = 4usize; + for i in 0..=n { + if buf.len() < off + 4 { return None; } + let tag = buf[off]; + let size = u16::from_le_bytes([buf[off+2], buf[off+3]]) as usize; + if buf.len() < off + 4 + size { return None; } + if i == n { + if tag != 3 || size != 8 { return None; } + let mut b = [0u8;8]; b.copy_from_slice(&buf[off+4..off+12]); + return Some(i64::from_le_bytes(b)); + } + off += 4 + size; + } + None +} + diff --git a/src/jit/lower/builder.rs b/src/jit/lower/builder.rs index 838ac12d..47364273 100644 --- a/src/jit/lower/builder.rs +++ b/src/jit/lower/builder.rs @@ -32,6 +32,8 @@ pub trait IRBuilder { fn emit_host_call(&mut self, _symbol: &str, _argc: usize, _has_ret: bool) { } /// Typed host-call emission: params kinds and return type hint (f64 when true) fn emit_host_call_typed(&mut self, _symbol: &str, _params: &[ParamKind], _has_ret: bool, _ret_is_f64: bool) { } + /// Phase 10.2: plugin invoke emission (symbolic; type_id/method_id based) + fn emit_plugin_invoke(&mut self, _type_id: u32, _method_id: u32, _argc: usize, _has_ret: bool) { } // ==== Phase 10.7 (control-flow wiring, default no-op) ==== /// Optional: prepare N basic blocks and return their handles (0..N-1) fn prepare_blocks(&mut self, _count: usize) { } @@ -98,6 +100,7 @@ impl IRBuilder for NoopBuilder { fn emit_branch(&mut self) { self.branches += 1; } fn emit_return(&mut self) { self.rets += 1; } fn emit_host_call_typed(&mut self, _symbol: &str, _params: &[ParamKind], has_ret: bool, _ret_is_f64: bool) { if has_ret { self.consts += 1; } } + fn emit_plugin_invoke(&mut self, _type_id: u32, _method_id: u32, _argc: usize, has_ret: bool) { if has_ret { self.consts += 1; } } fn ensure_local_i64(&mut self, _index: usize) { /* no-op */ } fn store_local_i64(&mut self, _index: usize) { self.consts += 1; } fn load_local_i64(&mut self, _index: usize) { self.consts += 1; } diff --git a/src/jit/lower/core.rs b/src/jit/lower/core.rs index ceac0027..0c523631 100644 --- a/src/jit/lower/core.rs +++ b/src/jit/lower/core.rs @@ -561,15 +561,55 @@ impl LowerCore { b.push_block_param_i64_at(pos); } } - I::ArrayGet { array, index, .. } => { super::core_hostcall::lower_array_get(b, &self.param_index, &self.known_i64, array, index); } - I::ArraySet { array, index, value } => { super::core_hostcall::lower_array_set(b, &self.param_index, &self.known_i64, array, index, value); } + I::ArrayGet { array, index, .. } => { + if std::env::var("NYASH_USE_PLUGIN_BUILTINS").ok().as_deref() == Some("1") { + // Plugin path: ArrayBox.get(index) + if let Ok(ph) = crate::runtime::plugin_loader_unified::get_global_plugin_host().read() { + if let Ok(h) = ph.resolve_method("ArrayBox", "get") { + // receiver + if let Some(pidx) = self.param_index.get(array).copied() { b.emit_param_i64(pidx); } else { b.emit_const_i64(-1); } + // index + if let Some(iv) = self.known_i64.get(index).copied() { b.emit_const_i64(iv); } else { self.push_value_if_known_or_param(b, index); } + b.emit_plugin_invoke(h.type_id, h.method_id, 2, true); + crate::jit::events::emit_lower( + serde_json::json!({ + "id": format!("plugin:{}:{}", h.box_type, "get"), + "decision":"allow","reason":"plugin_invoke","argc": 2, + "type_id": h.type_id, "method_id": h.method_id + }), + "plugin","" + ); + } + } + } else { + super::core_hostcall::lower_array_get(b, &self.param_index, &self.known_i64, array, index); + } + } + I::ArraySet { array, index, value } => { + if std::env::var("NYASH_USE_PLUGIN_BUILTINS").ok().as_deref() == Some("1") { + if let Ok(ph) = crate::runtime::plugin_loader_unified::get_global_plugin_host().read() { + if let Ok(h) = ph.resolve_method("ArrayBox", "set") { + if let Some(pidx) = self.param_index.get(array).copied() { b.emit_param_i64(pidx); } else { b.emit_const_i64(-1); } + if let Some(iv) = self.known_i64.get(index).copied() { b.emit_const_i64(iv); } else { self.push_value_if_known_or_param(b, index); } + if let Some(vv) = self.known_i64.get(value).copied() { b.emit_const_i64(vv); } else { self.push_value_if_known_or_param(b, value); } + b.emit_plugin_invoke(h.type_id, h.method_id, 3, false); + crate::jit::events::emit_lower( + serde_json::json!({ + "id": format!("plugin:{}:{}", h.box_type, "set"), + "decision":"allow","reason":"plugin_invoke","argc": 3, + "type_id": h.type_id, "method_id": h.method_id + }), + "plugin","" + ); + } + } + } else { + super::core_hostcall::lower_array_set(b, &self.param_index, &self.known_i64, array, index, value); + } + } I::BoxCall { box_val: array, method, args, dst, .. } => { if super::core_hostcall::lower_boxcall_simple_reads(b, &self.param_index, &self.known_i64, array, method.as_str(), args, dst.clone()) { // handled in helper (read-only simple methods) - } else if method.as_str() == "get" { - super::core_hostcall::lower_map_get(func, b, &self.param_index, &self.known_i64, array, args, dst.clone()); - } else if method.as_str() == "has" { - super::core_hostcall::lower_map_has(b, &self.param_index, &self.known_i64, array, args, dst.clone()); } else if matches!(method.as_str(), "sin" | "cos" | "abs" | "min" | "max") { super::core_hostcall::lower_math_call( func, @@ -581,6 +621,65 @@ impl LowerCore { args, dst.clone(), ); + } else if std::env::var("NYASH_USE_PLUGIN_BUILTINS").ok().as_deref() == Some("1") { + match method.as_str() { + "len" | "length" | "push" | "get" | "set" => { + // Resolve ArrayBox plugin method and emit plugin_invoke (symbolic) + if let Ok(ph) = crate::runtime::plugin_loader_unified::get_global_plugin_host().read() { + let mname = if method.as_str() == "len" { "length" } else { method.as_str() }; + if let Ok(h) = ph.resolve_method("ArrayBox", mname) { + // Receiver + if let Some(pidx) = self.param_index.get(array).copied() { b.emit_param_i64(pidx); } else { b.emit_const_i64(-1); } + let mut argc = 1usize; + match mname { + "push" | "get" => { + if let Some(v) = args.get(0) { self.push_value_if_known_or_param(b, v); } else { b.emit_const_i64(0); } + argc += 1; + } + "set" => { + // two args: index, value + if let Some(v) = args.get(0) { self.push_value_if_known_or_param(b, v); } else { b.emit_const_i64(0); } + if let Some(v2) = args.get(1) { self.push_value_if_known_or_param(b, v2); } else { b.emit_const_i64(0); } + argc += 2; + } + _ => {} + } + b.emit_plugin_invoke(h.type_id, h.method_id, argc, dst.is_some()); + crate::jit::events::emit_lower( + serde_json::json!({ + "id": format!("plugin:{}:{}", h.box_type, mname), + "decision":"allow","reason":"plugin_invoke","argc": argc, + "type_id": h.type_id, "method_id": h.method_id + }), + "plugin","" + ); + } + } + } + // Map (RO): size/get/has + "size" | "get" | "has" => { + if let Ok(ph) = crate::runtime::plugin_loader_unified::get_global_plugin_host().read() { + if let Ok(h) = ph.resolve_method("MapBox", method.as_str()) { + if let Some(pidx) = self.param_index.get(array).copied() { b.emit_param_i64(pidx); } else { b.emit_const_i64(-1); } + let mut argc = 1usize; + if matches!(method.as_str(), "get" | "has") { + if let Some(v) = args.get(0) { self.push_value_if_known_or_param(b, v); } else { b.emit_const_i64(0); } + argc += 1; + } + b.emit_plugin_invoke(h.type_id, h.method_id, argc, dst.is_some()); + crate::jit::events::emit_lower( + serde_json::json!({ + "id": format!("plugin:{}:{}", h.box_type, method.as_str()), + "decision":"allow","reason":"plugin_invoke","argc": argc, + "type_id": h.type_id, "method_id": h.method_id + }), + "plugin","" + ); + } + } + } + _ => { /* other BoxCalls handled below */ } + } } else if crate::jit::config::current().hostcall { match method.as_str() { "len" | "length" => {