Removed few unused IR nodes

Author: FractalFir

cilly/src/bin/linker/main.rs

@@ -339,15 +339,14 @@ fn main() {
                     MethodKind::Constructor,
                     vec![].into(),
                 );
+                let arg0 = cilly::cil_node::CILNode::V2(asm.alloc_node(CILNode::LdArg(0)));
                 MethodImpl::MethodBody {
                     blocks: vec![cilly::BasicBlock::from_v1(
                         &cilly::basic_block::BasicBlock::new(
                             vec![cilly::cil_root::CILRoot::Throw(
                                 cilly::cil_node::CILNode::NewObj(Box::new(
                                     cilly::cil_node::CallOpArgs {
-                                        args: Box::new([conv_usize!(
-                                            cilly::cil_node::CILNode::LDArg(0)
-                                        )]),
+                                        args: Box::new([conv_usize!(arg0)]),
                                         site: asm.alloc_methodref(exception_ctor),
                                         is_pure: IsPure::NOT,
                                     },

cilly/src/cil_node.rs

@@ -4,7 +4,6 @@ use crate::cilnode::MethodKind;
 use crate::v2::method::LocalDef;
 
 use crate::FieldDesc;
-use crate::IntoAsmIndex;
 use crate::{
     call,
     cil_root::CILRoot,
@@ -27,12 +26,7 @@ pub enum CILNode {
     V2(Interned<crate::v2::CILNode>),
     /// Loads the value of local variable number `n`.
     LDLoc(u32),
-    /// Loads the value of argument number `n`.
-    LDArg(u32),
-    /// Loads the address of local variable number `n`.
-    LDLocA(u32),
-    /// Loads the address of argument number `n`.
-    LDArgA(u32),
+
     /// A black box that prevents the bulit-in optimization engine from doing any optimizations.
     BlackBox(Box<Self>),
     /// Loads the value of a static variable described by the descripstor.
@@ -136,7 +130,7 @@ pub enum CILNode {
     CallVirt(Box<CallOpArgs>),
     LdcF64(HashableF64),
     LdcF32(HashableF32),
- 
+
     ConvU8(Box<Self>),
     ConvU16(Box<Self>),
     ConvU32(Box<Self>),
@@ -160,8 +154,7 @@ pub enum CILNode {
     Gt(Box<Self>, Box<Self>),
     /// Compares two operands, returning true if lhs < rhs. Unsigned for intigers, unordered(in respect to NaNs) for floats.
     GtUn(Box<Self>, Box<Self>),
-    LoadAddresOfTMPLocal,
-    LoadTMPLocal,
+
     LDFtn(Interned<MethodRef>),
     LDTypeToken(Box<Type>),
     NewObj(Box<CallOpArgs>),
@@ -374,7 +367,7 @@ impl CILNode {
         destination_addr: Self,
         val_desc: Interned<FieldDesc>,
         flag_desc: Interned<FieldDesc>,
-    ) -> [CILRoot;2] {
+    ) -> [CILRoot; 2] {
         // Set the value of the result.
         let set_val = CILRoot::SetField {
             addr: Box::new(destination_addr.clone()),
@@ -385,16 +378,18 @@ impl CILNode {
         let val = CILNode::LDField {
             addr: Box::new(destination_addr.clone()),
             field: val_desc,
-        }
-        ;
+        };
 
         let cmp = CILNode::Eq(val.into(), expected.into());
 
-        [set_val,CILRoot::SetField {
-            addr: Box::new(destination_addr.clone()),
-            value: Box::new(cmp),
-            desc: flag_desc,
-        }]
+        [
+            set_val,
+            CILRoot::SetField {
+                addr: Box::new(destination_addr.clone()),
+                value: Box::new(cmp),
+                desc: flag_desc,
+            },
+        ]
     }
     #[track_caller]
     pub fn cast_ptr(self, new_ptr: Type) -> Self {
@@ -427,11 +422,8 @@ impl CILNode {
             Self::GetException=>(),
             Self::LocAlloc{..}=>(),
             Self::LocAllocAligned {..}=>(),
-            Self::CastPtr { val, new_ptr: _ }=>val.allocate_tmps(curr_loc, locals),      
-            Self::LDLoc(_) |
-            Self::LDArg(_) |
-            Self::LDLocA(_)|
-            Self::LDArgA(_) => (),
+            Self::CastPtr { val, new_ptr: _ }=>val.allocate_tmps(curr_loc, locals),
+            Self::LDLoc(_) => (),
             Self::BlackBox(inner) => inner.allocate_tmps(curr_loc, locals),
             Self::LDIndI8 { ptr }|
             Self::LDIndBool { ptr }|
@@ -494,10 +486,6 @@ impl CILNode {
             //Self::Volatile(_) => todo!(),
             Self::Neg(val) |
             Self::Not(val) =>val.allocate_tmps(curr_loc, locals),
-            
-          
-            Self::LoadAddresOfTMPLocal => *self = Self::LDLocA(curr_loc.expect("Temporary local referenced when none present")),
-            Self::LoadTMPLocal =>*self = Self::LDLoc(curr_loc.expect("Temporary local referenced when none present")),
             Self::LDFtn(_) => (),
             Self::LDTypeToken(_) =>(),
 

cilly/src/cil_root.rs

@@ -88,9 +88,7 @@ pub enum CILRoot {
         value: Box<CILNode>,
         desc: Interned<FieldDesc>,
     },
-    SetTMPLocal {
-        value: CILNode,
-    },
+
     CpBlk {
         dst: Box<CILNode>,
         src: Box<CILNode>,
@@ -340,13 +338,6 @@ impl CILRoot {
                     .for_each(|arg| arg.allocate_tmps(curr_loc, locals));
             }
 
-            Self::SetTMPLocal { value } => {
-                value.allocate_tmps(curr_loc, locals);
-                *self = Self::STLoc {
-                    local: curr_loc.expect("Referenced a tmp local when none present!"),
-                    tree: value.clone(),
-                };
-            }
             Self::SetStaticField { descr: _, value } => value.allocate_tmps(curr_loc, locals),
             Self::JumpingPad { .. } => (),
         };

cilly/src/utilis.rs

@@ -239,15 +239,16 @@ pub fn get_environ(asm: &mut Assembly) -> Interned<MethodRef> {
         MethodKind::Instance,
         vec![].into(),
     );
-    let key = call!(asm.alloc_methodref(get_key), [CILNode::LDLocA(keyval)]);
+    let kv = CILNode::V2(asm.alloc_node(crate::v2::CILNode::LdLocA(keyval)));
+    let key = call!(asm.alloc_methodref(get_key), [kv.clone()]);
     let mref = MethodRef::new(
         keyval_tpe,
         asm.alloc_string("get_Value"),
         sig,
         MethodKind::Instance,
         vec![].into(),
     );
-    let value = call!(asm.alloc_methodref(mref), [CILNode::LDLocA(keyval)]);
+    let value = call!(asm.alloc_methodref(mref), [kv]);
     let concat = MethodRef::new(
         ClassRef::string(asm),
         asm.alloc_string("Concat"),

cilly/src/v2/cilnode.rs

@@ -351,10 +351,8 @@ impl CILNode {
     pub fn from_v1(v1: &V1Node, asm: &mut Assembly) -> Self {
         match v1 {
             // Varaible access
-            V1Node::LDArg(arg) => CILNode::LdArg(*arg),
             V1Node::LDLoc(arg) => CILNode::LdLoc(*arg),
-            V1Node::LDArgA(arg) => CILNode::LdArgA(*arg),
-            V1Node::LDLocA(arg) => CILNode::LdLocA(*arg),
+
             // Ptr deref
             V1Node::LDIndBool { ptr } => {
                 let ptr = Self::from_v1(ptr, asm);

src/assembly.rs

@@ -217,13 +217,13 @@ pub fn add_fn<'tcx, 'asm, 'a: 'asm>(
                 continue;
             }
             let arg_field = field_descrptor(repacked_ty, arg_id.try_into().unwrap(), ctx);
-
+            let arg = spread_arg.as_u32() - 1 + u32::try_from(arg_id).unwrap();
+            let arg = CILNode::V2(ctx.alloc_node(cilly::v2::CILNode::LdArg(arg)));
+            let repacked = CILNode::V2(ctx.alloc_node(cilly::v2::CILNode::LdLocA(repacked)));
             repack_cil.push(
                 CILRoot::SetField {
-                    addr: Box::new(CILNode::LDLocA(repacked)),
-                    value: Box::new(CILNode::LDArg(
-                        spread_arg.as_u32() - 1 + u32::try_from(arg_id).unwrap(),
-                    )),
+                    addr: Box::new(repacked),
+                    value: Box::new(arg),
                     desc: (arg_field),
                 }
                 .into(),