Added support for setting fields of structs. Added optimzation, which removed a lot of unused CIL ops, locals, and labels.

FractalFir · FractalFir · commit 007551eefdf1 · 2023-09-21T00:00:24.000+02:00
diff --git a/src/assembly.rs b/src/assembly.rs
@@ -62,7 +62,7 @@ impl Assembly {
             last_bb_id += 1;
             for statement in &block_data.statements {
                 ops.extend(crate::statement::handle_statement(statement, mir, tcx, mir));
-                ops.push(CILOp::Comment(format!("{statement:?}").into()));
+                // ops.push(CILOp::Comment(format!("{statement:?}").into()));
                 //println!("ops:{ops:?}\n\n");
             }
             match &block_data.terminator {
@@ -92,6 +92,10 @@ impl Assembly {
             self.types.insert(type_def);
         }
     }
+    pub fn opt(&mut self){
+        let functions:HashSet<_> = self.functions.iter().map(|method|{let mut method = method.clone();crate::opt::opt_method(&mut method);method}).collect();
+        self.functions = functions;
+    }
     pub fn add_typedef<'ctx>(&mut self, type_def: TypeDef) {
         self.types.insert(type_def);
     }
diff --git a/src/assembly_exporter/ilasm_exporter.rs b/src/assembly_exporter/ilasm_exporter.rs
@@ -379,11 +379,18 @@ fn op_cli(op: &crate::cil_op::CILOp) -> Cow<'static, str> {
         }
         // Pointer stuff
         CILOp::LDIndI8 => "ldind.i1".into(),
-        CILOp::Pop => "pop".into(),
+        //OOP
         CILOp::Throw => "throw".into(),
         CILOp::LdStr(str) => format!("ldstr {str:?}").into(),
         CILOp::LDField(descr) => format!(
-            "ldfld {prefixed_type} {owner}::{field_name}",
+            "ldfld {prefixed_type} valuetype {owner}::{field_name}",
+            prefixed_type = prefixed_type_cli(descr.tpe()),
+            owner = dotnet_type_ref_cli(descr.owner()),
+            field_name = descr.name()
+        )
+        .into(),
+        CILOp::STField(descr) => format!(
+            "stfld {prefixed_type} valuetype {owner}::{field_name}",
             prefixed_type = prefixed_type_cli(descr.tpe()),
             owner = dotnet_type_ref_cli(descr.owner()),
             field_name = descr.name()
@@ -421,6 +428,9 @@ fn op_cli(op: &crate::cil_op::CILOp) -> Cow<'static, str> {
                 .into()
             }
         }
+        //Stack 
+        CILOp::Pop => "pop".into(),
+        CILOp::Dup => "dup".into(),
         _ => todo!("Unsuported op {op:?}"),
     }
 }
diff --git a/src/cil_op.rs b/src/cil_op.rs
@@ -148,8 +148,12 @@ pub enum CILOp {
     Gt,
     //Special
     Pop,
+    Dup,
+    Nop,
     //OOP
     NewObj(Box<CallSite>),
     LDField(Box<FieldDescriptor>),
     LDFieldAdress(Box<FieldDescriptor>),
+    STField(Box<FieldDescriptor>),
+    LdObj(Box<DotnetTypeRef>),
 }
diff --git a/src/compile_test.rs b/src/compile_test.rs
@@ -107,7 +107,7 @@ macro_rules! run_test {
             let exec_path = concat!("../", stringify!($test_name), ".exe");
             test_dotnet_executable(exec_path, test_dir);
         }
-    };
+};
 }
 #[cfg(test)]
 fn backend_path() -> &'static str {
@@ -130,9 +130,10 @@ test_lib! {identity}
 test_lib! {libc}
 test_lib! {nbody}
 test_lib! {references}
-test_lib! {structs}
+//test_lib! {structs}
 
 test_lib! {types}
 
 run_test! {arthm,add}
 run_test! {types,enums}
+run_test! {types,structs}
diff --git a/src/lib.rs b/src/lib.rs
@@ -61,6 +61,7 @@ mod r#type;
 mod type_def;
 mod unop;
 mod utilis;
+mod opt;
 use assembly::Assembly;
 struct MyBackend;
 pub(crate) const ALWAYS_INIT_STRUCTS: bool = false;
@@ -106,7 +107,7 @@ impl CodegenBackend for MyBackend {
             let cs = cil_op::CallSite::new(None, symbol.into(), sig, true);
             codegen.set_entrypoint(cs);
         }
