Fixed setting the references. Dereferencing still does not work.

Author: FractalFir

makefile

@@ -2,7 +2,7 @@ TEST_DIR = "test"
 CODEGEN_BACKEND = ../target/debug/librustc_codegen_clr.so
 RUSTC = rustc
 RUST_FLAGS = --crate-type lib
-test: build_backend identy binops casts types calls
+test: build_backend identy binops casts types calls references
 calls:
 	cd test && rustc $(RUST_FLAGS) -O -Z codegen-backend=$(CODEGEN_BACKEND) calls.rs && \
 	ilasm /dll libcalls.rlib
@@ -11,7 +11,12 @@ identy:
 	ilasm /dll libidentity.rlib
 binops:
 	cd test && rustc $(RUST_FLAGS) -O -Z codegen-backend=$(CODEGEN_BACKEND) binops.rs && \
-	ilasm /dll libbinops.rlib
+	ilasm /dll libbinops.rlib && \
+	rustc -O --emit=mir --crate-type=lib binops.rs
+references:
+	cd test && rustc $(RUST_FLAGS) -O -Z codegen-backend=$(CODEGEN_BACKEND) references.rs && \
+	ilasm /dll libreferences.rlib && \
+	rustc -O --emit=mir --crate-type=lib references.rs
 casts:
 	cd test && rustc $(RUST_FLAGS) -O -Z codegen-backend=$(CODEGEN_BACKEND) casts.rs && \
 	ilasm /dll libcasts.rlib

src/assembly.rs

@@ -44,6 +44,7 @@ impl Assembly {
                 .expect("Could not resolve the function signature"),
             name,
         );
+        clr_method.add_locals(&mir.local_decls);
         for block_data in blocks {
             clr_method.begin_bb();
             for statement in &block_data.statements {
@@ -54,9 +55,7 @@ impl Assembly {
                 None => (),
             }
         }
-        // Optimization is currently broken, and may produce invalid IR.
         clr_method.opt();
-        clr_method.add_locals(&mir.local_decls);
         println!("clr_method:{clr_method:?}");
         println!("instance:{instance:?}\n");
         self.methods.push(clr_method);

src/assigment_target.rs

@@ -5,6 +5,7 @@ use rustc_middle::{
     mir::{Body, Place,AggregateKind,CastKind,BinOp,Operand,ConstantKind},
     ty::TyCtxt,
 };
+use rustc_middle::mir::ProjectionElem;
 macro_rules! sign_cast {
     ($var:ident,$src:ty,$dest:ty) => {
         (<$dest>::from_ne_bytes(($var as $src).to_ne_bytes()))
@@ -34,7 +35,24 @@ impl AsigmentTarget {
                     LocalPlacement::Var(var_id) => BaseIR::STLoc(var_id),
                 });
         } else {
-            panic!("Can't handle non-trivial assignments!");
+            let local: u32 = place.local.into();
+            new.adress_calc
+                .push(match clr_method.local_id_placement(local) {
+                    LocalPlacement::Arg(arg_id) => BaseIR::LDArg(arg_id),
+                    LocalPlacement::Var(var_id) => BaseIR::LDLoc(var_id),
+                });
+            for modifier in &place.projection[..(place.projection.len() - 1)]{
+                todo!("Can't handle assignments with more than one level of indirection")
+            }
+            let last = place.projection[(place.projection.len() - 1)];
+            match last{
+                ProjectionElem::Deref => {
+                    //TODO: handle the type
+                    new.value_pos = AsigmentValuePosition::AfterAdress;
+                    new.set_ops.push(BaseIR::STIInd(4));
+                }
+                _=> todo!("Can't handle ProjectionElements of type {last:?}!"),
+            }
         }
         new
     }
@@ -90,6 +108,13 @@ impl RValue {
             _ => todo!("Unknown binop:{binop:?}"),
         });
     }
+    fn read_pointer_of_type(&mut self, element_type:&VariableType){
+        match element_type{
+            VariableType::I32 => self.ops.push(BaseIR::LDIndIn(std::mem::size_of::<i32>() as u8)),
+            VariableType::Ref(_) | VariableType::RefMut(_) =>self.ops.push(BaseIR::LDIndI),
+            _=>todo!("Can't derference pointer of type {element_type:?}"),
+        }
+    }
     fn process_rvalue<'ctx>(
         &mut self,
         rvalue: &CompilerRValue<'ctx>,
@@ -128,6 +153,16 @@ impl RValue {
                     ),
                 }
             }
