Refactor calling convention Rust API to allow default implementations

Also implements the new calling convention APIs in Rust

Author: D0ntPanic

arch/riscv/src/lib.rs

@@ -14,7 +14,9 @@ use binaryninja::{
         UnusedRegisterStack,
     },
     binary_view::{BinaryView, BinaryViewType},
-    calling_convention::{register_calling_convention, CallingConvention, ConventionBuilder},
+    calling_convention::{
+        register_calling_convention, CallingConvention, ConventionBuilder, CoreCallingConvention,
+    },
     disassembly::{InstructionTextToken, InstructionTextTokenKind},
     function::Function,
     function_recognizer::FunctionRecognizer,
@@ -2755,12 +2757,22 @@ impl<D: RiscVDisassembler> AsRef<CoreRelocationHandler> for RiscVELFRelocationHa
 }
 
 struct RiscVCC<D: RiscVDisassembler> {
+    core: CoreCallingConvention,
     _dis: PhantomData<D>,
 }
 
 impl<D: RiscVDisassembler> RiscVCC<D> {
-    fn new() -> Self {
-        RiscVCC { _dis: PhantomData }
+    fn new(core: CoreCallingConvention) -> Self {
+        RiscVCC {
+            core,
+            _dis: PhantomData,
+        }
+    }
+}
+
+impl<D: RiscVDisassembler> AsRef<CoreCallingConvention> for RiscVCC<D> {
+    fn as_ref(&self) -> &CoreCallingConvention {
+        &self.core
     }
 }
 
@@ -3087,17 +3099,13 @@ pub extern "C" fn CorePluginInit() -> bool {
     arch32.register_function_recognizer(RiscVELFPLTRecognizer);
     arch64.register_function_recognizer(RiscVELFPLTRecognizer);
 
-    let cc32 = register_calling_convention(
-        arch32,
-        "default",
-        RiscVCC::<RiscVIMACDisassembler<Rv32GRegs>>::new(),
-    );
+    let cc32 = register_calling_convention(arch32, "default", |core| {
+        RiscVCC::<RiscVIMACDisassembler<Rv32GRegs>>::new(core)
+    });
     arch32.set_default_calling_convention(&cc32);
-    let cc64 = register_calling_convention(
-        arch64,
-        "default",
-        RiscVCC::<RiscVIMACDisassembler<Rv64GRegs>>::new(),
-    );
+    let cc64 = register_calling_convention(arch64, "default", |core| {
+        RiscVCC::<RiscVIMACDisassembler<Rv64GRegs>>::new(core)
+    });
     arch64.set_default_calling_convention(&cc64);
 
     if let Some(bvt) = BinaryViewType::by_name("ELF") {

plugins/pdb-ng/src/type_parser.rs

@@ -2421,7 +2421,7 @@ impl<'a, S: Source<'a> + 'a> PDBParserInstance<'a, S> {
         // that the calling convention can determine this by default
         let default_return_location = convention
             .contents
-            .return_value_location(self.bv, return_value.clone());
+            .return_value_location(Some(self.bv), &return_value);
         if default_return_location.indirect {
             None
         } else {

rust/src/architecture.rs

@@ -26,6 +26,7 @@ use crate::{
     calling_convention::CoreCallingConvention,
     data_buffer::DataBuffer,
     disassembly::InstructionTextToken,
+    ffi::INVALID_REGISTER,
     function::Function,
     platform::Platform,
     rc::*,
@@ -665,6 +666,13 @@ impl CoreArchitecture {
     pub fn name(&self) -> String {
         unsafe { BnString::into_string(BNGetArchitectureName(self.handle)) }
     }
+
+    pub fn register_stack_for_register(&self, reg: CoreRegister) -> Option<CoreRegisterStack> {
+        match unsafe { BNGetArchitectureRegisterStackForRegister(self.handle, reg.id().0) } {
+            INVALID_REGISTER => None,
+            reg_stack => CoreRegisterStack::new(*self, RegisterStackId::from(reg_stack)),
+        }
+    }
 }
 
 unsafe impl Send for CoreArchitecture {}
@@ -967,14 +975,14 @@ impl Architecture for CoreArchitecture {
 
     fn stack_pointer_reg(&self) -> Option<CoreRegister> {
         match unsafe { BNGetArchitectureStackPointerRegister(self.handle) } {
-            0xffff_ffff => None,
+            INVALID_REGISTER => None,
             reg => Some(CoreRegister::new(*self, reg.into())?),
         }
     }
 
     fn link_reg(&self) -> Option<CoreRegister> {
         match unsafe { BNGetArchitectureLinkRegister(self.handle) } {
-            0xffff_ffff => None,
+            INVALID_REGISTER => None,
             reg => Some(CoreRegister::new(*self, reg.into())?),
         }
     }
@@ -1257,7 +1265,7 @@ pub trait ArchitectureExt: Architecture {
         let name = name.to_cstr();
 
         match unsafe { BNGetArchitectureRegisterByName(self.as_ref().handle, name.as_ptr()) } {
-            0xffff_ffff => None,
+            INVALID_REGISTER => None,
             reg => self.register_from_id(reg.into()),
         }
     }
@@ -2130,7 +2138,7 @@ where
         if let Some(reg) = custom_arch.stack_pointer_reg() {
             reg.id().0
         } else {
-            0xffff_ffff
+            INVALID_REGISTER
         }
     }
 
@@ -2143,7 +2151,7 @@ where
         if let Some(reg) = custom_arch.link_reg() {
             reg.id().0
         } else {
-            0xffff_ffff
+            INVALID_REGISTER
         }
     }
 
@@ -2198,7 +2206,7 @@ where
                 result.firstTopRelativeReg = reg.id().0;
                 result.topRelativeCount = count as u32;
             } else {
-                result.firstTopRelativeReg = 0xffff_ffff;
+                result.firstTopRelativeReg = INVALID_REGISTER;
                 result.topRelativeCount = 0;
             }