-
+        codegen.opt();
         let name: IString = cgus.iter().next().unwrap().name().to_string().into();
         Box::new((
             name,
diff --git a/src/method.rs b/src/method.rs
@@ -40,6 +40,9 @@ impl Method {
             .iter()
             .any(|attr| *attr == Attribute::EntryPoint)
     }
+    pub fn ops_mut(&mut self)->&mut Vec<CILOp>{
+        &mut self.ops
+    }
     pub fn access(&self) -> AccessModifer {
         self.access
     }
@@ -61,4 +64,7 @@ impl Method {
     pub fn add_attribute(&mut self, attr: Attribute) {
         self.attributes.push(attr);
     }
+    pub fn set_locals(&mut self,locals: impl Into<Vec<Type>>){
+        self.locals = locals.into();
+    }
 }
diff --git a/src/opt/mod.rs b/src/opt/mod.rs
@@ -0,0 +1,109 @@
+use crate::{method::Method, cil_op::CILOp};
+const MAX_PASS:u32 = 4;
+pub fn opt_method(method:&mut Method){
+    for _ in 0..MAX_PASS{
+        op2_combos(method.ops_mut());
+        remove_zombie_sets(method.ops_mut());
+        method.ops_mut().retain(|op|*op != CILOp::Nop);
+        remove_unused_locals(method);
+    }
+}
+fn remove_unused_locals(method:&mut Method){
+    let mut local_map = vec![u32::MAX;method.locals().len()];
+    let mut new_locals = Vec::with_capacity(method.locals().len());
+    for (local,tpe) in  method.locals().iter().enumerate(){
+        if local_map[local] == u32::MAX && !is_local_unused(method.get_ops(), local as u32){
+            local_map[local] = new_locals.len() as u32;
+            new_locals.push(tpe.clone());
+        }
+    }
+    method.ops_mut().iter_mut().for_each(|op|match op{
+        CILOp::LDLoc(idx)=>{
+            let new_loc = local_map[*idx as usize];
+            *op = CILOp::LDLoc(new_loc);
+        },
+        CILOp::LDLocA(idx)=>{
+            let new_loc = local_map[*idx as usize];
+            *op = CILOp::LDLocA(new_loc);
+        },
+        CILOp::STLoc(idx)=>{
+            let new_loc = local_map[*idx as usize];
+            *op = CILOp::STLoc(new_loc);
+        }
+        _=>(),
+    });
+    method.set_locals(new_locals);
+}
+fn remove_zombie_sets(ops:&mut Vec<CILOp>){
+    for idx in 0..ops.len(){
+       match ops[idx]{
+            CILOp::STLoc(loc)=>
+                if is_local_dead(ops,loc){
+                    ops[idx] = CILOp::Pop;
+            },
+            CILOp::Label(label)=>
+                if is_label_unsused(ops,label){
+                    ops[idx] = CILOp::Nop;
+            },
+            _=>(),
+       }
+    }
+}
+fn op2_combos(ops:&mut Vec<CILOp>){
+    if ops.is_empty(){
+        return;
+    }
+    for idx in 0..(ops.len() - 1){
+        let (op1,op2) = (&ops[idx],&ops[idx + 1]);
+        match (op1,op2){
+            (CILOp::LDLoc(a),CILOp::STLoc(b))=> if a == b{
+                ops[idx] = CILOp::Nop;
+                ops[idx + 1]  = CILOp::Nop;
+            }
+            (CILOp::STLoc(a),CILOp::LDLoc(b))=> if a == b{
+                ops[idx + 1]  = CILOp::STLoc(*a);
+                ops[idx] = CILOp::Dup;
+                
+            }
+            (CILOp::Dup,CILOp::Pop)=>{
+                ops[idx] = CILOp::Nop;
+                ops[idx + 1]  = CILOp::Nop;
+            }
+            (CILOp::GoTo(target),CILOp::Label(label))=>if target == label{
+                ops[idx] = CILOp::Nop;
+            }
+            _=>(),
+        }
+    }
+}
+/// A "Dead" local is one that is only written into - never read.
+fn is_local_dead(ops:&[CILOp],local:u32)->bool{
+    !ops.iter().any(|op|{
+        match op{
+            CILOp::LDLoc(loc) => *loc == local,
+            CILOp::LDLocA(loc) => *loc == local,
+            _=>false,
+        }
+    })
+}
+/// A "Unused" local is one that is never written to or read from.
+fn is_local_unused(ops:&[CILOp],local:u32)->bool{
+    !ops.iter().any(|op|{
+        match op{
+            CILOp::LDLoc(loc) => *loc == local,
+            CILOp::LDLocA(loc) => *loc == local,
+            CILOp::STLoc(loc) => *loc == local,
+            _=>false,
+        }
+    })
+}
+/// A "Unused" label is one that is never jumped to 
+fn is_label_unsused(ops:&[CILOp],label:u32)->bool{
+    !ops.iter().any(|op|{
+        match op{
+            CILOp::GoTo(target) => label == *target,
+            CILOp::BEq(target) => label == *target,
+            _=>false,
+        }
+    })
+}
diff --git a/src/place.rs b/src/place.rs
@@ -9,7 +9,9 @@ fn slice_head<T>(slice: &[T]) -> (&T, &[T]) {
 fn pointed_type(ty: Ty) -> Ty {
     if let TyKind::Ref(_region, inner, _mut) = ty.kind() {
         *inner
-    } else {
+    } else if let TyKind::RawPtr(inner_and_mut) = ty.kind() {
+        inner_and_mut.ty   
+    }else {
         panic!("{ty:?} is not a pointer type!");
     }
 }
@@ -18,6 +20,7 @@ fn body_ty_is_by_adress(last_ty: &Ty) -> bool {
         TyKind::Int(_) => false,
         TyKind::Adt(_, _) => true,
         TyKind::Ref(_region, inner, _mut) => false,
+        TyKind::RawPtr(_) => false,
         _ => todo!("TODO: body_ty_is_by_adress does not support type {last_ty:?}"),
     }
 }
@@ -56,37 +59,37 @@ fn local_body<'tcx>(local: usize, method: &rustc_middle::mir::Body<'tcx>) -> (CI
         (local_get(local, method), ty)
     }
 }
