Fixed the runtime config and added some new debugging tools.

Author: FractalFir

cilly/src/bin/asmedit.rs

@@ -2,6 +2,7 @@ use std::{
     collections::VecDeque,
     io::{stdin, Read},
     num::NonZeroU32,
+    panic::catch_unwind,
     time::Instant,
 };
 
@@ -234,49 +235,82 @@ fn main() {
             "" => continue,
             "misolate" => {
                 let isolate_id = parse_id(body, &asm);
-                let externs: Vec<_> = asm
-                    .methods_with(|_, _, def| *def.access() == Access::Extern)
-                    .map(|(id, _)| id)
-                    .copied()
-                    .collect();
-                for extern_id in externs {
-                    asm.modify_methodef(|_, method| method.set_access(Access::Public), extern_id);
-                }
                 let Some(isolate_id) = asm.method_ref_to_def(isolate_id) else {
                     eprintln!("Invalid method!");
                     continue;
                 };
-                let main_module = asm.main_module();
-                let entrypoint = asm.alloc_string("entrypoint");
-                let sig = asm.sig([], cilly::Type::Void);
-                let fn_ptr = asm.alloc_node(CILNode::LdFtn(*isolate_id));
-                let roots = [
-                    asm.alloc_root(CILRoot::Pop(fn_ptr)),
-                    asm.alloc_root(CILRoot::VoidRet),
-                ];
-                let implementation = MethodImpl::MethodBody {
-                    blocks: vec![BasicBlock::new(roots.into(), 0, None)],
-                    locals: vec![],
-                };
-                let entrypoint = MethodDef::new(
-                    Access::Extern,
-                    main_module,
-                    entrypoint,
-                    sig,
-                    cilly::cilnode::MethodKind::Static,
-                    implementation,
-                    vec![],
-                );
-                asm.new_method(entrypoint);
-                asm.eliminate_dead_code();
-                // GC
-                asm = asm.clone().link(Assembly::default());
-                asm.remove_dead_statics();
+                misolate(&mut asm, *isolate_id)
             }
+            "find_invalid_c" => find_invalid_c(&asm),
+            "asmstats" => println!(
+                "methoddefs:{}",
+                asm.method_refs()
+                    .iter_keys()
+                    .filter_map(|key| asm.method_ref_to_def(key))
+                    .count()
+            ),
             _ => eprintln!("unknown command {cmd:?}"),
         }
     }
 }
+fn find_invalid_c(asm: &Assembly) {
+    let mut fail_id = 0;
+    for key in asm
+        .method_refs()
+        .iter_keys()
+        .filter_map(|key| asm.method_ref_to_def(key))
+    {
+        let mut copy = asm.clone();
+        misolate(&mut copy, *key);
+        if !is_valid_c(&copy, fail_id) {
+            fail_id += 1;
+            eprintln!("Invalid c code methodid {key:?} fail_id:{fail_id}")
+        } else {
+            eprintln!("Method ok.")
+        }
+    }
+    println!("Found {} faliures, saved to tmp", fail_id)
+}
+fn is_valid_c(asm: &Assembly, id: u32) -> bool {
+    catch_unwind(|| asm.export(format!("/tmp/test{id}.out"), CExporter::new(false))).is_ok()
+}
+fn misolate(asm: &mut Assembly, isolate_id: MethodRefIdx) {
+    let externs: Vec<_> = asm
+        .methods_with(|_, _, def| *def.access() == Access::Extern)
+        .map(|(id, _)| id)
+        .copied()
+        .collect();
+    for extern_id in externs {
+        asm.modify_methodef(|_, method| method.set_access(Access::Public), extern_id);
+    }
+
+    let main_module = asm.main_module();
+    let entrypoint = asm.alloc_string("entrypoint");
+    let sig = asm.sig([], cilly::Type::Void);
+    let fn_ptr = asm.alloc_node(CILNode::LdFtn(isolate_id));
+    let roots = [
+        asm.alloc_root(CILRoot::Pop(fn_ptr)),
+        asm.alloc_root(CILRoot::VoidRet),
+    ];
+    let implementation = MethodImpl::MethodBody {
+        blocks: vec![BasicBlock::new(roots.into(), 0, None)],
+        locals: vec![],
+    };
+    let entrypoint = MethodDef::new(
+        Access::Extern,
+        main_module,
+        entrypoint,
+        sig,
+        cilly::cilnode::MethodKind::Static,
+        implementation,
+        vec![],
+    );
+    asm.new_method(entrypoint);
+    asm.eliminate_dead_code();
+    // GC
+    *asm = asm.clone().link(Assembly::default());
+    asm.remove_dead_statics();
+}
 fn parse_id(id: &str, asm: &Assembly) -> MethodRefIdx {
     if let Ok(id) = id.parse::<u32>() {
         unsafe { MethodRefIdx::from_raw(NonZeroU32::new(id).unwrap()) }

cilly/src/bin/linker/dotnet_jumpstart.rs

@@ -1,8 +1,8 @@
 use std::io::Write;
-static DOTNET_ASSEMBLY:&[u8] = include_bytes!("{exec_file}");
-static RUNTIME_COFIG:&[u8] = b"{{
+static DOTNET_ASSEMBLY: &[u8] = include_bytes!("{exec_file}");
+static RUNTIME_COFIG: &[u8] = b"{{
     \"runtimeOptions\": {{
-      \"tfm\": \"netcoreapp3.1\",
+      \"tfm\": \"net8.0\",
       \"framework\": {{
         \"name\": \"Microsoft.NETCore.App\",
         \"version\": \"8.0.1\"
@@ -13,55 +13,84 @@ static RUNTIME_COFIG:&[u8] = b"{{
       }}
     }}
 }}";
