Extend m_call to be able to filter by name

Author: AmrDeveloper

docs/matchers/call.md

@@ -2,5 +2,5 @@
 
 |  Function   | Parameters  |   Return    |                                 Description                                 |
 | :---------: | :---------: | :---------: | :-------------------------------------------------------------------------: |
-|   m_call    |             | InstMatcher |               Build Inst Matcher that match call instruction                |
+|   m_call    | (n : Text?) | InstMatcher |     Build Inst Matcher that match call instruction   with optional name     |
 | m_intrinsic | (n : Text?) | InstMatcher | Build Inst Matcher that match intrinsic call instruction with optional name |

src/functions/matchers/call.rs

@@ -19,21 +19,32 @@ pub fn register_call_inst_matchers_functions(map: &mut HashMap<&'static str, Sta
 
 #[inline(always)]
 pub fn register_call_inst_matchers_function_signatures(map: &mut HashMap<&'static str, Signature>) {
-    map.insert("m_call", Signature::with_return(Box::new(InstMatcherType)));
+    map.insert(
+        "m_call",
+        Signature::with_return(Box::new(InstMatcherType))
+            .add_parameter(Box::new(OptionType::new(Some(Box::new(TextType))))),
+    );
+
     map.insert(
         "m_intrinsic",
         Signature::with_return(Box::new(InstMatcherType))
             .add_parameter(Box::new(OptionType::new(Some(Box::new(TextType))))),
     );
 }
 
-fn match_call_inst(_values: &[Box<dyn Value>]) -> Box<dyn Value> {
-    let matcher = Box::new(CallInstMatcher::create_call());
+fn match_call_inst(values: &[Box<dyn Value>]) -> Box<dyn Value> {
+    let function_name = if values.is_empty() {
+        None
+    } else {
+        values[0].as_text()
+    };
+
+    let matcher = Box::new(CallInstMatcher::create_call(function_name));
     Box::new(InstMatcherValue { matcher })
 }
 
 fn match_intrinsic_inst(values: &[Box<dyn Value>]) -> Box<dyn Value> {
-    let intrinsic_name: Option<String> = if values.is_empty() {
+    let intrinsic_name = if values.is_empty() {
         None
     } else {
         values[0].as_text()

src/matchers/call.rs

@@ -10,18 +10,33 @@ use inkwell::llvm_sys::LLVMOpcode;
 use super::Matcher;
 
 #[derive(Clone)]
-pub struct CallInstMatcher;
+pub struct CallInstMatcher {
+    pub name: Option<String>,
+}
 
 impl CallInstMatcher {
-    pub fn create_call() -> Self {
-        CallInstMatcher
+    pub fn create_call(name: Option<String>) -> Self {
+        CallInstMatcher { name }
     }
 }
 
 impl Matcher<LLVMValueRef> for CallInstMatcher {
     #[allow(clippy::not_unsafe_ptr_arg_deref)]
     fn is_match(&self, instruction: &LLVMValueRef) -> bool {
-        unsafe { LLVMGetInstructionOpcode(*instruction) == LLVMOpcode::LLVMCall }
+        unsafe {
+            if LLVMGetInstructionOpcode(*instruction) == LLVMOpcode::LLVMCall {
+                if let Some(expected_name) = &self.name {
+                    let called_value = LLVMGetCalledValue(*instruction);
+                    let mut len: usize = 0;
+                    let name_ptr = LLVMGetValueName2(called_value, &mut len);
+                    let name_slice = std::slice::from_raw_parts(name_ptr as *const u8, len);
+                    let name = std::str::from_utf8_unchecked(name_slice).to_string();
+                    return name.eq(expected_name);
+                }
+                return true;
+            }
+        }
+        false
     }
 }