Simple functions may now be converted into IR

Author: FractalFir

makefile

@@ -4,7 +4,7 @@ RUSTC = rustc
 RUST_FLAGS = --crate-type lib
 test: build_backend compile_simple_file
 compile_simple_file:
-	rustc $(RUST_FLAGS) -Z codegen-backend=$(CODEGEN_BACKEND) test/identity.rs
+	rustc $(RUST_FLAGS) -O -Z codegen-backend=$(CODEGEN_BACKEND) test/identity.rs
 build_backend:
 	cargo build
 

src/lib.rs

@@ -10,73 +10,190 @@ extern crate rustc_driver;
 use rustc_codegen_ssa::CrateInfo;
 use std::any::Any;
 use rustc_codegen_ssa::{traits::CodegenBackend,CodegenResults};
-use rustc_middle::{ty::{TyCtxt,Ty,ParamEnv,Instance,PolyFnSig},dep_graph::{WorkProductId,WorkProduct},mir::{Statement,StatementKind,Rvalue,mono::MonoItem,Operand}};
+use rustc_middle::{ty::{TyCtxt,Ty,ParamEnv,Instance,PolyFnSig,TyKind,IntTy},dep_graph::{WorkProductId,WorkProduct},mir::{Statement,StatementKind,Terminator,TerminatorKind,Rvalue,BinOp,Operand,ConstantKind,AggregateKind,interpret::ConstValue,mono::MonoItem}};
 use rustc_metadata::EncodedMetadata;
 use rustc_span::ErrorGuaranteed;
 use std::hash::BuildHasherDefault;
 use rustc_session::{config::OutputFilenames,Session};
 use rustc_data_structures::fx::FxIndexMap;