-/// Returns the ops for getting the value of place.
-pub fn place_get<'a>(
-    place: &Place<'a>,
+fn place_elem_get<'a>(
+    place_elem: &PlaceElem<'a>,
+    curr_type: Ty<'a>,
     ctx: TyCtxt<'a>,
-    method: &rustc_middle::mir::Body<'a>,
 ) -> Vec<CILOp> {
-    let mut ops = Vec::with_capacity(place.projection.len());
-    if place.projection.is_empty() {
-        ops.push(local_get(place.local.as_usize(), method));
-        return ops;
-    } else {
-        let (op, mut ty) = local_body(place.local.as_usize(), method);
-        ops.push(op);
-        let (head, body) = slice_head(place.projection);
-        for elem in body {
-            println!("elem:{elem:?} ty:{ty:?}");
-            let (curr_ty, curr_ops) = place_elem_body(elem, ty, ctx);
-            ty = curr_ty;
-            ops.extend(curr_ops);
+    match place_elem {
+        PlaceElem::Deref => deref_op(curr_type,ctx),
+        PlaceElem::Field(index, field_type) => {
+            let field_name = field_name(curr_type, index.as_u32());
+            let curr_type = crate::r#type::Type::from_ty(curr_type, ctx);
+            let curr_type = if let crate::r#type::Type::DotnetType(dotnet_type) = curr_type {
+                dotnet_type.as_ref().clone()
+            } else {
+                panic!();
+            };
+            let field_desc = FieldDescriptor::boxed(
+                curr_type,
+                crate::r#type::Type::from_ty(*field_type, ctx),
+                field_name,
+            );
+            vec![CILOp::LDField(field_desc)]
         }
-        ops.extend(place_elem_get(head, ty, ctx));
-        ops
+        _ => todo!("Can't handle porojection {place_elem:?} in get"),
     }
 }
-fn place_elem_get<'a>(
+fn place_elem_set<'a>(
     place_elem: &PlaceElem<'a>,
     curr_type: Ty<'a>,
     ctx: TyCtxt<'a>,
 ) -> Vec<CILOp> {
     match place_elem {
-        PlaceElem::Deref => deref_op(curr_type),
         PlaceElem::Field(index, field_type) => {
             let field_name = field_name(curr_type, index.as_u32());
             let curr_type = crate::r#type::Type::from_ty(curr_type, ctx);
@@ -100,9 +103,9 @@ fn place_elem_get<'a>(
                 crate::r#type::Type::from_ty(*field_type, ctx),
                 field_name,
             );
-            vec![CILOp::LDField(field_desc)]
+            vec![CILOp::STField(field_desc)]
         }
-        _ => todo!("Can't handle porojection {place_elem:?} in get"),
+        _ => todo!("Can't handle porojection {place_elem:?} in set"),
     }
 }
 fn field_name(ty: Ty, idx: u32) -> crate::IString {
@@ -128,7 +131,7 @@ fn place_elem_body<'ctx>(
             if body_ty_is_by_adress(&pointed) {
                 (pointed, vec![])
             } else {
-                (pointed, deref_op(curr_type))
+                (pointed, deref_op(curr_type,tyctx))
             }
         }
         PlaceElem::Field(index, field_type) => {
@@ -153,16 +156,48 @@ fn place_elem_body<'ctx>(
         _ => todo!("Can't handle porojection {place_elem:?} in body"),
     }
 }