-macro_rules! include_bytes_if{{
-  (true,$path:literal)=>{{
-      include_bytes!($path)
-  }};
-  (false,$path:literal)=>{{b""}};
-}}
-
-static BUNDLED_SHARED_LIB:&[u8] = include_bytes_if!({has_native_companion},"{native_companion_file}");
-static BUNDLED_PDB:&[u8] = include_bytes_if!({has_pdb},"{pdb_file}");
-fn main(){{
-    let curr_path = std::env::current_exe().unwrap();
-    let dll_path = curr_path.with_extension("dll");
-    let config = curr_path.with_extension("runtimeconfig.json");
-    let pdb_file = curr_path.with_file_name("{pdb_file}");
-    let mut requires_refresh = false;
-    if dll_path.exists() {{
-    	let ondisk_len = std::fs::File::open(dll_path.clone()).expect("Could not create a file to unpack the .NET assembly").metadata().unwrap().len();
-    	// If the length on disk is != expected, write the new file TODO: this can very rarely not detect if an update is needed. Check assembly GUID too, to ensure recompilation works.
-    	if ondisk_len != DOTNET_ASSEMBLY.len() as u64{{
-    		requires_refresh = true;
-    	}}
-    }}
-    if !dll_path.exists() || requires_refresh {{
-        let mut file = std::fs::File::create(dll_path.clone()).expect("Could not create a file to unpack the .NET assembly");
-        file.write_all(DOTNET_ASSEMBLY).expect("Could not unpack the .NET assembly");
-    }}
-    if !config.exists() ||requires_refresh {{
-        let mut file = std::fs::File::create(config).expect("Could not create a file to save .NET runtime settings.");
-        file.write_all(RUNTIME_COFIG).expect("Could not save .NET runtime settings");
-    }}
-    if {has_native_companion} {{
-      if !std::path::Path::new("{native_companion_file}").exists() || requires_refresh{{
-          let mut file = std::fs::File::create("{native_companion_file}").expect("Could not create a file to provide the native companion.");
-          file.write_all(BUNDLED_SHARED_LIB).expect("Could create a file to provide the native companion");
-      }}
-  
-    }}
-    if {has_pdb}{{
-      if !pdb_file.exists() || requires_refresh{{
-          println!("creating the pdb file");
-          let mut file = std::fs::File::create(pdb_file).expect("Could not create a file to provide the pdb debug info.");
-          file.write_all(BUNDLED_PDB).expect("Could create a file to provide the pdb debug info.");
-      }}
-      else{{
-          println!("Not creating the pdb file");
-      }}
-    }}
-    let args:Vec<String> = std::env::args().collect();
-    let args = &args[1..];
-    std::process::Command::new("{jumpstart_cmd}").arg(dll_path).args(args).status().expect("Could not start the .NET runtime.");
-}}
+macro_rules! include_bytes_if {}
 
