Better type support. Some casts now work. Some if's and match'es now work.

Author: FractalFir

makefile

@@ -1,10 +1,18 @@
 TEST_DIR = "test"
-CODEGEN_BACKEND = target/debug/librustc_codegen_clr.so
+CODEGEN_BACKEND = ../target/debug/librustc_codegen_clr.so
 RUSTC = rustc
 RUST_FLAGS = --crate-type lib
-test: build_backend compile_simple_file
-compile_simple_file:
-	rustc $(RUST_FLAGS) -O -Z codegen-backend=$(CODEGEN_BACKEND) test/identity.rs
+test: build_backend identy binops casts types ifs
+identy:
+	cd test && rustc $(RUST_FLAGS) -O -Z codegen-backend=$(CODEGEN_BACKEND) identity.rs
+binops:
+	cd test && rustc $(RUST_FLAGS) -O -Z codegen-backend=$(CODEGEN_BACKEND) binops.rs
+casts:
+	cd test && rustc $(RUST_FLAGS) -O -Z codegen-backend=$(CODEGEN_BACKEND) casts.rs
+types:
+	cd test && rustc $(RUST_FLAGS) -O -Z codegen-backend=$(CODEGEN_BACKEND) types.rs
+branches:
+	cd test && rustc $(RUST_FLAGS) -O -Z codegen-backend=$(CODEGEN_BACKEND) branches.rs
 build_backend:
 	cargo build
 

src/assembly.rs

@@ -1,5 +1,5 @@
-use crate::{FunctionSignature,CLRMethod};
 use crate::IString;