-fn deref_op(curr_type: Ty) -> Vec<CILOp> {
+fn deref_op<'ctx>(curr_type: Ty<'ctx>,tyctx: TyCtxt<'ctx>) -> Vec<CILOp> {
     match curr_type.kind() {
         TyKind::Int(int_ty) => match int_ty {
             IntTy::I8 => vec![CILOp::LDIndI8],
             _ => todo!("TODO: can't deref int type {int_ty:?} yet"),
         },
+        TyKind::Adt(_,_)=>{
+            let curr_type = if let crate::r#type::Type::DotnetType(dotnet_type) = crate::r#type::Type::from_ty(curr_type,tyctx) {
+                dotnet_type
+            } else {
+                panic!();
+            };
+            vec![CILOp::LdObj(curr_type)]
+        }
         _ => todo!("TODO: can't deref type {curr_type:?} yet"),
     }
 }
 /// Returns the ops for getting the value of place.
+pub fn place_get<'a>(
+    place: &Place<'a>,
+    ctx: TyCtxt<'a>,
+    method: &rustc_middle::mir::Body<'a>,
+) -> Vec<CILOp> {
+    let mut ops = Vec::with_capacity(place.projection.len());
+    if place.projection.is_empty() {
+        ops.push(local_get(place.local.as_usize(), method));
+        return ops;
+    } else {
+        let (op, mut ty) = local_body(place.local.as_usize(), method);
+        ops.push(op);
+        let (head, body) = slice_head(place.projection);
+        for elem in body {
+            println!("elem:{elem:?} ty:{ty:?}");
+            let (curr_ty, curr_ops) = place_elem_body(elem, ty, ctx);
+            ty = curr_ty;
+            ops.extend(curr_ops);
+        }
+        ops.extend(place_elem_get(head, ty, ctx));
+        ops
+    }
+}
+/// Returns the ops for getting the value of place.
 pub fn place_adress<'a>(
     place: &Place<'a>,
     ctx: TyCtxt<'a>,
@@ -192,6 +227,15 @@ pub(crate) fn place_set<'a>(
     } else {
         let (op, mut ty) = local_body(place.local.as_usize(), method);
         ops.push(op);
-        todo!();
+        let (head, body) = slice_head(place.projection);
+        for elem in body {
+            println!("elem:{elem:?} ty:{ty:?}");
+            let (curr_ty, curr_ops) = place_elem_body(elem, ty, ctx);
+            ty = curr_ty;
+            ops.extend(curr_ops);
+        }
+        ops.extend(value_calc);
+        ops.extend(place_elem_set(head, ty, ctx));
+        ops
     }
 }
diff --git a/src/statement.rs b/src/statement.rs
diff --git a/test/structs.rs b/test/structs.rs

Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ impl Assembly {`
`62`	`62`	`last_bb_id += 1;`
`63`	`63`	`for statement in &block_data.statements {`
`64`	`64`	`ops.extend(crate::statement::handle_statement(statement, mir, tcx, mir));`
`65`		`- ops.push(CILOp::Comment(format!("{statement:?}").into()));`
	`65`	`+ // ops.push(CILOp::Comment(format!("{statement:?}").into()));`
`66`	`66`	`//println!("ops:{ops:?}\n\n");`
`67`	`67`	`}`
`68`	`68`	`match &block_data.terminator {`
`@@ -92,6 +92,10 @@ impl Assembly {`
`92`	`92`	`self.types.insert(type_def);`
`93`	`93`	`}`
`94`	`94`	`}`
	`95`	`+ pub fn opt(&mut self){`
	`96`	`+ let functions:HashSet<_> = self.functions.iter().map(\|method\|{let mut method = method.clone();crate::opt::opt_method(&mut method);method}).collect();`
	`97`	`+ self.functions = functions;`
	`98`	`+ }`
`95`	`99`	`pub fn add_typedef<'ctx>(&mut self, type_def: TypeDef) {`
`96`	`100`	`self.types.insert(type_def);`
`97`	`101`	`}`
Original file line number	Diff line number	Diff line change
`@@ -40,6 +40,9 @@ impl Method {`
`40`	`40`	`.iter()`
`41`	`41`	`.any(\|attr\| *attr == Attribute::EntryPoint)`
`42`	`42`	`}`
	`43`	`+ pub fn ops_mut(&mut self)->&mut Vec<CILOp>{`
	`44`	`+ &mut self.ops`
	`45`	`+ }`
`43`	`46`	`pub fn access(&self) -> AccessModifer {`
`44`	`47`	`self.access`
`45`	`48`	`}`
`@@ -61,4 +64,7 @@ impl Method {`
`61`	`64`	`pub fn add_attribute(&mut self, attr: Attribute) {`
`62`	`65`	`self.attributes.push(attr);`
`63`	`66`	`}`
	`67`	`+ pub fn set_locals(&mut self,locals: impl Into<Vec<Type>>){`
	`68`	`+ self.locals = locals.into();`
	`69`	`+ }`
`64`	`70`	`}`