-#[derive(Debug)]
-enum CLROp{
+#[derive(Debug,Clone)]
+enum BaseIR{
+    LDConstI32(i32),
     STArg(u32),
     LDArg(u32),
     STLoc(u32),
     LDLoc(u32),
+    Add,
+    Mul,
+    Shl,
+    Return,
 }
 struct MyBackend;
 struct CustomCodegen{}
 #[derive(Debug)]
 struct CLRMethod{
-    ops:Vec<CLROp>,
+    ops:Vec<BaseIR>,
     argc:u32,
 }
+enum LocalPlacement{
+    Arg(u32),
+    Var(u32),
+}
 impl CLRMethod{
     fn argc(&self)->u32{self.argc}
+    fn remove_sl(&mut self)->usize{
+        let mut opt_ops:Vec<BaseIR> = Vec::with_capacity(self.ops.len());
+        let mut ops_peek = self.ops.iter().peekable();
+        while let Some(op) = ops_peek.next(){
+            match op{
+                BaseIR::STLoc(local_id)=>{
+                    if let Some(BaseIR::LDLoc(other_id)) = ops_peek.peek(){
+                        //Ops store and the load the same value, being effectively a NOP.
+                        if local_id == other_id{
+                            ops_peek.next();
+                            continue;
+                        }
+                    }  
+                }
+                _=>(),
+            }
+            opt_ops.push(op.clone());
+        }
+        self.ops = opt_ops;
+        self.ops.len()
+    }
+    fn opt(&mut self){
+        const MAX_OPT_PASS:usize = 8;
+        for _ in 0..MAX_OPT_PASS{
+            let prev_length = self.ops.len();
+            if !(self.remove_sl() < prev_length){continue;}
+        }
+    }
+    fn has_return(&self)->bool{true}
     fn new(argc:u32)->Self{
         Self{argc,ops:Vec::with_capacity(0xF)}
     }
-    fn load(&mut self,var:u32){
-        if var < self.argc(){ 
-            self.ops.push(CLROp::LDArg(var));
+    fn var_live(&mut self,local:u32){
+        //TODO: use variable lifetimes!
+    }
+    fn var_dead(&mut self,local:u32){
+        //TODO: use variable lifetimes!
+    }
+    fn local_id_placement(&self,local:u32)->LocalPlacement{
+        // I assume local 0 is supposed to be the return value. TODO: check if this is always the case.
+        if self.has_return(){
+             if local == 0{
+                LocalPlacement::Var(0)
+            } 
+            else if local - 1 < self.argc(){
+                LocalPlacement::Arg(local - 1)
+            }
+            else{
+                LocalPlacement::Var(local - self.argc())
+            }
         }
         else{
-            println!("argc:{}, var:{var}",self.argc);
-            self.ops.push(CLROp::LDLoc(var - self.argc()));
+            panic!("Can't handle void functions yet. Diagnose MIR to determine what happens to the return var(0)!");
         }
+       
+    }
+    fn load(&mut self,local:u32){
+        self.ops.push(match self.local_id_placement(local){
+            LocalPlacement::Arg(arg_id)=>BaseIR::LDArg(arg_id),
+            LocalPlacement::Var(var_id)=>BaseIR::LDLoc(var_id),
+        })
+    }
+    fn store(&mut self,local:u32){
+        self.ops.push(match self.local_id_placement(local){
+            LocalPlacement::Arg(arg_id)=>BaseIR::STArg(arg_id),
+            LocalPlacement::Var(var_id)=>BaseIR::STLoc(var_id),
+        })
+    }
+    fn process_constant(&mut self, constant:ConstantKind){
+        self.ops.push(match constant{
+            ConstantKind::Val(value,r#type)=> match value{
+                ConstValue::Scalar(scalar)=>{
+                    match r#type.kind(){
+                        TyKind::Int(IntTy::I32)=>BaseIR::LDConstI32(scalar.to_i32().expect("Type is i32, but odes not fit in i32.")),
+                        _=>todo!("Unhandled type kind {:?}",r#type.kind()),
+                    }
+                }
+                _=>todo!("Unhanled constant value {value:?}"),
+            }
+            _=>todo!("Unhanled constant {constant:?}"),
+        });
     }
     // Makes so the top of the stack is the value of RValue
     fn process_operand(&mut self, operand:&Operand){
         match operand{
             Operand::Copy(place) => self.load(place.local.into()),
+            //TODO:Do moves need to be treated any diffrently forom copies in the context of CLR?
+            Operand::Move(place) => self.load(place.local.into()),
+            Operand::Constant(const_val)=>{
+                self.process_constant(const_val.literal);
+            },
             _=>todo!("Unhanled operand {operand:?}"),
         }
     }
     // Makes so the top of the stack is the value of RValue
     fn process_rvalue(&mut self,rvalue:&Rvalue){
         match rvalue{
             Rvalue::Use(operand)=>self.process_operand(operand),
+            Rvalue::BinaryOp(binop,operands)=>{
+                let (a,b):(_,_) = (&operands.0,&operands.1);
+                self.process_operand(a);
+                self.process_operand(b);
+                self.ops.push(match binop{
+                    BinOp::Add=>BaseIR::Add,
+                    BinOp::Mul=>BaseIR::Mul,
+                    BinOp::Shl=>BaseIR::Shl,
+                    _=>todo!("Unknown binop:{binop:?}"),
+                });
+            }
+            Rvalue::Aggregate(kind,operands)=>{
+                match kind.as_ref(){
+                    AggregateKind::Adt(def_id,variant_idx,subst_ref,utai,fidx)=>{
+                        //let (def_id,variant_idx,subst_ref,utai,fidx) = *adt;
+                        panic!("def_id:{def_id:?},variant_idx:{variant_idx:?},subst_ref:{subst_ref:?},utai:{utai:?},fidx:{fidx:?},\noperands:{operands}");
+                    }
+                    _=> todo!("Can't yet handle the aggregate of kind {kind:?} and operands:{operands:?}"),
+                }
+            }
             _=>todo!("Can't yet handle a rvalue of type {rvalue:?}"),
         }
     }
-    fn store(&mut self,var:u32){
-        if var < self.argc(){
-            self.ops.push(CLROp::STArg(var));
-        }
-        else{
-            self.ops.push(CLROp::STLoc(var - self.argc()));
-        }
-    }
     fn add_statement(&mut self,statement:&Statement){
+        println!("statement:{statement:?}");
         match &statement.kind{
             StatementKind::Assign(asign_box)=>{
                 let (place,rvalue) = (asign_box.0,&asign_box.1);
                 self.process_rvalue(rvalue);
                 self.store(place.local.into());
                 //panic!("place:{place:?},rvalue:{rvalue:?}");
+            },
+            StatementKind::StorageLive(local)=>{
+                self.var_live((*local).into());
+            }
+            StatementKind::StorageDead(local)=>{
+                self.var_dead((*local).into());
             }
             _=>todo!("Unhanded statement:{:?}",statement.kind),       
         }
     }
+    fn add_terminator(&mut self,terminator:&Terminator){
+        match terminator.kind{
+            TerminatorKind::Return=>{
+                if self.has_return(){
+                    self.load(0);
+                    self.ops.push(BaseIR::Return);
+                }
+                else{
+                    todo!("Can't yet return from a void method!");
+                } 
+            }
+            _=>todo!("Unknown terminator type {terminator:?}"),
+        }
+    }
 }
 impl CustomCodegen{
     fn add_fn<'tcx>(&mut self,instance:Instance<'tcx>,tcx: TyCtxt<'tcx>){
@@ -92,8 +209,12 @@ impl CustomCodegen{
             for statement in &block_data.statements{
                 clr_method.add_statement(statement);
             }
-            
+            match &block_data.terminator{
+                Some(term)=>clr_method.add_terminator(term),
+                None=>(),
+            }
         }
+        clr_method.opt();
         println!("clr_method:{clr_method:?}");
         println!("instance:{instance:?}\n");
     }

test/identity.rs

@@ -1,9 +1,13 @@
 pub extern fn identity(a:i32)->i32{a}
-/*
-pub struct Vector3(f32,f32,f32);
+pub extern fn add(a:i32)->i32{a+a}
+pub extern fn add2(a:i32,b:i32)->i32{a + b}
+pub extern fn sqr_mag(ax:i32,ay:i32)->i32{ax*ax + ay*ay}
+pub extern fn pow2(power:i32)->i32{1<<power}
+struct Vector3{x:f32,y:f32,z:f32}
+
 impl std::ops::Add for Vector3{
-    type Output = Self;
+    type Output = Vector3;
     fn add(self,rhs:Self)->Self{
-        Self(self.0 + rhs.0, self.1 + rhs.1, self.2 + rhs.2)
+        Self{x:self.x + rhs.x,y:self.y + rhs.y,z:self.z + rhs.z}    
     }
-}*/
+}