feat: add index out of bounds check

Author: Chronostasys

src/ast/builder/llvmbuilder.rs

@@ -1751,6 +1751,20 @@ impl<'a, 'ctx> IRBuilder<'a, 'ctx> for LLVMBuilder<'a, 'ctx> {
         let f = self.get_llvm_value(f).unwrap().into_function_value();
         f.get_name().to_str().unwrap() == "main"
     }
+
+    fn build_global_string_ptr(&self, s: &str, name: &str) -> ValueHandle {
+        let s = self.builder.build_global_string_ptr(s, name).unwrap();
+        self.get_llvm_value_handle(&s.as_any_value_enum())
+    }
+
+    fn build_unreachable(&self) {
+        _ = self.builder.build_unreachable();
+    }
+
+    fn is_debug(&self) -> bool {
+        self.debug
+    }
+
     fn tag_generator_ctx_as_root(&self, f: ValueHandle, ctx: &mut Ctx<'a>) {
         let f = self.get_llvm_value(f).unwrap().into_function_value();
         let allocab = f.get_first_basic_block().unwrap();
@@ -2371,7 +2385,7 @@ impl<'a, 'ctx> IRBuilder<'a, 'ctx> for LLVMBuilder<'a, 'ctx> {
         if *self.optimized.borrow() {
             return;
         }
-        if !self.debug {
+        if !self.debug && self.optlevel as u32 >= 1 {
             self.module.strip_debug_info();
         }
         self.module.verify().unwrap_or_else(|e| {

src/ast/builder/mod.rs

@@ -39,6 +39,7 @@ pub trait IRBuilder<'a, 'ctx> {
     fn get_global_var_handle(&self, name: &str) -> Option<ValueHandle>;
     fn new_subscope(&self, start: Pos);
     fn get_sp_handle(&self) -> ValueHandle;
+    fn is_debug(&self) -> bool;
     fn add_global(
         &self,
         name: &str,
@@ -329,6 +330,8 @@ pub trait IRBuilder<'a, 'ctx> {
     fn is_main(&self, f: ValueHandle) -> bool;
     fn await_task(&self, ctx: &mut Ctx<'a>, task: ValueHandle) -> ValueHandle;
     fn await_ret(&self, ctx: &mut Ctx<'a>, ret: ValueHandle);
+    fn build_global_string_ptr(&self, s: &str, name: &str) -> ValueHandle;
+    fn build_unreachable(&self);
 }
 
 /// ValueHandle is an index used to separate the low level generatted code inside [BuilderEnum] from the respective high level ast node

src/ast/builder/no_op_builder.rs

@@ -631,4 +631,16 @@ impl<'a, 'ctx> IRBuilder<'a, 'ctx> for NoOpBuilder<'a, 'ctx> {
         0
     }
     fn await_ret(&self, _ctx: &mut Ctx<'a>, _ret: ValueHandle) {}
+
+    fn is_debug(&self) -> bool {
+        false
+    }
+
+    fn build_global_string_ptr(&self, _s: &str, _name: &str) -> ValueHandle {
+        0
+    }
+
+    fn build_unreachable(&self) {
+        // 什么都不做
+    }
 }

src/ast/node/primary.rs

@@ -1,10 +1,12 @@
+use std::cell::RefCell;
 use std::sync::Arc;
 
 use super::node_result::NodeResultBuilder;
 use super::*;
 
 use crate::ast::builder::BuilderEnum;
 use crate::ast::builder::IRBuilder;
+use crate::ast::builder::IntPredicate;
 use crate::ast::builder::ValueHandle;
 use crate::ast::ctx::Ctx;
 use crate::ast::ctx::MacroReplaceNode;
@@ -366,6 +368,69 @@ impl Node for ArrayElementNode {
 
             let elemptr: ValueHandle = {
                 let index: &[ValueHandle; 1] = &[index_val];
+
+                // 在debug模式下添加越界检查
+                if ctx.config.assert_index_out_of_bounds {
+                    // 获取数组大小
+                    let size_ptr = builder
+                        .build_struct_gep(arr, 2, "size_ptr", &pltype.borrow(), ctx)
+                        .unwrap();
+                    let size = builder.build_load(
+                        size_ptr,
+                        "arr_size",
+                        &PLType::Primitive(PriType::I64),
+                        ctx,
+                    );
+
+                    // 创建比较：index >= size 或 index < 0
+                    let cmp_ge = builder.build_int_compare(
+                        IntPredicate::SGE,
+                        index_val,
+                        size,
+                        "index_ge_size",
+                    );
+                    let cmp_lt = builder.build_int_compare(
+                        IntPredicate::SLT,
+                        index_val,
+                        builder.int_value(&PriType::I64, 0, true),
+                        "index_lt_zero",
+                    );
+                    let out_of_bounds = builder.build_or(cmp_ge, cmp_lt, "out_of_bounds");
+
+                    // 获取当前函数
+                    let current_func = ctx.function.unwrap();
+                    let error_block = builder.append_basic_block(current_func, "arr_index_error");
+                    let continue_block =
+                        builder.append_basic_block(current_func, "arr_index_continue");
+
+                    builder.build_conditional_branch(out_of_bounds, error_block, continue_block);
+
+                    // 错误处理块
+                    builder.position_at_end_block(error_block);
+
+                    // 获取printf函数
+                    let printf_fn = builder
+                        .get_function("pl_index_out_of_bounds")
+                        .unwrap_or_else(|| {
+                            let ret_type = PLType::Void;
+                            let param_type = PLType::Primitive(PriType::I64);
+                            builder.add_function(
+                                "pl_index_out_of_bounds",
+                                &[param_type.clone(), param_type],
+                                ret_type,
+                                ctx,
+                            )
+                        });
+
+                    // 调用printf输出错误信息
+                    builder.build_call(printf_fn, &[index_val, size], &PLType::Void, ctx, None);
+
+                    builder.build_unreachable();
+
+                    // 继续执行块
+                    builder.position_at_end_block(continue_block);
+                }
+
                 let real_arr: ValueHandle = builder
                     .build_struct_gep(arr, 1, "real_arr", &pltype.borrow(), ctx)
                     .unwrap();

src/ast/test.rs

@@ -653,6 +653,58 @@ fn test_tail_call_opt() {
     drop(l);
 }
 
+#[test]
+fn test_assert_index_out_of_bounds() {
+    let l = crate::utils::plc_new::tests::TEST_COMPILE_MUTEX
+        .lock()
+        .unwrap();
+    set_test_asset();
+    let out = "testout3";
+    let exe = PathBuf::from(out);
+    #[cfg(target_os = "windows")]
+    let exe = exe.with_extension("exe");
+    _ = remove_file(&exe);
+    use std::{path::PathBuf, process::Command};
+
+    use crate::ast::compiler::{compile, Options};
+
+    let docs = MemDocs::default();
+    let db = Database::default();
+    let input = MemDocsInput::new(
+        &db,
+        Arc::new(Mutex::new(docs)),
+        "test/arr_bounds/main.pi".to_string(),
+        Default::default(),
+        ActionType::Compile,
+        None,
+        None,
+    );
+    compile(
+        &db,
+        input,
+        out.to_string(),
+        Options {
+            optimization: crate::ast::compiler::HashOptimizationLevel::Less,
+            genir: true,
+            printast: false,
+            flow: false,
+            fmt: false,
+            jit: false,
+            debug: false,
+            ..Default::default()
+        },
+    );
+    let exe = crate::utils::canonicalize(&exe)
+        .unwrap_or_else(|_| panic!("static compiled file not found {:?}", exe));
+    eprintln!("exec: {:?}", exe);
+    let o = Command::new(exe.to_str().unwrap())
+        .output()
+        .expect("failed to execute compiled program");
+    // should trigger index out of bounds, so status should be non-zero
+    assert!(!o.status.success(), "should trigger index out of bounds");
+    drop(l);
+}
+
 #[cfg(test)]
 pub(crate) fn set_test_asset() {
     use std::time::SystemTime;

src/utils/read_config.rs

@@ -84,6 +84,10 @@ pub struct Config {
     /// and it's decided by the position of kagari.toml file
     #[serde(skip)]
     pub root: String,
+
+    /// Assert Index Out Of Bounds, default is false
+    #[serde(default)]
+    pub assert_index_out_of_bounds: bool,
 }
 
 /// ConfigWrapper wraps a config, which represents all configuration of an entry node of a program.

test/Kagari.toml

@@ -1,6 +1,7 @@
 project = "project1"
 entry = "main.pi"
 
+assert_index_out_of_bounds = true
 
 [deps]
 project2 = { path = "project2" }

test/arr_bounds/Kagari.toml

@@ -0,0 +1,4 @@
+entry = "main.pi"
+project = "arr_bounds"
+
+assert_index_out_of_bounds = true

test/arr_bounds/main.pi

@@ -0,0 +1,5 @@
+fn main() i64 {
+    let a = [1];
+    let d = a[1];
+    return 0;
+}

vm/src/lib.rs

@@ -41,6 +41,17 @@ fn pl_panic() {
     exit(1);
 }
 
+#[is_runtime]
+fn pl_index_out_of_bounds(index: i64, len: i64) {
+    println!(
+        "index out of bounds occured! index: {}, len: {}",
+        index, len
+    );
+    let bt = Backtrace::new();
+    println!("{:?}", bt);
+    exit(1);
+}
+
 #[is_runtime]
 fn __cast_panic() {
     println!("invalid cast occured!");