Refactors

Author: FractalFir

Cargo.toml

@@ -31,7 +31,7 @@ crate-type = ["dylib"]
 members = [ "cilly", "dotnet_aot",
     "mycorrhiza", "rustc_codegen_clr_call", "rustc_codegen_clr_ctx", "rustc_codegen_clr_place", "rustc_codegen_clr_type", "rustc_codgen_clr_operand", 
 ]
-exclude = ["rust/src/bootstrap","backup_rust/src/bootstrap"]
+exclude = ["rust/src/bootstrap","backup_rust/src/bootstrap", "bin"]
 [profile.release]
 debug = true
 

cilly/Cargo.toml

@@ -11,11 +11,8 @@ serde = { version = "1.0.183", features = ["derive","rc"] }
 postcard = { version = "1.0.6", features = ["use-std"] }
 ar = "0.9.0"
 fxhash = "0.2.1"
+rustc-demangle = "0.1.24"
 [[bin]]
 name = "linker"
 test = false
 bench = false
-[[bin]]
-name = "interpreter"
-test = false
-bench = false

cilly/src/access_modifier.rs

@@ -8,13 +8,13 @@ use std::{
 
 use cilly::{
     c_exporter::CExporter,
-    v2::{
+    BasicBlock, CILNode, CILRoot, MethodDef,
+    {
         asm::{encoded_stats, Assembly},
         cillyir_exporter::CillyIRExpoter,
         il_exporter::ILExporter,
         Access, CILIter, MethodImpl, MethodRefIdx,
     },
-    BasicBlock, CILNode, CILRoot, MethodDef,
 };
 use fxhash::FxHashSet;
 
@@ -148,7 +148,7 @@ fn main() {
                 let start = Instant::now();
                 println!("Preparing to export the assembly");
                 #[cfg(not(miri))]
-                asm.export(path, ILExporter::new(cilly::v2::IlasmFlavour::Clasic, true));
+                asm.export(path, ILExporter::new(cilly::IlasmFlavour::Clasic, true));
                 println!(
                     "Exported the assembly in {} ms",
                     start.elapsed().as_millis()

cilly/src/bin/asmedit.rs

@@ -1,4 +1,4 @@
-use cilly::v2::asm::Assembly;
+use cilly::asm::Assembly;
 //use cilly::asm::Assembly;
 fn main() {
     let args: Vec<String> = std::env::args().collect();

cilly/src/bin/asmstat.rs

@@ -20,10 +20,8 @@ impl LinkableFile {
         &self.file
     }
 }
-fn load_ar(
-    r: &mut impl std::io::Read,
-) -> std::io::Result<(cilly::v2::Assembly, Vec<LinkableFile>)> {
-    let mut final_assembly = cilly::v2::Assembly::default();
+fn load_ar(r: &mut impl std::io::Read) -> std::io::Result<(cilly::Assembly, Vec<LinkableFile>)> {
+    let mut final_assembly = cilly::Assembly::default();
     let mut archive = Archive::new(r);
     let mut linkables = Vec::new();
     // Iterate over all entries in the archive:
@@ -58,9 +56,9 @@ fn load_ar(
 pub fn load_assemblies(
     raw_files: &[&String],
     archives: &[String],
-) -> (cilly::v2::Assembly, Vec<LinkableFile>) {
+) -> (cilly::Assembly, Vec<LinkableFile>) {
     println!("Preparing to load assmeblies");
-    let mut final_assembly = cilly::v2::Assembly::default();
+    let mut final_assembly = cilly::Assembly::default();
     let mut linkables = Vec::new();
     for asm_path in raw_files {
         let mut asm_file =
@@ -69,7 +67,7 @@ pub fn load_assemblies(
         asm_file
             .read_to_end(&mut asm_bytes)
             .expect("ERROR: Could not load the assembly file!");
-        let asm: cilly::v2::Assembly =
+        let asm: cilly::Assembly =
             postcard::from_bytes(&asm_bytes).expect("ERROR:Could not decode the assembly file!");
 
         final_assembly = final_assembly.link(asm);

cilly/src/bin/interpreter/main.rs

@@ -4,18 +4,14 @@ use cilly::{
     cilnode::IsPure,
     config, conv_usize,
     libc_fns::{self, LIBC_FNS, LIBC_MODIFIES_ERRNO},
-    v2::{
+    MethodRef, DEAD_CODE_ELIMINATION,
+    {
         asm::{MissingMethodPatcher, ILASM_FLAVOUR},
         cilnode::MethodKind,
         Assembly, BasicBlock, CILNode, CILRoot, ClassDef, ClassRef, Const, IlasmFlavour, Int,
         MethodImpl, Type,
     },
-    MethodRef, DEAD_CODE_ELIMINATION,
 };
-//use assembly::Assembly;
-
-mod cmd;
-mod export;
 mod load;
 mod native_passtrough;
 mod patch;
@@ -29,16 +25,16 @@ use std::{
 };
 mod aot;
 
-fn add_mandatory_statics(asm: &mut cilly::v2::Assembly) {
+fn add_mandatory_statics(asm: &mut cilly::Assembly) {
     let main_module = asm.main_module();
     asm.add_static(
-        cilly::v2::Type::Int(cilly::v2::Int::U8),
+        cilly::Type::Int(cilly::Int::U8),
         "__rust_alloc_error_handler_should_panic",
         false,
         main_module,
     );
     asm.add_static(
-        cilly::v2::Type::Int(cilly::v2::Int::U8),
+        cilly::Type::Int(cilly::Int::U8),
         "__rust_no_alloc_shim_is_unstable",
         false,
         main_module,
@@ -340,7 +336,7 @@ fn main() {
                     vec![].into(),
                 );
                 MethodImpl::MethodBody {
-                    blocks: vec![cilly::v2::BasicBlock::from_v1(
+                    blocks: vec![cilly::BasicBlock::from_v1(
                         &cilly::basic_block::BasicBlock::new(
                             vec![cilly::cil_root::CILRoot::Throw(
                                 cilly::cil_node::CILNode::NewObj(Box::new(
@@ -435,25 +431,25 @@ fn main() {
             }
         }),
     );
-    cilly::v2::builtins::select::generate_int_selects(&mut final_assembly, &mut overrides);
-    cilly::v2::builtins::insert_swap_at_generic(&mut final_assembly, &mut overrides);
-    cilly::v2::builtins::insert_bounds_check(&mut final_assembly, &mut overrides);
-    cilly::v2::builtins::casts::insert_casts(&mut final_assembly, &mut overrides);
-    cilly::v2::builtins::insert_heap(&mut final_assembly, &mut overrides, *C_MODE);
-    cilly::v2::builtins::int128::generate_int128_ops(&mut final_assembly, &mut overrides, *C_MODE);
-    cilly::v2::builtins::int128::i128_mul_ovf_check(&mut final_assembly, &mut overrides);
-    cilly::v2::builtins::f16::generate_f16_ops(&mut final_assembly, &mut overrides, *C_MODE);
-    cilly::v2::builtins::atomics::generate_all_atomics(&mut final_assembly, &mut overrides);
-    cilly::v2::builtins::stack_addr(&mut final_assembly, &mut overrides);
-    cilly::v2::builtins::transmute(&mut final_assembly, &mut overrides);
-    cilly::v2::builtins::create_slice(&mut final_assembly, &mut overrides);
-    cilly::v2::builtins::ovf_check_tuple(&mut final_assembly, &mut overrides);
-    cilly::v2::builtins::uninit_val(&mut final_assembly, &mut overrides);
+    cilly::builtins::select::generate_int_selects(&mut final_assembly, &mut overrides);
+    cilly::builtins::insert_swap_at_generic(&mut final_assembly, &mut overrides);
+    cilly::builtins::insert_bounds_check(&mut final_assembly, &mut overrides);
+    cilly::builtins::casts::insert_casts(&mut final_assembly, &mut overrides);
+    cilly::builtins::insert_heap(&mut final_assembly, &mut overrides, *C_MODE);
+    cilly::builtins::int128::generate_int128_ops(&mut final_assembly, &mut overrides, *C_MODE);
+    cilly::builtins::int128::i128_mul_ovf_check(&mut final_assembly, &mut overrides);
+    cilly::builtins::f16::generate_f16_ops(&mut final_assembly, &mut overrides, *C_MODE);
+    cilly::builtins::atomics::generate_all_atomics(&mut final_assembly, &mut overrides);
+    cilly::builtins::stack_addr(&mut final_assembly, &mut overrides);
+    cilly::builtins::transmute(&mut final_assembly, &mut overrides);
+    cilly::builtins::create_slice(&mut final_assembly, &mut overrides);
+    cilly::builtins::ovf_check_tuple(&mut final_assembly, &mut overrides);
+    cilly::builtins::uninit_val(&mut final_assembly, &mut overrides);
 
-    cilly::v2::builtins::math::bitreverse(&mut final_assembly, &mut overrides);
+    cilly::builtins::math::bitreverse(&mut final_assembly, &mut overrides);
 
     if *C_MODE {
-        cilly::v2::builtins::insert_exeception_stub(&mut final_assembly, &mut overrides);
+        cilly::builtins::insert_exeception_stub(&mut final_assembly, &mut overrides);
         externs.insert("__dso_handle", LIBC.clone());
         externs.insert("_mm_malloc", LIBC.clone());
         externs.insert("_mm_free", LIBC.clone());
@@ -492,11 +488,11 @@ fn main() {
             }),
         );
     } else {
-        cilly::v2::builtins::instert_threading(&mut final_assembly, &mut overrides);
-        cilly::v2::builtins::math::math(&mut final_assembly, &mut overrides);
-        cilly::v2::builtins::simd::simd(&mut final_assembly, &mut overrides);
-        cilly::v2::builtins::insert_exception(&mut final_assembly, &mut overrides);
-        cilly::v2::builtins::argc_argv_init(&mut final_assembly, &mut overrides);
+        cilly::builtins::instert_threading(&mut final_assembly, &mut overrides);
+        cilly::builtins::math::math(&mut final_assembly, &mut overrides);
+        cilly::builtins::simd::simd(&mut final_assembly, &mut overrides);
+        cilly::builtins::insert_exception(&mut final_assembly, &mut overrides);
+        cilly::builtins::argc_argv_init(&mut final_assembly, &mut overrides);
     }
 
     // Ensure the cctor and tcctor exist!
@@ -510,7 +506,7 @@ fn main() {
         None,
         vec![],
         vec![],
-        cilly::v2::Access::Public,
+        cilly::Access::Public,
         NonZeroU32::new(16),
         NonZeroU32::new(16),
         true,
@@ -538,11 +534,11 @@ fn main() {
         panic!("FORCE_FAIL");
     }
     if *C_MODE {
-        let cexport = cilly::v2::c_exporter::CExporter::new(is_lib, libs, dirs);
+        let cexport = cilly::c_exporter::CExporter::new(is_lib, libs, dirs);
 
         final_assembly.export(&path, cexport);
     } else if *JAVA_MODE {
-        final_assembly.export(&path, cilly::v2::java_exporter::JavaExporter::new(is_lib));
+        final_assembly.export(&path, cilly::java_exporter::JavaExporter::new(is_lib));
         if cargo_support {
             let bootstrap =
                 bootstrap_source(&path.with_extension("jar"), path.to_str().unwrap(), "java");
@@ -568,7 +564,7 @@ fn main() {
     } else {
         final_assembly.export(
             &path,
-            cilly::v2::il_exporter::ILExporter::new(*ILASM_FLAVOUR, is_lib),
+            cilly::il_exporter::ILExporter::new(*ILASM_FLAVOUR, is_lib),
         );
         if cargo_support {
             let bootstrap = bootstrap_source(