+static BUNDLED_SHARED_LIB: &[u8] =
+    include_bytes_if!({ has_native_companion }, "{native_companion_file}");
+static BUNDLED_PDB: &[u8] = include_bytes_if!({ has_pdb }, "{pdb_file}");
+fn main() {
+    {
+        let curr_path = std::env::current_exe().unwrap();
+        let dll_path = curr_path.with_extension("dll");
+        let config = curr_path.with_extension("runtimeconfig.json");
+        let pdb_file = curr_path.with_file_name("{pdb_file}");
+        let mut requires_refresh = false;
+        if dll_path.exists() {
+            {
+                let ondisk_len = std::fs::File::open(dll_path.clone())
+                    .expect("Could not create a file to unpack the .NET assembly")
+                    .metadata()
+                    .unwrap()
+                    .len();
+                // If the length on disk is != expected, write the new file TODO: this can very rarely not detect if an update is needed. Check assembly GUID too, to ensure recompilation works.
+                if ondisk_len != DOTNET_ASSEMBLY.len() as u64 {
+                    {
+                        requires_refresh = true;
+                    }
+                }
+            }
+        }
+        if !dll_path.exists() || requires_refresh {
+            {
+                let mut file = std::fs::File::create(dll_path.clone())
+                    .expect("Could not create a file to unpack the .NET assembly");
+                file.write_all(DOTNET_ASSEMBLY)
+                    .expect("Could not unpack the .NET assembly");
+            }
+        }
+        if !config.exists() || requires_refresh {
+            {
+                let mut file = std::fs::File::create(config)
+                    .expect("Could not create a file to save .NET runtime settings.");
+                file.write_all(RUNTIME_COFIG)
+                    .expect("Could not save .NET runtime settings");
+            }
+        }
+        if { has_native_companion } {
+            {
+                if !std::path::Path::new("{native_companion_file}").exists() || requires_refresh {
+                    {
+                        let mut file = std::fs::File::create("{native_companion_file}")
+                            .expect("Could not create a file to provide the native companion.");
+                        file.write_all(BUNDLED_SHARED_LIB)
+                            .expect("Could create a file to provide the native companion");
+                    }
+                }
+            }
+        }
+        if { has_pdb } {
+            {
+                if !pdb_file.exists() || requires_refresh {
+                    {
+                        println!("creating the pdb file");
+                        let mut file = std::fs::File::create(pdb_file)
+                            .expect("Could not create a file to provide the pdb debug info.");
+                        file.write_all(BUNDLED_PDB)
+                            .expect("Could create a file to provide the pdb debug info.");
+                    }
+                } else {
+                    {
+                        println!("Not creating the pdb file");
+                    }
+                }
+            }
+        }
+        let args: Vec<String> = std::env::args().collect();
+        let args = &args[1..];
+        std::process::Command::new("{jumpstart_cmd}")
+            .arg(dll_path)
+            .args(args)
+            .status()
+            .expect("Could not start the .NET runtime.");
+    }
+}

cilly/src/v2/asm.rs

@@ -510,19 +510,25 @@ impl Assembly {
             self.new_method(cctor_def)
         }
     }
-    /// Returns a reference to the static initializer
-    pub fn cctor(&mut self) -> MethodDefIdx {
+    fn cctor_mref(&mut self) -> MethodRefIdx {
         let main_module = self.main_module();
         let user_init = self.alloc_string(CCTOR);
         let ctor_sig = self.sig([], Type::Void);
-        let mref = MethodRef::new(
+        self.alloc_methodref(MethodRef::new(
             *main_module,
             user_init,
             ctor_sig,
             MethodKind::Static,
             vec![].into(),
-        );
-        let mref = self.alloc_methodref(mref);
+        ))
+    }
+    pub fn has_cctor(&mut self) -> bool {
+        let cctor = self.cctor_mref();
+        self.method_ref_to_def(cctor).is_some()
+    }
+    /// Returns a reference to the static initializer
+    pub fn cctor(&mut self) -> MethodDefIdx {
+        let mref = self.cctor_mref();
         if self.method_defs.contains_key(&MethodDefIdx(mref)) {
             MethodDefIdx(mref)
         } else {
@@ -534,6 +540,9 @@ impl Assembly {
                 )],
                 locals: vec![],
             };
+            let main_module = self.main_module();
+            let user_init = self.alloc_string(CCTOR);
+            let ctor_sig = self.sig([], Type::Void);
             let cctor_def = MethodDef::new(
                 Access::Extern,
                 main_module,
@@ -1013,6 +1022,10 @@ impl Assembly {
             },
         }
     }
