feat: Implement m_operands_number Matcher

Author: AmrDeveloper

docs/InstructionMatcher.md

@@ -4,20 +4,21 @@ Instructions Matchers are functions that build a instruction matcher to match ag
 
 ### General Instructions Matchers functions
 
-|    Function     |              Parameters              |   Return    |                               Description                                |
-| :-------------: | :----------------------------------: | :---------: | :----------------------------------------------------------------------: |
-|     m_inst      |   (i: Instruction, m: InstMatcher)   |    Bool     |               Check if instruction is matched with Matcher               |
-| m_extract_value | (m : InstMatcher?, indices: ...Int?) | InstMatcher |          Build Inst Matcher that match ExtractValue Instruction          |
-|   m_inst_type   |          (m : TypeMatcher?)          | InstMatcher |         Build Inst Matcher that match instruction returned type          |
-|   m_any_inst    |                  ()                  | InstMatcher |              Build Inst Matcher that match any Instruction               |
-|    m_poison     |                  ()                  | InstMatcher |                Build Inst Matcher that match poison value                |
-|     m_label     |             (n : Text?)              | InstMatcher |          Build Inst Matcher that match Label with optional name          |
-|   m_argument    |    (n : Text?, m : TypeMatcher?)     | InstMatcher | Build Inst Matcher that match Argument value with optional name and type |
-|    m_return     |          (m : InstMatcher?)          | InstMatcher |             Build Inst Matcher that match Return Instruction             |
-|  m_unreachable  |                  ()                  | InstMatcher |          Build Inst Matcher that match unreachable Instruction           |
-|    m_unused     |          (m : InstMatcher?)          | InstMatcher |       Build Inst Matcher that match instruction that unused at all       |
-|  m_has_one_use  |          (m : InstMatcher?)          | InstMatcher |    Build Inst Matcher that match instruction that has exactly on use     |
-|  m_has_n_uses   |      (m : InstMatcher?, n: Int)      | InstMatcher |   Build Inst Matcher that match instruction that has n number of uses    |
+|     Function      |              Parameters              |   Return    |                               Description                                |
+| :---------------: | :----------------------------------: | :---------: | :----------------------------------------------------------------------: |
+|      m_inst       |   (i: Instruction, m: InstMatcher)   |    Bool     |               Check if instruction is matched with Matcher               |
+|  m_extract_value  | (m : InstMatcher?, indices: ...Int?) | InstMatcher |          Build Inst Matcher that match ExtractValue Instruction          |
+|    m_inst_type    |          (m : TypeMatcher?)          | InstMatcher |         Build Inst Matcher that match instruction returned type          |
+|    m_any_inst     |                  ()                  | InstMatcher |              Build Inst Matcher that match any Instruction               |
+|     m_poison      |                  ()                  | InstMatcher |                Build Inst Matcher that match poison value                |
+|      m_label      |             (n : Text?)              | InstMatcher |          Build Inst Matcher that match Label with optional name          |
+|    m_argument     |    (n : Text?, m : TypeMatcher?)     | InstMatcher | Build Inst Matcher that match Argument value with optional name and type |
+|     m_return      |          (m : InstMatcher?)          | InstMatcher |             Build Inst Matcher that match Return Instruction             |
+|   m_unreachable   |                  ()                  | InstMatcher |          Build Inst Matcher that match unreachable Instruction           |
+|     m_unused      |          (m : InstMatcher?)          | InstMatcher |       Build Inst Matcher that match instruction that unused at all       |
+|   m_has_one_use   |          (m : InstMatcher?)          | InstMatcher |    Build Inst Matcher that match instruction that has exactly on use     |
+|   m_has_n_uses    |      (m : InstMatcher?, n: Int)      | InstMatcher |   Build Inst Matcher that match instruction that has n number of uses    |
+| m_operands_number |               (n: Int)               | InstMatcher |       Built Inst Matcher that match number of instruction operands       |
 
 ---
 

src/functions/matchers/other.rs

@@ -21,6 +21,7 @@ use crate::matchers::other::ArgumentMatcher;
 use crate::matchers::other::ExtractValueInstMatcher;
 use crate::matchers::other::InstTypeMatcher;
 use crate::matchers::other::LabelInstMatcher;
+use crate::matchers::other::OperandCountMatcher;
 use crate::matchers::other::PoisonValueMatcher;
 use crate::matchers::other::ReturnInstMatcher;
 use crate::matchers::other::UnreachableInstMatcher;
@@ -37,6 +38,7 @@ pub fn register_other_inst_matchers_functions(map: &mut HashMap<&'static str, St
     map.insert("m_argument", match_argument_inst);
     map.insert("m_return", match_return_inst);
     map.insert("m_unreachable", match_unreachable_inst);
+    map.insert("m_operands_number", match_operands_number);
 }
 
 #[inline(always)]
@@ -120,6 +122,11 @@ pub fn register_other_inst_matchers_function_signatures(
             return_type: Box::new(InstMatcherType),
         },
     );
+
+    map.insert(
+        "m_operands_number",
+        Signature::with_return(Box::new(InstMatcherType)).add_parameter(Box::new(IntType)),
+    );
 }
 
 fn match_inst(values: &[Box<dyn Value>]) -> Box<dyn Value> {
@@ -243,7 +250,12 @@ fn match_argument_inst(values: &[Box<dyn Value>]) -> Box<dyn Value> {
 }
 
 fn match_unreachable_inst(_values: &[Box<dyn Value>]) -> Box<dyn Value> {
-    Box::new(InstMatcherValue {
-        matcher: Box::new(UnreachableInstMatcher),
-    })
+    let matcher = Box::new(UnreachableInstMatcher);
+    Box::new(InstMatcherValue { matcher })
+}
+
+fn match_operands_number(values: &[Box<dyn Value>]) -> Box<dyn Value> {
+    let expected_number = values[0].as_int().unwrap() as i32;
+    let matcher = Box::new(OperandCountMatcher::has_n_operands(expected_number));
+    Box::new(InstMatcherValue { matcher })
 }

src/matchers/other.rs

@@ -3,6 +3,7 @@ use std::ffi::CStr;
 use inkwell::llvm_sys::core::LLVMGetIndices;
 use inkwell::llvm_sys::core::LLVMGetInstructionOpcode;
 use inkwell::llvm_sys::core::LLVMGetNumIndices;
+use inkwell::llvm_sys::core::LLVMGetNumOperands;
 use inkwell::llvm_sys::core::LLVMGetOperand;
 use inkwell::llvm_sys::core::LLVMGetValueKind;
 use inkwell::llvm_sys::core::LLVMGetValueName2;
@@ -171,3 +172,22 @@ impl InstMatcher for UnreachableInstMatcher {
         unsafe { LLVMGetInstructionOpcode(instruction) == LLVMOpcode::LLVMUnreachable }
     }
 }
+
+/// Match the number of operands in LLVM instruction
+#[derive(Clone)]
+pub struct OperandCountMatcher {
+    expected_number: i32,
+}
+
+impl OperandCountMatcher {
+    pub fn has_n_operands(expected_number: i32) -> Self {
+        OperandCountMatcher { expected_number }
+    }
+}
+
+impl InstMatcher for OperandCountMatcher {
+    #[allow(clippy::not_unsafe_ptr_arg_deref)]
+    fn is_match(&self, instruction: LLVMValueRef) -> bool {
+        unsafe { LLVMGetNumOperands(instruction) == self.expected_number }
+    }
+}