feat: Implement noneOf inst combine matcher

Author: AmrDeveloper

docs/InstructionMatcher.md

@@ -163,14 +163,15 @@ Instructions Matchers are functions that build a instruction matcher to match ag
 
 ### Combine Instructions Matchers functions
 
-|       Function       |              Parameters              |   Return    |                                   Description                                    |
-| :------------------: | :----------------------------------: | :---------: | :------------------------------------------------------------------------------: |
-| m_inst_combine_oneof |        (inst: ...InstMatcher)        | InstMatcher | Build Inst Matcher from list of matchers that return true if one of them matches |
-| m_inst_combine_allof |        (inst: ...InstMatcher)        | InstMatcher | Build Inst Matcher from list of matchers that return true if all of them matches |
-|  m_inst_combine_and  | (lhs: InstMatcher, rhs: InstMatcher) | InstMatcher |     Build Inst Matcher two matchers that return true if (lhs and rhs) = true     |
-|  m_inst_combine_or   | (lhs: InstMatcher, rhs: InstMatcher) | InstMatcher |     Build Inst Matcher two matchers that return true if (lhs or rhs) = true      |
-|  m_inst_combine_xor  | (lhs: InstMatcher, rhs: InstMatcher) | InstMatcher |     Build Inst Matcher two matchers that return true if (lhs xor rhs )= true     |
-|  m_inst_combine_not  |          (rhs: InstMatcher)          | InstMatcher |        Build Inst Matcher two matchers that return true if (!rhs) = true         |
+|       Function        |              Parameters              |   Return    |                                      Description                                       |
+| :-------------------: | :----------------------------------: | :---------: | :------------------------------------------------------------------------------------: |
+| m_inst_combine_oneof  |        (inst: ...InstMatcher)        | InstMatcher |    Build Inst Matcher from list of matchers that return true if one of them matches    |
+| m_inst_combine_allof  |        (inst: ...InstMatcher)        | InstMatcher |    Build Inst Matcher from list of matchers that return true if all of them matches    |
+| m_inst_combine_noneof |        (inst: ...InstMatcher)        | InstMatcher | Build Inst Matcher from list of matchers that return true if all of them don't matches |
+|  m_inst_combine_and   | (lhs: InstMatcher, rhs: InstMatcher) | InstMatcher |        Build Inst Matcher two matchers that return true if (lhs and rhs) = true        |
+|   m_inst_combine_or   | (lhs: InstMatcher, rhs: InstMatcher) | InstMatcher |        Build Inst Matcher two matchers that return true if (lhs or rhs) = true         |
+|  m_inst_combine_xor   | (lhs: InstMatcher, rhs: InstMatcher) | InstMatcher |        Build Inst Matcher two matchers that return true if (lhs xor rhs )= true        |
+|  m_inst_combine_not   |          (rhs: InstMatcher)          | InstMatcher |           Build Inst Matcher two matchers that return true if (!rhs) = true            |
 
 ### Combine Instructions Matchers Operators
 

src/functions/matchers/combine.rs

@@ -17,6 +17,7 @@ use crate::matchers::InstMatcher;
 pub fn register_combine_matchers_function(map: &mut HashMap<&'static str, StandardFunction>) {
     map.insert("m_inst_combine_oneof", match_oneof_combine_inst);
     map.insert("m_inst_combine_allof", match_allof_combine_inst);
+    map.insert("m_inst_combine_noneof", match_noneof_combine_inst);
 
     map.insert("m_inst_combine_and", match_and_combine_inst);
     map.insert("m_inst_combine_or", match_or_combine_inst);
@@ -53,6 +54,19 @@ pub fn register_combine_matchers_function_signatures(map: &mut HashMap<&'static
         },
     );
 
+    map.insert(
+        "m_inst_combine_noneof",
+        Signature {
+            parameters: vec![
+                Box::new(InstMatcherType),
+                Box::new(VarargsType {
+                    base: Box::new(InstMatcherType),
+                }),
+            ],
+            return_type: Box::new(InstMatcherType),
+        },
+    );
+
     map.insert(
         "m_inst_combine_and",
         Signature {
@@ -108,6 +122,17 @@ fn match_allof_combine_inst(values: &[Box<dyn Value>]) -> Box<dyn Value> {
     Box::new(InstMatcherValue { matcher })
 }
 
+fn match_noneof_combine_inst(values: &[Box<dyn Value>]) -> Box<dyn Value> {
+    let mut matchers: Vec<Box<dyn InstMatcher>> = vec![];
+    for value in values.iter() {
+        if let Some(inst_matcher) = value.as_any().downcast_ref::<InstMatcherValue>() {
+            matchers.push(inst_matcher.matcher.to_owned());
+        }
+    }
+    let matcher = Box::new(CombineInstMatcher::create_none_of(matchers));
+    Box::new(InstMatcherValue { matcher })
+}
+
 fn match_and_combine_inst(values: &[Box<dyn Value>]) -> Box<dyn Value> {
     let (lhs, rhs) = binary_matchers_sides(values);
     let matcher = Box::new(CombineBinaryInstMatcher::create_and(lhs, rhs));

src/matchers/combine.rs

@@ -2,10 +2,12 @@ use inkwell::llvm_sys::prelude::LLVMValueRef;
 
 use super::InstMatcher;
 
+#[allow(clippy::enum_variant_names)]
 #[derive(PartialEq, Clone)]
 enum CombineMatcherKind {
     OneOf,
     AllOf,
+    NoneOf,
 }
 
 #[derive(Clone)]
@@ -28,21 +30,34 @@ impl CombineInstMatcher {
             matcher_kind: CombineMatcherKind::AllOf,
         }
     }
+
+    pub fn create_none_of(matchers: Vec<Box<dyn InstMatcher>>) -> Self {
+        CombineInstMatcher {
+            matchers,
+            matcher_kind: CombineMatcherKind::AllOf,
+        }
+    }
 }
 
 impl InstMatcher for CombineInstMatcher {
     fn is_match(&self, instruction: LLVMValueRef) -> bool {
         let mut matches_count = 0;
+        let matcher_kind = &self.matcher_kind;
         for matcher in self.matchers.iter() {
             let is_matches = matcher.is_match(instruction);
 
             // If kind is `oneOf` and one if matches, return true
-            if is_matches && self.matcher_kind == CombineMatcherKind::OneOf {
+            if is_matches && CombineMatcherKind::OneOf.eq(matcher_kind) {
                 return true;
             }
 
             // If kind is `allOf` and one is not matches, return false
-            if !is_matches && self.matcher_kind == CombineMatcherKind::AllOf {
+            if !is_matches && CombineMatcherKind::AllOf.eq(matcher_kind) {
+                return false;
+            }
+
+            // If kind is `noneOf` and one is matches, return false
+            if is_matches && CombineMatcherKind::NoneOf.eq(matcher_kind) {
                 return false;
             }
 
@@ -54,6 +69,7 @@ impl InstMatcher for CombineInstMatcher {
         match self.matcher_kind {
             CombineMatcherKind::OneOf => matches_count > 1,
             CombineMatcherKind::AllOf => matches_count == self.matchers.len(),
+            CombineMatcherKind::NoneOf => matches_count == 0,
         }
     }
 }