+
+    pub fn method_refs(&self) -> &BiMap<MethodRefIdx, MethodRef> {
+        &self.method_refs
+    }
 }
 /// An initializer, which runs before everything else. By convention, it is used to initialize static / const data. Should not execute any user code
 pub const CCTOR: &str = ".cctor";
@@ -1024,7 +1037,11 @@ pub const USER_INIT: &str = "static_init";
 pub const ENTRYPOINT: &str = "entrypoint";
 /// Main class of this module
 pub const MAIN_MODULE: &str = "MainModule";
-
+#[test]
+fn test_encoded_stats() {
+    assert_eq!(encoded_stats(&u64::MAX), (type_name::<u64>(), 10));
+    assert_eq!(encoded_stats(&0_i32), (type_name::<i32>(), 1));
+}
 fn encoded_stats<T: Serialize + for<'a> Deserialize<'a>>(val: &T) -> (&'static str, usize) {
     let buff = postcard::to_allocvec(val).unwrap();
     let start = std::time::Instant::now();

cilly/src/v2/basic_block.rs

@@ -110,7 +110,22 @@ impl BasicBlock {
             &mut self.roots,
         )
     }
-    /// Checks if this basic block consists of nothing more than an unconditional jump to another block
+    /// Checks if this basic block consists of nothing more than an unconditional jump to another block.
+    /// ```
+    /// # use cilly::*;
+    /// # use cilly::v2::BasicBlock;
+    /// # let mut asm = Assembly::default();
+    /// # let mut void_ret = asm.alloc_root(CILRoot::VoidRet);
+    /// # let mut rethrow = asm.alloc_root(CILRoot::ReThrow);
+    /// # let mut val = asm.alloc_node(0);
+    /// # let mut do_sth = asm.alloc_root(CILRoot::StLoc(0,val));
+    /// let target = 11;
+    /// let mut jump = asm.alloc_root(CILRoot::Branch(Box::new((target,0,None))));
+    /// assert_eq!(BasicBlock::new(vec![],0,None).is_direct_jump(&asm),None);
+    /// assert_eq!(BasicBlock::new(vec![void_ret],0,None).is_direct_jump(&asm),None);
+    /// assert_eq!(BasicBlock::new(vec![jump],0,None).is_direct_jump(&asm),Some((target,0)));
+    /// assert_eq!(BasicBlock::new(vec![do_sth,jump],0,None).is_direct_jump(&asm),None);
+    /// ```
     #[must_use]
     pub fn is_direct_jump(&self, asm: &Assembly) -> Option<(BlockId, BlockId)> {
         let mut meningfull_root = self.meaningfull_roots(asm);
@@ -125,6 +140,19 @@ impl BasicBlock {
         }
     }
     /// Checks if this basic block consists of nothing more thaan an uncondtional rethrow
+    /// ```
+    /// # use cilly::*;
+    /// # use cilly::v2::BasicBlock;
+    /// # let mut asm = Assembly::default();
+    /// # let mut void_ret = asm.alloc_root(CILRoot::VoidRet);
+    /// # let mut rethrow = asm.alloc_root(CILRoot::ReThrow);
+    /// # let mut val = asm.alloc_node(0);
+    /// # let mut do_sth = asm.alloc_root(CILRoot::StLoc(0,val));
+    /// assert!(!BasicBlock::new(vec![],0,None).is_only_rethrow(&asm));
+    /// assert!(!BasicBlock::new(vec![void_ret],0,None).is_only_rethrow(&asm));
+    /// assert!(BasicBlock::new(vec![rethrow],0,None).is_only_rethrow(&asm));
+    /// assert!(!BasicBlock::new(vec![do_sth,rethrow],0,None).is_only_rethrow(&asm));
+    /// ```
     #[must_use]
     pub fn is_only_rethrow(&self, asm: &Assembly) -> bool {
         let mut meningfull_root = self.meaningfull_roots(asm);

cilly/src/v2/bimap.rs

@@ -62,6 +62,9 @@ impl<Key: IntoBiMapIndex + Eq + Hash + Clone + Debug, Value: Eq + Hash + Clone +
     pub fn contais_val(&self, def: Value) -> bool {
         self.1.contains_key(&def)
     }
+    pub fn iter_keys(&self) -> impl Iterator<Item = Key> {
+        (1..(self.0.len() as u32)).map(|key| Key::from_index(NonZeroU32::new(key).unwrap()))
+    }
 }
 pub type BiMapIndex = NonZeroU32;
 pub trait IntoBiMapIndex {