+            CompilerRValue::Repeat(_, _) => todo!("Can't yet initialize arrays!"),
+            CompilerRValue::CopyForDeref(place) =>{
+                if place.projection.len() == 1{
+                    self.load(place.local.into(),clr_method);
+                    self.read_pointer_of_type(&clr_method.get_type_of_local(place.local.into()).get_pointed_type().expect("Tried to deference a value that was neither a pointer nor a reference"));
+                }
+                else {
+                    panic!("Can't handle non-trivial deference's yet, projection:{projection:?}!",projection = place.projection);
+                }
+            }
             _ => todo!("Can't yet handle a rvalue of type {rvalue:?}"),
         }
     }

src/base_ir.rs

@@ -7,6 +7,8 @@ pub(crate) enum BaseIR {
     LDConstI32(i32),
     LDConstI64(i64),
     STIInd(u8),
+    LDIndIn(u8),
+    LDIndI,
     LDConstString(String),
     STArg(u32),
     LDArg(u32),
@@ -75,6 +77,8 @@ impl BaseIR {
             Self::NewObj { ctor_fn } => format!("\tnewobj instance {ctor_fn}\n"),
             Self::Throw => "\tthrow\n".into(),
             Self::STIInd(size) => format!("\tstind.i{size}\n"),
+            Self::LDIndIn(size) => format!("\tldind.i{size}\n"),
+            Self::LDIndI=>"\tldind.i\n".into(),
         }
         .into()
     }

src/clr_method.rs

@@ -33,6 +33,12 @@ pub(crate) enum LocalPlacement {
     Var(u32),
 }
 impl CLRMethod {
+    pub(crate) fn get_type_of_local(&self, local:u32)->&VariableType{
+       match self.local_id_placement(local){
+            LocalPlacement::Arg(index)=>&self.sig.inputs[index as usize],
+            LocalPlacement::Var(index)=>&self.locals[index as usize],
+       }
+    }
     pub(crate) fn extend_ops(&mut self,ops:&[BaseIR]){
         self.ops.extend(ops.iter().map(|ref_op| ref_op.clone()))
     }
@@ -188,35 +194,6 @@ impl CLRMethod {
             LocalPlacement::Var(var_id) => BaseIR::LDLoc(var_id),
         })
     }
-    fn store(&mut self, place: Place) {
-        if place.projection.is_empty() {
-            let local: u32 = place.local.into();
-            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),
-            })
-        } else {
-            // First, travel trough almost every element besides the last one!
-            if place.projection.len() > 1 {
-                panic!("Unhandled Non-trivial store!");
-                for _projection_mod in &place.projection[..(place.projection.len() - 1)] {}
-            }
-            // The value or address of the last one should be on top of the stack.
-            let last = place.projection[place.projection.len() - 1];
-            match last {
-                PlaceElem::Deref => {
-                    let local: u32 = place.local.into();
-                    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),
-                    });
-                    //TODO: use type info!
-                    self.ops.push(BaseIR::STIInd(4));
-                }
-                _ => todo!("Unhandled placement!"),
-            }
-        }
-    }
     fn process_constant(&mut self, constant: ConstantKind) {
         match constant {
             ConstantKind::Val(value, r#type) => match value {
@@ -246,89 +223,6 @@ impl CLRMethod {
             }
         }
     }
-    fn convert(&mut self, src: &VariableType, dest: &VariableType) {
-        match (src, dest) {
-            (
-                VariableType::F32
-                | VariableType::I8
-                | VariableType::I16
-                | VariableType::I32
-                | VariableType::U8
-                | VariableType::U16
-                | VariableType::U32,
-                VariableType::I32,
-            ) => self.ops.push(BaseIR::ConvI32),
-            (
-                VariableType::F64
-                | VariableType::I64
-                | VariableType::U64
-                | VariableType::ISize
-                | VariableType::USize,
-                VariableType::I32,
-            ) => self.ops.push(BaseIR::ConvI32Checked),
-            (VariableType::F32, VariableType::I8) => self.ops.push(BaseIR::ConvI8),
-            (VariableType::I32, VariableType::F32) => self.ops.push(BaseIR::ConvF32),
-            _ => todo!("Can't convert type {src:?} to {dest:?}"),
-        }
-    }
-    // Makes so the top of the stack is the value of RValue
-    fn process_rvalue<'ctx>(
-        &mut self,
-        rvalue: &Rvalue<'ctx>,
-        body: &Body<'ctx>,
-        tyctx: &TyCtxt<'ctx>,
-    ) {
-        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::Sub => BaseIR::Sub,
-                    BinOp::Mul => BaseIR::Mul,
-                    BinOp::Shl => BaseIR::Shl,
-                    BinOp::Shr => BaseIR::Shr,
-                    BinOp::Eq => BaseIR::Eq,
-                    BinOp::Ne => BaseIR::NEq,
-                    BinOp::Gt => BaseIR::Gt,
-                    BinOp::Rem => BaseIR::Rem,
-                    BinOp::BitXor => BaseIR::Xor,
-                    BinOp::BitOr => BaseIR::Or,
-                    BinOp::BitAnd => BaseIR::And,
-                    BinOp::Div => BaseIR::Div,
-                    _ => todo!("Unknown binop:{binop:?}"),
-                });
-            }
-            Rvalue::Cast(
-                CastKind::IntToInt
-                | CastKind::FloatToFloat
-                | CastKind::FloatToInt
-                | CastKind::IntToFloat,
-                operand,
-                target,
-            ) => {
-                self.process_operand(operand);
-                self.convert(
-                    &VariableType::from_ty(operand.ty(body, *tyctx)),
-                    &VariableType::from_ty(*target),
-                );
-            }
-            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:?}");
-                    }
-                    _ => todo!(
-                        "Can't yet handle the aggregate of kind {kind:?} and operands:{operands:?}"
-                    ),
-                }
-            }
-            _ => todo!("Can't yet handle a rvalue of type {rvalue:?}"),
-        }
-    }
     pub(crate) fn add_statement<'ctx>(
         &mut self,
         statement: &Statement<'ctx>,
