feat: add more compile options & fix safe cast

1. add asm compile target
2. add ability to compile ir file
3. fix a wrong load type in safe cast
4. better test file structure

Author: Chronostasys

immix/src/llvm_stackmap/mod.rs

@@ -278,6 +278,8 @@ extern "C" {
     pub fn CreateGlobalOrcJITEngine() -> std::ffi::c_void;
     pub fn AddModuleToOrcJIT(module: *mut u8) -> std::ffi::c_void;
     pub fn RunExpr(module: *mut u8) -> std::ffi::c_void;
+
+    pub fn parse_ir(ir: *const std::ffi::c_char) -> *mut u8;
     /// # run_module_pass
     ///
     /// run the module pass

planglib/std/cols/hashtable.pi

@@ -31,7 +31,7 @@ impl <K:Hash+Eq<K>|V> HashTable<K|V>  {
         if self.entries as f64 / arr_len(self.buckets) as f64 > 0.5 {
             let new_size = arr_len(self.buckets) * 2;
             let new_table = new_hash_table<K|V>(new_size as u64, self.salt +1);
-            let iterator = self.into_inter();
+            let iterator = self.into_iter();
             for let i = iterator.next(); !i is None; i = iterator.next() {
                 let (key, value) = i as (K,V)!;
                 new_table.insert(key, value);
@@ -42,7 +42,7 @@ impl <K:Hash+Eq<K>|V> HashTable<K|V>  {
         }
         return;
     }
-    gen pub fn into_inter() Iterator<(K,V)> {
+    gen pub fn into_iter() Iterator<(K,V)> {
         for let i = 0; i < arr_len(self.buckets); i = i + 1 {
             let node = self.buckets[i];
             while node is *TableNode<K|V> {
@@ -143,7 +143,7 @@ pub use core::string::ToString;
 impl <K:ToString+Hash+Eq<K>|V:ToString> ToString for HashTable<K|V> {
     fn to_string() string {
         let ret = "HashTable{";
-        let iterator = self.into_inter();
+        let iterator = self.into_iter();
         for let i = iterator.next(); !i is None; {
             let (key, value) = i as (K,V)!;
             ret.append(key.to_string());

planglib/std/time.pi

@@ -116,12 +116,26 @@ impl Duration {
         return self.t.sec as i128 * 1_000_000_000 + self.t.nano as i128;
     }
 
+    /// # sub_sec_nanos
+    ///
+    /// get the number of nanoseconds that have elapsed since the last second
+    pub fn sub_sec_nanos() u32 {
+        return self.t.nano;
+    }
+
     /// # sub
     ///
     /// subtract a duration from another duration
     pub fn sub(d:Duration) Duration {
         let sec = self.t.sec - d.t.sec;
-        let nano = self.t.nano - d.t.nano;
+        // check if we need to borrow from the seconds
+        let nano;
+        if self.t.nano < d.t.nano {
+            sec = sec - 1;
+            nano = self.t.nano + NANO_PER_SEC as u32 - d.t.nano;
+        } else {
+            nano = self.t.nano - d.t.nano;
+        };
         return Duration{
             t:Timespec{
                 sec: sec,

src/ast/compiler.rs

@@ -58,6 +58,35 @@ pub fn compile(db: &dyn Db, docs: MemDocsInput, out: String, op: Options) {
     immix::register_llvm_gc_plugins();
     ensure_target_folder();
 
+    let p = PathBuf::from(docs.file(db).to_string());
+    if p.extension().unwrap_or_default() == "bc" || p.extension().unwrap_or_default() == "ll" {
+        if !p.exists() {
+            eprintln!("{} file not found", p.to_str().unwrap().red());
+            exit(1)
+        }
+        let ctx = Context::create();
+        let tm = crate::ast::builder::llvmbuilder::get_target_machine(op.optimization.to_llvm());
+        let obj_f = &format!("{}/{}", &ASSET_PATH.lock().unwrap(), "out.o");
+        let module = if p.extension().unwrap_or_default() == "bc" {
+            Module::parse_bitcode_from_path(p, &ctx).unwrap()
+        } else {
+            let c_str = std::ffi::CString::new(p.to_str().unwrap()).unwrap();
+            let mem = unsafe { immix::parse_ir(c_str.as_ptr()) };
+            Module::parse_bitcode_from_buffer(
+                unsafe { &inkwell::memory_buffer::MemoryBuffer::new(mem as _) },
+                &ctx,
+            )
+            .unwrap()
+        };
+        tm.write_to_file(
+            &module,
+            inkwell::targets::FileType::Object,
+            Path::new(obj_f),
+        )
+        .unwrap();
+        pl_link(module, vec![obj_f.into()], out.clone(), op);
+        return;
+    }
     let total_steps = 3;
     let pb = &COMPILE_PROGRESS;
     prepare_prgressbar(
@@ -247,6 +276,16 @@ pub fn process_llvm_ir<'a>(
         output_files.push(obj_f.into());
     }
     pb.finish_with_message("中间代码优化完成");
+    let asm_path = format!("{}/{}", &ASSET_PATH.lock().unwrap(), "out.asm");
+    if op.asm {
+        tm.write_to_file(
+            &llvmmod,
+            inkwell::targets::FileType::Assembly,
+            Path::new(&asm_path),
+        )
+        .unwrap();
+        eprintln!("asm file written to: {}", &asm_path);
+    }
     (llvmmod, output_files)
 }
 

src/ast/compiler/options.rs

@@ -4,6 +4,7 @@ use inkwell::OptimizationLevel;
 /// Options preserves additional args to do additional works during parsing AST
 #[derive(Debug, Clone, Default, PartialEq, Eq, Hash, Copy)]
 pub struct Options {
+    pub asm: bool,
     pub genir: bool,
     /// printast will print out the generated AST and ends up the further processes.
     pub printast: bool,

src/ast/node/cast.rs

@@ -309,7 +309,7 @@ impl<'a, 'ctx> Ctx<'a> {
         let data = builder
             .build_struct_gep(val, 1, "data", ori_ty, self)
             .unwrap();
-        let data = builder.build_load(data, "data", &target_ty.borrow(), self);
+        let data = builder.build_load(data, "data", &PLType::new_u8_ptr(), self);
         builder.build_store(result_data_field, data);
         builder.build_store(result_tag_field, builder.int_value(&PriType::U64, 0, false));
         builder.build_unconditional_branch(after_block);

src/ast/test.rs

@@ -414,6 +414,7 @@ fn test_doc_symbol() {
 
 #[test]
 #[cfg(feature = "jit")]
+#[cfg(not(windows))] // FIXME: windows i128 issue https://discourse.llvm.org/c/beginners/17
 fn test_orc_jit() {
     use crate::ast::compiler::{compile, Options};
     use std::path::PathBuf;

src/main.rs

@@ -156,6 +156,10 @@ struct Cli {
     #[arg(long)]
     genir: bool,
 
+    /// generate
+    #[arg(long, short = 'S')]
+    asm: bool,
+
     /// jit compile
     #[arg(long)]
     jit: bool,
@@ -188,6 +192,7 @@ impl Cli {
             .unwrap();
 
         let op = compiler::Options {
+            asm: self.asm,
             genir: self.genir,
             printast: self.printast,
             flow: self.flow,
@@ -221,13 +226,16 @@ impl Cli {
     // todo(griffin): make the input name more generic
     // currently it support file path input only,
     pub fn build(&mut self, name: String) {
-        self.check(name.clone());
+        if !(name.ends_with(".bc") || name.ends_with(".ll")) {
+            self.check(name.clone());
+        }
 
         let db = Database::default();
         let filepath = Path::new(&name);
         let abs = crate::utils::canonicalize(filepath).unwrap();
 
         let op = compiler::Options {
+            asm: self.asm,
             genir: self.genir,
             printast: self.printast,
             flow: self.flow,
@@ -299,6 +307,7 @@ impl Cli {
         let abs = crate::utils::canonicalize(filepath).unwrap();
 
         let op = compiler::Options {
+            asm: self.asm,
             genir: self.genir,
             printast: self.printast,
             flow: self.flow,

src/repl/mod.rs

@@ -54,6 +54,7 @@ pub fn start_repl() {
     let mut db2 = Database::default();
 
     let op = compiler::Options {
+        asm: false,
         genir: false,
         printast: false,
         flow: false,

test/main.pi

@@ -1,49 +1,73 @@
-use std::cols::hashtable::*;
-use std::cols::arr::*;
-
 use project1::test::_match;
-
-use std::time;
-
+use project1::test::time;
+use project1::test::print;
+use project1::test::ifel;
+use project1::test::generic;
+use project1::test::st;
+use project1::test::method;
+use project1::test::global;
+use project1::test::traits;
+use project1::test::simple;
+use project1::test::flow;
+use project1::test::compiletime_reflection::test_compile_time_reflection;
+use project1::test::list;
+use project1::test::module;
+use project1::test::str;
+use project1::test::macros;
+use project1::test::union;
+use project1::test::multi_trait;
+use project1::test::tuple;
+use project1::test::fntype;
+use project1::test::closure;
+use project1::test::map;
+use project1::test::tree;
+use project1::test::fixed_point;
+use project1::test::sort_test;
+use project1::tmod2;
+// use pl_test::main;
+use project1::test::deconstruct;
+use project1::test::st::*;
+use project1::test::arr;
+use project1::test::iter;
+use project1::test::inference;
+use project1::test::rand;
+use project1::test::_hashtable;
+use project1::test::_io;
+// use std::cols::hashtable::new_hash_table;
 
 pub fn main() i64 {
-    let t = time::now();
-    let a = 0.0;
-    println!(a);
-    let m = "🌏Hello, 世界!";
-    println!(m);
-    let cs = m.chars();
-    println!(cs);
-    let h = new_hash_table<i64|i64>(10 as u64, 1 as u64);
-    h.insert(1, 2);
-    h.insert(2, 3);
-    println!(-0);
-    println!(456 as i32);
-    println!(-789 as i16);
-    println!(12 as i8);
-    println!(123);
-    println!(456 as u32);
-    println!(789 as u16);
-    println!(12 as u8);
-    println!(123.456);
-    println!(-789.012);
-    println!(1.0/3.0);
-    println!(-0.123 as f32); // TODO: impl a better way to cast f32 (like f64)
-    println!(-10.0);
-    println!([1, 2, 3, 4]);
-    println!(from_slice([1, 2, 3, 4]));
-    println!(h);
-    println!(1,2,3);
-    println!(123);
-    let b = '😀';
-    println!(b);
-    _match::test_match();
-    let aa = 0;
-    for let i = 0; i < 100; i = i + 1 {
-        aa = aa + i;
-    }
-    let ep = t.elapsed();
-    println!(ep);
-    println!(0.000093999999999999994);
+
+    macros::test_macros();
+    ifel::test_if_else();
+    generic::test_generic();
+    method::test_impl();
+    test_struct();
+    global::test_global();
+    traits::test_trait();
+    simple::test_simple();
+    flow::test_flow();
+    list::test_list();
+    // main::simple_test();
+    module::test_module();
+    str::test_string();
+    union::test_union();
+    multi_trait::test_multi_trait();
+    deconstruct::test_deconstruct();
+    tuple::test_tuple();
+    fntype::test_fntype()();
+    closure::test_closure();
+    tree::test_eva();
+    map::test_map();
+    fixed_point::test_fixed_point();
+    generic::ret_generic1<i64>();
+    test_compile_time_reflection();
+    iter::test_generator();
+    inference::test_inference();
+    rand::test_rand();
+    sort_test::test_sort();
+    arr::test_arr();
+    _hashtable::test_hashtable();
+    _io::test_io();
+    
     return 0;
-}
+}