+use crate::{CLRMethod, FunctionSignature};
 use rustc_middle::{
     mir::mono::MonoItem,
     ty::{Instance, ParamEnv, TyCtxt},
@@ -9,10 +9,9 @@ pub(crate) struct Assembly {
     name: IString,
 }
 impl Assembly {
-    
     pub(crate) fn into_il_ir(&self) -> IString {
         let mut methods = String::new();
-        for method in &self.methods{
+        for method in &self.methods {
             methods.push_str(&method.into_il_ir());
         }
         let methods = format!(".class {name} {{{methods}}}", name = self.name);
@@ -22,33 +21,39 @@ impl Assembly {
 impl Assembly {
     pub(crate) fn new(name: &str) -> Self {
         let name: String = name.chars().take_while(|c| *c != '.').collect();
-        let name = name.replace("-", "_");
+        let name = name.replace('-', "_");
         Self {
             methods: Vec::with_capacity(0x100),
             name: name.into(),
         }
     }
-    pub(crate) fn add_fn<'tcx>(&mut self, instance: Instance<'tcx>, tcx: TyCtxt<'tcx>,name:&str) {
+    pub(crate) fn add_fn<'tcx>(&mut self, instance: Instance<'tcx>, tcx: TyCtxt<'tcx>, name: &str) {
         // TODO: figure out: What should it be???
         let param_env = ParamEnv::empty();
 
         let def_id = instance.def_id();
         let mir = tcx.optimized_mir(def_id);
         let blocks = &(*mir.basic_blocks);
         let sig = instance.ty(tcx, param_env).fn_sig(tcx);
-        let mut clr_method = CLRMethod::new(FunctionSignature::from_poly_sig(sig).expect("Could not resolve the function signature"),name);
+        let mut clr_method = CLRMethod::new(
+            FunctionSignature::from_poly_sig(sig)
+                .expect("Could not resolve the function signature"),
+            name,
+        );
         for block_data in blocks {
+            clr_method.begin_bb();
             for statement in &block_data.statements {
-                clr_method.add_statement(statement);
+                clr_method.add_statement(statement, mir, &tcx);
             }
             match &block_data.terminator {
-                Some(term) => clr_method.add_terminator(term),
+                Some(term) => clr_method.add_terminator(term,mir,&tcx),
                 None => (),
             }
         }
-        // Optimization is currently broken, and may produce invalid IR. 
+        // Optimization is currently broken, and may produce invalid IR.
         //clr_method.opt();
-        clr_method.typecheck();
+        //clr_method.typecheck();
+        clr_method.add_locals(&mir.local_decls);
         println!("clr_method:{clr_method:?}");
         println!("instance:{instance:?}\n");
         self.methods.push(clr_method);
@@ -57,7 +62,9 @@ impl Assembly {
         println!("adding item:{}", item.symbol_name(tcx));
 
         match item {
-            MonoItem::Fn(instance) => self.add_fn(instance, tcx,&format!("{}",item.symbol_name(tcx))),
+            MonoItem::Fn(instance) => {
+                self.add_fn(instance, tcx, &format!("{}", item.symbol_name(tcx)))
+            }
             _ => todo!("Unsupported item:\"{item:?}\"!"),
         }
     }

src/base_ir.rs

@@ -1,47 +1,58 @@
-use crate::{IString,VariableType,CLRMethod};
+use crate::IString;
+// An IR close, but not exactly equivalent to the CoreCLR IR.
+#[derive(Debug,Clone)]
+struct BranchInfo{bb_target:u16,value:u128}
 #[derive(Debug, Clone)]
 pub(crate) enum BaseIR {
+    LDConstI8(i8),
     LDConstI32(i32),
     STArg(u32),
     LDArg(u32),
     STLoc(u32),
     LDLoc(u32),
     Add,
+    Sub,
     Mul,
+    Rem,
     Shl,
+    Shr,
+    Eq,
     Return,
+    ConvF32,
+    ConvI32,
+    ConvI32Checked,
+    ConvI8,
+    //Not a real instruction, but a marker for a basic block.
+    BBLabel{bb_id:u32},
+    BEq{target:u32},
+    GoTo{target:u32},
 }
-impl BaseIR{
-    pub(crate) fn stack_change(&self)->i8{
-        match self{
-            Self::Add | Self::Mul | Self::Shl=>-1,
-            Self::Return=>-1,
-            Self::LDLoc(_)=>1,
-            Self::LDArg(_)=>1,
-            Self::STLoc(_)=>-1,
-            Self::STArg(_)=>-1,
-            Self::LDConstI32(_)=>-1,
+impl BaseIR {
+    pub(crate) fn clr_ir(&self) -> IString {
+        match self {
+            Self::BBLabel{bb_id} => format!("\tBB_{bb_id}:\n"),
+            Self::BEq{target} => format!("\tbeq BB_{target}\n"),
+            Self::GoTo{target} => format!("\tbr BB_{target}\n"),
+            Self::LDArg(arg) => format!("\tldarg.{arg}\n"),
+            Self::STArg(arg) => format!("\tstarg.{arg}\n"),
+            Self::LDLoc(arg) => format!("\tldloc.{arg}\n"),
+            Self::STLoc(arg) => format!("\tstloc.{arg}\n"),
+            Self::Return => "\tret\n".into(),
+            Self::Add => "\tadd\n".into(),
+            Self::Sub => "\tadd\n".into(),
+            Self::Mul => "\tmul\n".into(),
+            Self::Rem => "\trem\n".into(),
+            Self::Shl => "\tshl\n".into(),
+            Self::Shr => "\tshr\n".into(),
+            Self::Eq => "\tceq\n".into(),
+            Self::LDConstI8(i8const) => format!("\tldc.i4.s {i8const}\t\n"),
+            Self::LDConstI32(i32const) => format!("\tldc.i4 {i32const}\t\n"),
+            Self::ConvF32 => "\tconv.r4\n".into(),
+            Self::ConvI8 => "\tconv.i1\n".into(),
+            Self::ConvI32 => "\tconv.i4\n".into(),
+            Self::ConvI32Checked => "\tconv.ovf.i4\n".into(),
+            //_=>format!("\t//Comment!\n"),
         }
-    }
-    pub(crate) fn get_trivial_type(&self,parent_method:&CLRMethod)->Option<VariableType>{
-        match self{
-            Self::LDConstI32(_)=>Some(VariableType::I32),
-            Self::LDLoc(var_id)=>parent_method.local_type(*var_id).cloned(),
-            Self::LDArg(arg_id)=>Some(parent_method.get_arg_type(*arg_id).clone()),
-            _=>None,
-        }
-    }
-    pub(crate) fn clr_ir(&self)->IString{
-        match self{
-            Self::LDArg(arg)=>format!("\tldarg.{arg}\n"),
-            Self::LDLoc(arg)=>format!("\tldloc.{arg}\n"),
-            Self::STLoc(arg)=>format!("\tstloc.{arg}\n"),
-            Self::Return=>"\tret\n".into(),
-            Self::Add=>"\tadd\n".into(),
-            Self::Mul=>"\tmul\n".into(),
-            Self::Shl=>"\tshl\n".into(),
-            Self::LDConstI32(i32const)=>format!("\tldc.i4 {i32const}\t\n"),
-            _=>format!("\t//Comment!\n"),
-        }.into()
+        .into()
     }
 }