@@ -339,12 +233,8 @@ impl CLRMethod {
         match &statement.kind {
             StatementKind::Assign(asign_box) => {
                 let (place, rvalue) = (asign_box.0, &asign_box.1);
-                //self.process_rvalue(rvalue, body, tyctx);
                 let rvalue = RValue::from_rvalue(rvalue, body, tyctx,self);
-                //self.ops.extend(rvalue.get_ops().iter().map(|op|op.clone()));
                 AsigmentTarget::from_placement(place,&self).finalize(rvalue,self);
-                //self.store(place);
-                //panic!("place:{place:?},rvalue:{rvalue:?}");
             }
             StatementKind::StorageLive(local) => {
                 self.var_live((*local).into());

src/lib.rs

@@ -54,15 +54,15 @@ impl FunctionSignature {
     pub(crate) fn from_poly_sig(sig: PolyFnSig) -> Option<Self> {
         let inputs = sig
             .inputs()
-            // `skip_binder` is `a riskiy thing` TODO: Foigure out to which kind of issues it may lead!
+            // `skip_binder` is `a riskiy thing` TODO: Figure out to which kind of issues it may lead!
             .skip_binder()
             //.no_bound_vars()?
             .iter()
             .map(|v| VariableType::from_ty(*v))
             .collect();
         let output = VariableType::from_ty(
             sig.output()
-                // `skip_binder` is `a riskiy thing` TODO: Foigure out to which kind of issues it may lead!
+                // `skip_binder` is `a riskiy thing` TODO: Figure out to which kind of issues it may lead!
                 .skip_binder(), //.no_bound_vars()?
         );
         Some(Self { inputs, output })

src/variable.rs

@@ -26,6 +26,13 @@ pub(crate) enum VariableType {
     RefMut(Box<Self>),
 }
 impl VariableType {
+    pub(crate) fn get_pointed_type(&self)->Option<Self>{
+        match self{
+            Self::Ref(inner) => Some((*inner.as_ref()).clone()),
+            Self::RefMut(inner) => Some((*inner.as_ref()).clone()),
+            _=>None,
+        }
+    }
     pub(crate) fn from_ty(ty: Ty) -> Self {
         match ty.kind() {
             TyKind::Int(IntTy::I8) => VariableType::I8,

test/.gitignore

@@ -1,3 +1,4 @@
 *.rlib
 *.dll
 *.rcgu.o
+*.mir

test/binops.rs

@@ -25,6 +25,3 @@ pub extern fn neq(a:i32,b:i32)->bool{a != b}
 pub extern fn sqr_mag(ax:i32,ay:i32)->i32{ax*ax + ay*ay}
 #[no_mangle]
 pub extern fn pow2(power:i32)->i32{1<<power}
-/*
-#[no_mangle]
-pub extern fn set(reference:&mut i32, value:i32){*reference = value}*/

test/references.rs

@@ -0,0 +1,10 @@
+#[no_mangle]
+pub extern fn set(reference:&mut i32, value:i32){*reference = value}
+#[no_mangle]
+pub extern fn set_i2(reference:&mut &mut i32, value:i32){**reference = value}
+#[no_mangle]
+pub extern fn set_i3(reference:&mut &mut &mut i32, value:i32){***reference = value}
+#[no_mangle]
+pub extern fn set_i4(reference:&mut &mut &mut &mut i32, value:i32){****reference = value}
+#[no_mangle]
+pub extern fn get(reference:&mut i32)->i32{*reference}