Subregister access encoding (#114)

Now subregisters are accessed using SUBPIECE instructions. This should fix the issue that we could not assign subregister accesses to the corresponding base register in some cases.

cwe_checker_rs/src/intermediate_representation/term.rs

-use super::{ByteSize, Expression, Variable};
+use super::{ByteSize, CastOpType, Expression, Variable};
 use crate::prelude::*;
 use crate::utils::log::LogMessage;
 use std::collections::HashSet;
@@ -68,6 +68,36 @@ pub enum Def {
     Assign { var: Variable, value: Expression },
 }
 
+impl Term<Def> {
+    /// This function checks whether the instruction
+    /// is a zero extension of the overwritten sub register of the previous instruction.
+    /// If so, returns its TID
+    pub fn check_for_zero_extension(
+        &self,
+        output_name: String,
+        output_sub_register: String,
+    ) -> Option<Tid> {
+        match &self.term {
+            Def::Assign { var, value } if output_name == var.name => match value {
+                Expression::Cast { op, arg, .. } => {
+                    let argument: &Expression = arg;
+                    match op {
+                        CastOpType::IntZExt => match argument {
+                            Expression::Var(var) if var.name == output_sub_register => {
+                                Some(self.tid.clone())
+                            }
+                            _ => None,
+                        },
+                        _ => None,
+                    }
+                }
+                _ => None,
+            },
+            _ => None,
+        }
+    }
+}
+
 /// A `Jmp` instruction affects the control flow of a program, i.e. it may change the instruction pointer.
 /// With the exception of `CallOther`, it has no other side effects.
 ///
@@ -442,6 +472,8 @@ impl Project {
 
 #[cfg(test)]
 mod tests {
+    use crate::intermediate_representation::BinOpType;
+
     use super::*;
 
     impl Blk {
@@ -539,4 +571,88 @@ mod tests {
             .is_err());
         assert_eq!(jmp_term.term, Jmp::Branch(Tid::new("dummy_blk")));
     }
+
+    #[test]
+    fn zero_extension_check() {
+        let eax_variable = Expression::Var(Variable {
+            name: String::from("EAX"),
+            size: ByteSize::new(4),
+            is_temp: false,
+        });
+        let int_sub_expr = Expression::BinOp {
+            op: BinOpType::IntSub,
+            lhs: Box::new(Expression::Var(Variable {
+                name: String::from("EAX"),
+                size: ByteSize::new(4),
+                is_temp: false,
+            })),
+            rhs: Box::new(Expression::Var(Variable {
+                name: String::from("ECX"),
+                size: ByteSize::new(4),
+                is_temp: false,
+            })),
+        };
+
+        let zero_extend_def = Term {
+            tid: Tid::new("zero_tid"),
+            term: Def::Assign {
+                var: Variable {
+                    name: String::from("RAX"),
+                    size: ByteSize::new(8),
+                    is_temp: false,
+                },
+                value: Expression::Cast {
+                    op: CastOpType::IntZExt,
+                    size: ByteSize::new(8),
+                    arg: Box::new(eax_variable.clone()),
+                },
+            },
+        };
+        // An expression that is a zero extension but does not directly contain a variable
+        let zero_extend_but_no_var_def = Term {
+            tid: Tid::new("zero_tid"),
+            term: Def::Assign {
+                var: Variable {
+                    name: String::from("RAX"),
+                    size: ByteSize::new(8),
+                    is_temp: false,
+                },
+                value: Expression::Cast {
+                    op: CastOpType::IntZExt,
+                    size: ByteSize::new(8),
+                    arg: Box::new(int_sub_expr.clone()),
+                },
+            },
+        };
+
+        let non_zero_extend_def = Term {
+            tid: Tid::new("zero_tid"),
+            term: Def::Assign {
+                var: Variable {
+                    name: String::from("RAX"),
+                    size: ByteSize::new(8),
+                    is_temp: false,
+                },
+                value: Expression::Cast {
+                    op: CastOpType::IntSExt,
+                    size: ByteSize::new(8),
+                    arg: Box::new(eax_variable.clone()),
+                },
+            },
+        };
+
+        assert_eq!(
+            zero_extend_def.check_for_zero_extension(String::from("RAX"), String::from("EAX")),
+            Some(Tid::new("zero_tid"))
+        );
+        assert_eq!(
+            zero_extend_but_no_var_def
+                .check_for_zero_extension(String::from("RAX"), String::from("EAX")),
+            None
+        );
+        assert_eq!(
+            non_zero_extend_def.check_for_zero_extension(String::from("RAX"), String::from("EAX")),
+            None
+        );
+    }
 }