diff --git a/CURRENT_TASK.md b/CURRENT_TASK.md index 36592405..2c44cadd 100644 --- a/CURRENT_TASK.md +++ b/CURRENT_TASK.md @@ -2,7 +2,57 @@ このドキュメントは「いま何をすれば良いか」を最小で共有するためのコンパクト版です。詳細は git 履歴と `docs/`（phase-15）を参照してください。 -— 最終更新: 2025‑09‑06 (Phase 15.17 反映, Core‑13 純化モード/LLVM AOT shim 拡張) +— 最終更新: 2025‑09‑08 (LLVM Core‑13 安定化 P0 進捗更新) + +【Quick Update — LLVM Core‑13 P0】 +現状 +- ビルド環境は LLVM 18 検出済み（`LLVM_SYS_180_PREFIX=/usr/lib/llvm-18`）。 +- 代表的なビルドエラーは次の3点に収束。 + 1) Opaque Pointer 由来: `PointerType::get_element_type()` 不在 → i8* 判別経路をヒューリスティックに簡素化。 + 2) IntegerBox API: `.value()` 誤用 → `.value` に修正（フィールド参照）。 + 3) BinaryOp 網羅: BitAnd/BitOr/BitXor/Shl/Shr 未対応 → いったん `_ => todo!()` で回避。 + +対応済み +- `src/backend/llvm/compiler.rs` + - `env.box.new` の opaque 対応（i8* は `nyash.box.from_i8_string` を呼ぶ単純化）。 + - `.value()`→`.value` を修正（BinOpパス）。 + - 末尾 mock BinOp に `_ => todo!()` を追加。 + +残タスク（P0完了条件） +- `env.box.new`（new_i64x 側）の引数 i64 化クロージャを完全インライン化（lifetime エラー解消）。 +- BinOp 未網羅の match 箇所をもう1か所整理（`_ => todo!()` か軽実装）。 +- 再ビルド通過後、代表スモークの一致確認。 + +代表スモーク +- ビルド: `LLVM_SYS_180_PREFIX=$(llvm-config-18 --prefix) cargo build --release --features llvm` +- 実行: `tools/build_llvm.sh apps/tests/mir-compare-multi/main.nyash -o app && ./app` +- 受け入れ: VM と同一の戻り値（Core‑13 正規化パスに依存：`NYASH_MIR_CORE13=1` 既定ON） + +メモ +- 作業ディレクトリ: `/mnt/c/git/nyash-project/nyash_llvm`（branch: `llvm-dev`） +- 次の commit で P0 を締め、P1（ビット演算/Shift 実装）に移行する。 + +【Phase 17.1 — LLVM Core‑13 安定化（専用worktree/branch）】 +目的 +- Core‑13 正規化後の MIR を LLVM AOT に下ろし、VM と同値の代表ケースを安定動作させる。 + +作業環境 +- worktree: /mnt/c/git/nyash-project/nyash_llvm （branch: llvm-dev, origin/llvm-dev 追従） +- LLVM 18 前提: `LLVM_SYS_180_PREFIX=$(llvm-config-18 --prefix)` + +短期タスク（P0） +- Opaque Pointer 対応: Inkwell 0.6 + LLVM 18 に合わせ、`get_element_type()` 等を使用しない降ろしに修正。 + - `env.box.new` の引数ハンドリングをヒューリスティックに単純化（i8* は `nyash.box.from_i8_string`） +- IntegerBox API 整合: `.value()` → `.value` に是正（フィールド参照）。 +- BinaryOp の網羅性: `BitAnd/BitOr/BitXor/Shl/Shr` 未対応を `_ => todo!()` で一旦回避（代表スモーク優先）。 + +検証（P0） +- ビルド: `LLVM_SYS_180_PREFIX=$(llvm-config-18 --prefix) cargo build --release --features llvm` +- 代表スモーク: `tools/build_llvm.sh apps/tests/mir-compare-multi/main.nyash -o app && ./app`（VM一致） + +後続（P1） +- ビット演算/シフトの実装と検証（LLVM 降ろし/IR 生成/実行互換）。 +- AOT 実行の戻り値と型変換経路の整理（i64/handle→Box materialize）。 【ハンドオフ（2025‑09‑06 final）— String.length 修正 完了／JIT 実行を封印し四体制へ】 @@ -468,6 +518,21 @@ Phase A 進捗（実施済） ■ 現在のフォーカス（JITオンリー／一旦の着地） 1) Core 緑維持（完了） - `tools/jit_smoke.sh` / Roundtrip(A/B) / Bootstrap(c0→c1→c1') / Using E2E = PASS + +【P1 進捗 — LLVM Core-13: ビット演算/シフト】 +実装 +- LLVM 降ろしで `BinaryOp::{BitAnd,BitOr,BitXor,Shl,Shr}` を i64 経路に実装済み（既存）。 +- `compile_and_execute` の MIR インタプリタにも同演算を実装し、パリティを確保。 + +検証 +- 単体テスト追加: `src/tests/llvm_bitops_test.rs` + - MIR を直接構築して `1=(5&3),7=(5|2),4=(5^1),32=(1<<5),4=(32>>3)` の合計 48 を検証。 + - VM 実行で 48、LLVM `compile_to_object` がエラーなく emit、`compile_and_execute` でも 48 を確認（フォールバック実行）。 +- AOT スモーク（任意）: `tools/llvm_smoke.sh` に `NYASH_LLVM_BITOPS_SMOKE=1` で有効化する項目を追加（入力は Nyash ソース制約のため現状 skip 既定）。 + +注意 +- Nyash ソースパーサが `&|^<<>>` を未サポートのため、ビット演算の E2E は当面 MIR 直構築テストで担保。 + 将来 `grammar/` の演算子追加後に `apps/tests/ny-llvm-bitops/` を有効化予定。 2) CI 分離（完了） - Core（常時）: `tools/jit_smoke.sh` + Roundtrip - Plugins（任意）: `NYASH_SKIP_TOML_ENV=1 ./tools/smoke_plugins.sh`（strict既定OFF、`NYASH_PLUGINS_STRICT=1`でON） diff --git a/apps/tests/ny-llvm-bitops/main.nyash b/apps/tests/ny-llvm-bitops/main.nyash new file mode 100644 index 00000000..5d866b85 --- /dev/null +++ b/apps/tests/ny-llvm-bitops/main.nyash @@ -0,0 +1,19 @@ +// ny-llvm-bitops - ビット演算とシフト演算の LLVM/AOT スモーク +// 期待: Result: 48 + +static box Main { + main() { + // Integer 演算の網羅（i64 経路） + local a = 5 & 3 // 1 + local b = 5 | 2 // 7 + local c = 5 ^ 1 // 4 + local d = 1 << 5 // 32 + local e = 32 >> 3 // 4 (算術/論理は i64 上の右シフト: 実装は算術/false指定) + + local sum = a + b + c + d + e // 1+7+4+32+4 = 48 + + print("Result: " + sum) + return 0 + } +} + diff --git a/src/backend/llvm/compiler.rs b/src/backend/llvm/compiler.rs index 770f2a6a..0ad3fed4 100644 --- a/src/backend/llvm/compiler.rs +++ b/src/backend/llvm/compiler.rs @@ -127,16 +127,19 @@ impl LLVMCompiler { if let (Some(l), Some(r)) = (left.as_any().downcast_ref::(), right.as_any().downcast_ref::()) { let result = match op { - BinaryOp::Add => l.value() + r.value(), - BinaryOp::Sub => l.value() - r.value(), - BinaryOp::Mul => l.value() * r.value(), + BinaryOp::Add => l.value + r.value, + BinaryOp::Sub => l.value - r.value, + BinaryOp::Mul => l.value * r.value, BinaryOp::Div => { - if r.value() == 0 { + if r.value == 0 { return Err("Division by zero".to_string()); } - l.value() / r.value() + l.value / r.value + } + BinaryOp::Mod => l.value % r.value, + _ => { + return Err("Binary operation not supported in mock".to_string()); } - BinaryOp::Mod => l.value() % r.value(), }; self.values.insert(*dst, Box::new(IntegerBox::new(result))); println!(" 📊 %{} = %{} {:?} %{} = {}", dst.0, lhs.0, op, rhs.0, result); @@ -221,6 +224,8 @@ use inkwell::context::Context; #[cfg(feature = "llvm")] use inkwell::{values::{BasicValueEnum, FloatValue, IntValue, PhiValue, FunctionValue, PointerValue}, types::{BasicTypeEnum, IntType, FloatType, PointerType}, AddressSpace}; #[cfg(feature = "llvm")] +use inkwell::types::BasicType; // for as_basic_type_enum() +#[cfg(feature = "llvm")] use std::collections::HashMap as StdHashMap; #[cfg(feature = "llvm")] @@ -900,68 +905,115 @@ impl LLVMCompiler { let tyv = *vmap.get(&args[0]).ok_or("type name arg missing")?; let ty_ptr = match tyv { BasicValueEnum::PointerValue(p) => p, _ => return Err("env.box.new type must be i8* string".to_string()) }; let i64t = codegen.context.i64_type(); - let ret_to_ptr = |rv: BasicValueEnum| -> Result { - let i64v = if let BasicValueEnum::IntValue(iv) = rv { iv } else { return Err("env.box.new ret expected i64".to_string()); }; - let pty = i8p; - let ptr = codegen.builder.build_int_to_ptr(i64v, pty, "box_handle_to_ptr").map_err(|e| e.to_string())?; - Ok(ptr.into()) - }; - // Helper: coerce arbitrary BasicValueEnum to i64; for i8* assume string and convert to box-handle via nyash.box.from_i8_string - let to_i64 = |v: BasicValueEnum| -> Result { - match v { - BasicValueEnum::IntValue(iv) => Ok(iv), - BasicValueEnum::FloatValue(fv) => { - // Route via NyRT: i64 @nyash.box.from_f64(double) - let i64t = codegen.context.i64_type(); - let fnty = i64t.fn_type(&[codegen.context.f64_type().into()], false); - let callee = codegen.module.get_function("nyash.box.from_f64").unwrap_or_else(|| codegen.module.add_function("nyash.box.from_f64", fnty, None)); - let call = codegen.builder.build_call(callee, &[fv.into()], "arg_f64_to_box").map_err(|e| e.to_string())?; - let rv = call.try_as_basic_value().left().ok_or("from_f64 returned void".to_string())?; - if let BasicValueEnum::IntValue(h) = rv { Ok(h) } else { Err("from_f64 ret expected i64".to_string()) } - } - BasicValueEnum::PointerValue(pv) => { - // If pointer is i8*, call nyash.box.from_i8_string to obtain a handle (i64) - let ty = pv.get_type(); - let elem = ty.get_element_type(); - if elem == codegen.context.i8_type().as_basic_type_enum() { - let i64t = codegen.context.i64_type(); - let fnty = i64t.fn_type(&[i8p.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 = codegen.builder.build_call(callee, &[pv.into()], "arg_i8_to_box").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 BasicValueEnum::IntValue(h) = rv { Ok(h) } else { Err("from_i8_string ret expected i64".to_string()) } - } else { - Ok(codegen.builder.build_ptr_to_int(pv, codegen.context.i64_type(), "p2i").map_err(|e| e.to_string())?) - } - } - _ => Err("unsupported arg value for env.box.new".to_string()), - } - }; - let out_val = if args.len() == 1 { + // 1) new(type) + let out_ptr: PointerValue = if args.len() == 1 { let fnty = i64t.fn_type(&[i8p.into()], false); let callee = codegen.module.get_function("nyash.env.box.new").unwrap_or_else(|| codegen.module.add_function("nyash.env.box.new", fnty, None)); let call = codegen.builder.build_call(callee, &[ty_ptr.into()], "env_box_new").map_err(|e| e.to_string())?; - call.try_as_basic_value().left().ok_or("env.box.new returned void".to_string())? + let rv = call.try_as_basic_value().left().ok_or("env.box.new returned void".to_string())?; + let i64v = if let BasicValueEnum::IntValue(iv) = rv { iv } else { return Err("env.box.new ret expected i64".to_string()); }; + codegen.builder.build_int_to_ptr(i64v, i8p, "box_handle_to_ptr").map_err(|e| e.to_string())? } else { - // Support up to 4 args for now + // 2) new_i64x(type, argc, a1..a4) if args.len() - 1 > 4 { return Err("env.box.new supports up to 4 args in AOT shim".to_string()); } let fnty = i64t.fn_type(&[i8p.into(), i64t.into(), i64t.into(), i64t.into(), i64t.into(), i64t.into()], false); let callee = codegen.module.get_function("nyash.env.box.new_i64x").unwrap_or_else(|| codegen.module.add_function("nyash.env.box.new_i64x", fnty, None)); let argc_val = i64t.const_int((args.len() - 1) as u64, false); - // helper to coerce to i64 - let get_i64 = |vid: ValueId| -> Result { to_i64(*vmap.get(&vid).ok_or("arg missing")?) }; + // Inline-coerce up to 4 args to i64 handles (int pass-through, f64→box, i8*→box) let mut a1 = i64t.const_zero(); + if args.len() >= 2 { + let bv = *vmap.get(&args[1]).ok_or("arg missing")?; + a1 = match bv { + BasicValueEnum::IntValue(iv) => iv, + BasicValueEnum::FloatValue(fv) => { + let fnty = i64t.fn_type(&[codegen.context.f64_type().into()], false); + let callee = codegen.module.get_function("nyash.box.from_f64").unwrap_or_else(|| codegen.module.add_function("nyash.box.from_f64", fnty, None)); + let call = codegen.builder.build_call(callee, &[fv.into()], "arg1_f64_to_box").map_err(|e| e.to_string())?; + let rv = call.try_as_basic_value().left().ok_or("from_f64 returned void".to_string())?; + if let BasicValueEnum::IntValue(h) = rv { h } else { return Err("from_f64 ret expected i64".to_string()); } + } + BasicValueEnum::PointerValue(pv) => { + let fnty = i64t.fn_type(&[i8p.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 = codegen.builder.build_call(callee, &[pv.into()], "arg1_i8_to_box").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 BasicValueEnum::IntValue(h) = rv { h } else { return Err("from_i8_string ret expected i64".to_string()); } + } + _ => { return Err("unsupported arg value for env.box.new".to_string()); } + }; + } let mut a2 = i64t.const_zero(); - if args.len() >= 2 { a1 = get_i64(args[1])?; } - if args.len() >= 3 { a2 = get_i64(args[2])?; } + if args.len() >= 3 { + let bv = *vmap.get(&args[2]).ok_or("arg missing")?; + a2 = match bv { + BasicValueEnum::IntValue(iv) => iv, + BasicValueEnum::FloatValue(fv) => { + let fnty = i64t.fn_type(&[codegen.context.f64_type().into()], false); + let callee = codegen.module.get_function("nyash.box.from_f64").unwrap_or_else(|| codegen.module.add_function("nyash.box.from_f64", fnty, None)); + let call = codegen.builder.build_call(callee, &[fv.into()], "arg2_f64_to_box").map_err(|e| e.to_string())?; + let rv = call.try_as_basic_value().left().ok_or("from_f64 returned void".to_string())?; + if let BasicValueEnum::IntValue(h) = rv { h } else { return Err("from_f64 ret expected i64".to_string()); } + } + BasicValueEnum::PointerValue(pv) => { + let fnty = i64t.fn_type(&[i8p.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 = codegen.builder.build_call(callee, &[pv.into()], "arg2_i8_to_box").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 BasicValueEnum::IntValue(h) = rv { h } else { return Err("from_i8_string ret expected i64".to_string()); } + } + _ => { return Err("unsupported arg value for env.box.new".to_string()); } + }; + } let mut a3 = i64t.const_zero(); + if args.len() >= 4 { + let bv = *vmap.get(&args[3]).ok_or("arg missing")?; + a3 = match bv { + BasicValueEnum::IntValue(iv) => iv, + BasicValueEnum::FloatValue(fv) => { + let fnty = i64t.fn_type(&[codegen.context.f64_type().into()], false); + let callee = codegen.module.get_function("nyash.box.from_f64").unwrap_or_else(|| codegen.module.add_function("nyash.box.from_f64", fnty, None)); + let call = codegen.builder.build_call(callee, &[fv.into()], "arg3_f64_to_box").map_err(|e| e.to_string())?; + let rv = call.try_as_basic_value().left().ok_or("from_f64 returned void".to_string())?; + if let BasicValueEnum::IntValue(h) = rv { h } else { return Err("from_f64 ret expected i64".to_string()); } + } + BasicValueEnum::PointerValue(pv) => { + let fnty = i64t.fn_type(&[i8p.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 = codegen.builder.build_call(callee, &[pv.into()], "arg3_i8_to_box").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 BasicValueEnum::IntValue(h) = rv { h } else { return Err("from_i8_string ret expected i64".to_string()); } + } + _ => { return Err("unsupported arg value for env.box.new".to_string()); } + }; + } let mut a4 = i64t.const_zero(); - if args.len() >= 4 { a3 = get_i64(args[3])?; } - if args.len() >= 5 { a4 = get_i64(args[4])?; } + if args.len() >= 5 { + let bv = *vmap.get(&args[4]).ok_or("arg missing")?; + a4 = match bv { + BasicValueEnum::IntValue(iv) => iv, + BasicValueEnum::FloatValue(fv) => { + let fnty = i64t.fn_type(&[codegen.context.f64_type().into()], false); + let callee = codegen.module.get_function("nyash.box.from_f64").unwrap_or_else(|| codegen.module.add_function("nyash.box.from_f64", fnty, None)); + let call = codegen.builder.build_call(callee, &[fv.into()], "arg4_f64_to_box").map_err(|e| e.to_string())?; + let rv = call.try_as_basic_value().left().ok_or("from_f64 returned void".to_string())?; + if let BasicValueEnum::IntValue(h) = rv { h } else { return Err("from_f64 ret expected i64".to_string()); } + } + BasicValueEnum::PointerValue(pv) => { + let fnty = i64t.fn_type(&[i8p.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 = codegen.builder.build_call(callee, &[pv.into()], "arg4_i8_to_box").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 BasicValueEnum::IntValue(h) = rv { h } else { return Err("from_i8_string ret expected i64".to_string()); } + } + _ => { return Err("unsupported arg value for env.box.new".to_string()); } + }; + } let call = codegen.builder.build_call(callee, &[ty_ptr.into(), argc_val.into(), a1.into(), a2.into(), a3.into(), a4.into()], "env_box_new_i64x").map_err(|e| e.to_string())?; - call.try_as_basic_value().left().ok_or("env.box.new_i64 returned void".to_string())? + let rv = call.try_as_basic_value().left().ok_or("env.box.new_i64 returned void".to_string())?; + let i64v = if let BasicValueEnum::IntValue(iv) = rv { iv } else { return Err("env.box.new_i64 ret expected i64".to_string()); }; + codegen.builder.build_int_to_ptr(i64v, i8p, "box_handle_to_ptr").map_err(|e| e.to_string())? }; - if let Some(d) = dst { vmap.insert(*d, ret_to_ptr(out_val)?); } + if let Some(d) = dst { vmap.insert(*d, out_ptr.into()); } } else { return Err(format!("ExternCall lowering unsupported: {}.{} (enable NYASH_LLVM_ALLOW_BY_NAME=1 to try by-name, or add a NyRT shim)", iface_name, method_name)); } @@ -969,7 +1021,7 @@ impl LLVMCompiler { MirInstruction::UnaryOp { dst, op, operand } => { let v = *vmap.get(operand).ok_or("operand missing")?; let out = match op { - UnaryOp::Neg => { + UnaryOp::Neg => { if let Some(iv) = as_int(v) { codegen.builder.build_int_neg(iv, "ineg").map_err(|e| e.to_string())?.into() } else if let Some(fv) = as_float(v) { codegen.builder.build_float_neg(fv, "fneg").map_err(|e| e.to_string())?.into() } else { return Err("neg on non-number".to_string()) } @@ -1374,16 +1426,23 @@ impl LLVMCompiler { .get(rhs) .and_then(|b| b.as_any().downcast_ref::()) .ok_or_else(|| format!("binop rhs %{} not integer", rhs.0))?; - let res = match op { - BinaryOp::Add => l.value() + r.value(), - BinaryOp::Sub => l.value() - r.value(), - BinaryOp::Mul => l.value() * r.value(), - BinaryOp::Div => { - if r.value() == 0 { return Err("division by zero".into()); } - l.value() / r.value() - } - BinaryOp::Mod => l.value() % r.value(), - }; + let res = match op { + BinaryOp::Add => l.value + r.value, + BinaryOp::Sub => l.value - r.value, + BinaryOp::Mul => l.value * r.value, + BinaryOp::Div => { + if r.value == 0 { return Err("division by zero".into()); } + l.value / r.value + } + BinaryOp::Mod => l.value % r.value, + BinaryOp::BitAnd => l.value & r.value, + BinaryOp::BitOr => l.value | r.value, + BinaryOp::BitXor => l.value ^ r.value, + BinaryOp::Shl => l.value << r.value, + BinaryOp::Shr => l.value >> r.value, + BinaryOp::And => { if (l.value != 0) && (r.value != 0) { 1 } else { 0 } }, + BinaryOp::Or => { if (l.value != 0) || (r.value != 0) { 1 } else { 0 } }, + }; self.values.insert(*dst, Box::new(IntegerBox::new(res))); } I::Return { value } => { diff --git a/src/tests/llvm_bitops_test.rs b/src/tests/llvm_bitops_test.rs new file mode 100644 index 00000000..75f7af64 --- /dev/null +++ b/src/tests/llvm_bitops_test.rs @@ -0,0 +1,54 @@ +#[test] +fn llvm_bitops_compile_and_exec() { + use crate::mir::{MirModule, MirFunction, FunctionSignature, MirInstruction, BasicBlockId, ConstValue, MirType, instruction::BinaryOp}; + use crate::backend::vm::VM; + + // Build MIR: compute sum of bitwise/shift ops -> 48 + let sig = FunctionSignature { name: "Main.main".into(), params: vec![], return_type: MirType::Integer, effects: Default::default() }; + let mut f = MirFunction::new(sig, BasicBlockId::new(0)); + let bb = f.entry_block; + // Constants + let c5 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: c5, value: ConstValue::Integer(5) }); + let c3 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: c3, value: ConstValue::Integer(3) }); + let c2 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: c2, value: ConstValue::Integer(2) }); + let c1 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: c1, value: ConstValue::Integer(1) }); + let c32 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: c32, value: ConstValue::Integer(32) }); + let c5_sh = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: c5_sh, value: ConstValue::Integer(5) }); + let c3_sh = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: c3_sh, value: ConstValue::Integer(3) }); + + // a = 5 & 3 -> 1 + let a = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BinOp { dst: a, op: BinaryOp::BitAnd, lhs: c5, rhs: c3 }); + // b = 5 | 2 -> 7 + let b = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BinOp { dst: b, op: BinaryOp::BitOr, lhs: c5, rhs: c2 }); + // c = 5 ^ 1 -> 4 + let c = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BinOp { dst: c, op: BinaryOp::BitXor, lhs: c5, rhs: c1 }); + // d = 1 << 5 -> 32 + let d = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BinOp { dst: d, op: BinaryOp::Shl, lhs: c1, rhs: c5_sh }); + // e = 32 >> 3 -> 4 + let e = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BinOp { dst: e, op: BinaryOp::Shr, lhs: c32, rhs: c3_sh }); + + // sum = a + b + c + d + e + let t1 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BinOp { dst: t1, op: BinaryOp::Add, lhs: a, rhs: b }); + let t2 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BinOp { dst: t2, op: BinaryOp::Add, lhs: t1, rhs: c }); + let t3 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BinOp { dst: t3, op: BinaryOp::Add, lhs: t2, rhs: d }); + let sum = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BinOp { dst: sum, op: BinaryOp::Add, lhs: t3, rhs: e }); + f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Return { value: Some(sum) }); + + let mut m = MirModule::new("bitops".into()); m.add_function(f); + + // VM executes to 48 + let mut vm = VM::new(); + let out = vm.execute_module(&m).expect("vm exec"); + assert_eq!(out.to_string_box().value, "48"); + + // LLVM: ensure lowering/emit succeeds; compile_and_execute should also return 48 (via MIR interpreter fallback) + #[cfg(feature = "llvm")] + { + use crate::backend::llvm; + let tmp = format!("{}/target/aot_objects/test_bitops", env!("CARGO_MANIFEST_DIR")); + llvm::compile_to_object(&m, &format!("{}.o", tmp)).expect("llvm emit"); + let out2 = llvm::compile_and_execute(&m, &tmp).expect("llvm compile&exec"); + assert_eq!(out2.to_string_box().value, "48"); + } +} + diff --git a/tools/llvm_smoke.sh b/tools/llvm_smoke.sh index 874236ec..26619d05 100644 --- a/tools/llvm_smoke.sh +++ b/tools/llvm_smoke.sh @@ -17,6 +17,25 @@ if ! command -v llvm-config-18 >/dev/null 2>&1; then exit 2 fi +# --- AOT smoke: apps/ny-llvm-bitops (bitwise & shift operations) --- +if [[ "${NYASH_LLVM_BITOPS_SMOKE:-0}" == "1" ]]; then + echo "[llvm-smoke] building + linking apps/ny-llvm-bitops ..." >&2 + OBJ_BIT="$PWD/target/aot_objects/bitops_smoke.o" + rm -f "$OBJ_BIT" + NYASH_LLVM_ALLOW_BY_NAME=1 NYASH_LLVM_OBJ_OUT="$OBJ_BIT" LLVM_SYS_181_PREFIX="${_LLVMPREFIX}" LLVM_SYS_180_PREFIX="${_LLVMPREFIX}" "$BIN" --backend llvm apps/tests/ny-llvm-bitops/main.nyash >/dev/null || true + NYASH_LLVM_SKIP_EMIT=1 NYASH_LLVM_OBJ_OUT="$OBJ_BIT" ./tools/build_llvm.sh apps/tests/ny-llvm-bitops/main.nyash -o app_bitops_llvm >/dev/null || true + echo "[llvm-smoke] running app_bitops_llvm ..." >&2 + out_bit=$(./app_bitops_llvm || true) + echo "[llvm-smoke] output: $out_bit" >&2 + if ! echo "$out_bit" | grep -q "Result: 48"; then + echo "error: ny-llvm-bitops unexpected output: $out_bit" >&2 + exit 1 + fi + echo "[llvm-smoke] OK: bitwise/shift smoke passed" >&2 +else + echo "[llvm-smoke] skipping ny-llvm-bitops (set NYASH_LLVM_BITOPS_SMOKE=1 to enable)" >&2 +fi + echo "[llvm-smoke] building nyash (${MODE}, feature=llvm)..." >&2 # Support both llvm-sys 180/181 by exporting both prefixes to the same value _LLVMPREFIX=$(llvm-config-18 --prefix)