remove generic arch from calling convention

Author: rbran

arch/riscv/src/lib.rs

@@ -2670,9 +2670,9 @@ impl<D: 'static + RiscVDisassembler + Send + Sync> RiscVCC<D> {
     }
 }
 
-impl<D: 'static + RiscVDisassembler + Send + Sync> CallingConventionBase for RiscVCC<D> {
-    type Arch = RiscVArch<D>;
-
+impl<D: 'static + RiscVDisassembler + Send + Sync> CallingConventionBase<RiscVArch<D>>
+    for RiscVCC<D>
+{
     fn caller_saved_registers(&self) -> Vec<Register<D>> {
         let mut regs = Vec::with_capacity(36);
         let int_reg_count = <D::RegFile as RegFile>::int_reg_count();

plugins/pdb-ng/src/parser.rs

@@ -48,11 +48,11 @@ pub struct PDBParserInstance<'a, S: Source<'a> + 'a> {
     /// Default arch of self.bv
     pub(crate) arch: CoreArchitecture,
     /// Default calling convention for self.arch
-    pub(crate) default_cc: Ref<CallingConvention<CoreArchitecture>>,
+    pub(crate) default_cc: Ref<CallingConvention>,
     /// Thiscall calling convention for self.bv, or default_cc if we can't find one
-    pub(crate) thiscall_cc: Ref<CallingConvention<CoreArchitecture>>,
+    pub(crate) thiscall_cc: Ref<CallingConvention>,
     /// Cdecl calling convention for self.bv, or default_cc if we can't find one
-    pub(crate) cdecl_cc: Ref<CallingConvention<CoreArchitecture>>,
+    pub(crate) cdecl_cc: Ref<CallingConvention>,
     /// Default platform of self.bv
     pub(crate) platform: Ref<Platform>,
     /// pdb-rs structure for making lifetime hell a real place

plugins/pdb-ng/src/type_parser.rs

@@ -18,7 +18,7 @@ use std::sync::OnceLock;
 use crate::struct_grouper::group_structure;
 use crate::PDBParserInstance;
 use anyhow::{anyhow, Result};
-use binaryninja::architecture::{Architecture, CoreArchitecture};
+use binaryninja::architecture::Architecture;
 use binaryninja::binary_view::BinaryViewExt;
 use binaryninja::calling_convention::CallingConvention;
 use binaryninja::confidence::{Conf, MAX_CONFIDENCE};
@@ -2084,7 +2084,7 @@ impl<'a, S: Source<'a> + 'a> PDBParserInstance<'a, S> {
     pub(crate) fn find_calling_convention(
         platform: &Platform,
         name: &str,
-    ) -> Option<Ref<CallingConvention<CoreArchitecture>>> {
+    ) -> Option<Ref<CallingConvention>> {
         platform
             .calling_conventions()
             .iter()
@@ -2093,10 +2093,7 @@ impl<'a, S: Source<'a> + 'a> PDBParserInstance<'a, S> {
     }
 
     /// Convert pdb calling convention enum to binja
-    fn cv_call_t_to_calling_convention(
-        &self,
-        cv: u8,
-    ) -> Option<Ref<CallingConvention<CoreArchitecture>>> {
+    fn cv_call_t_to_calling_convention(&self, cv: u8) -> Option<Ref<CallingConvention>> {
         match CV_call_t::try_from(cv) {
             Ok(CV_call_t::NEAR_FAST) | Ok(CV_call_t::FAR_FAST) => {
                 self.platform.get_fastcall_calling_convention()

plugins/warp/src/convert.rs

@@ -348,17 +348,15 @@ pub fn from_bn_type_internal(
     }
 }
 
-pub fn from_bn_calling_convention<A: BNArchitecture>(
-    raw_cc: BNRef<BNCallingConvention<A>>,
-) -> CallingConvention {
+pub fn from_bn_calling_convention(raw_cc: BNRef<BNCallingConvention>) -> CallingConvention {
     // NOTE: Currently calling convention just stores the name.
     CallingConvention::new(raw_cc.name().as_str())
 }
 
 pub fn to_bn_calling_convention<A: BNArchitecture>(
     arch: &A,
     calling_convention: &CallingConvention,
-) -> BNRef<BNCallingConvention<A>> {
+) -> BNRef<BNCallingConvention> {
     for cc in &arch.calling_conventions() {
         if cc.name().as_str() == calling_convention.name {
             return cc.clone();

rust/src/architecture.rs

@@ -1897,7 +1897,7 @@ impl Architecture for CoreArchitecture {
 
 macro_rules! cc_func {
     ($get_name:ident, $get_api:ident, $set_name:ident, $set_api:ident) => {
-        fn $get_name(&self) -> Option<Ref<CallingConvention<Self>>> {
+        fn $get_name(&self) -> Option<Ref<CallingConvention>> {
             let arch = self.as_ref();
 
             unsafe {
@@ -1906,16 +1906,16 @@ macro_rules! cc_func {
                 if cc.is_null() {
                     None
                 } else {
-                    Some(CallingConvention::ref_from_raw(cc, self.handle()))
+                    Some(CallingConvention::ref_from_raw(cc))
                 }
             }
         }
 
-        fn $set_name(&self, cc: &CallingConvention<Self>) {
+        fn $set_name(&self, cc: &CallingConvention) {
             let arch = self.as_ref();
 
             assert!(
-                cc.arch_handle.borrow().as_ref().handle == arch.handle,
+                cc.arch().handle == arch.handle,
                 "use of calling convention with non-matching architecture!"
             );
 
@@ -1939,12 +1939,12 @@ pub trait ArchitectureExt: Architecture {
         }
     }
 
-    fn calling_conventions(&self) -> Array<CallingConvention<Self>> {
+    fn calling_conventions(&self) -> Array<CallingConvention> {
         unsafe {
             let mut count = 0;
             let calling_convs =
                 BNGetArchitectureCallingConventions(self.as_ref().handle, &mut count);
-            Array::new(calling_convs, count, self.handle())
+            Array::new(calling_convs, count, ())
         }
     }