Let all checkshim use FnAbi instead

Author: tiif

src/tools/miri/src/helpers.rs

@@ -19,6 +19,10 @@ use rustc_middle::ty::layout::{FnAbiOf, LayoutOf, MaybeResult, TyAndLayout};
 use rustc_middle::ty::{self, FloatTy, IntTy, Ty, TyCtxt, UintTy};
 use rustc_session::config::CrateType;
 use rustc_span::{Span, Symbol};
+use rustc_target::callconv::FnAbi;
+use rustc_target::callconv::Conv;
+
+
 
 use crate::*;
 
@@ -916,13 +920,27 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     }
 
     /// Check that the ABI is what we expect.
-    fn check_abi<'a>(&self, abi: ExternAbi, exp_abi: ExternAbi) -> InterpResult<'a, ()> {
-        if abi != exp_abi {
-            throw_ub_format!(
-                "calling a function with ABI {} using caller ABI {}",
-                exp_abi.name(),
-                abi.name()
-            )
+    fn check_abi<'a>(&self, fn_abi: &FnAbi<'tcx, Ty<'tcx>>, exp_abi: ExternAbi) -> InterpResult<'a, ()> {
+        let call_conv;
+        match fn_abi.conv {
+            Conv::C => {
+                // TODO: unwind what? 
+                call_conv = ExternAbi::C { unwind: false};
+            },
+            Conv::Rust => {
+                call_conv = ExternAbi::Rust;
+            },
+            _=> {
+                // TODO: What is a better way of doing this?
+                panic!("Unsupported calling convention");
+            }
+        };
+        if call_conv != exp_abi {
+                        throw_ub_format!(
+                               "calling a function with ABI {} using caller ABI {}",
+                                exp_abi.name(),
+                                call_conv.name()
+                            )
         }
         interp_ok(())
     }
@@ -952,11 +970,11 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
     fn check_abi_and_shim_symbol_clash(
         &mut self,
-        abi: ExternAbi,
+        fnabi: &FnAbi<'tcx, Ty<'tcx>>,
         exp_abi: ExternAbi,
         link_name: Symbol,
     ) -> InterpResult<'tcx, ()> {
-        self.check_abi(abi, exp_abi)?;
+        self.check_abi(fnabi, exp_abi)?;
         if let Some((body, instance)) = self.eval_context_mut().lookup_exported_symbol(link_name)? {
             // If compiler-builtins is providing the symbol, then don't treat it as a clash.
             // We'll use our built-in implementation in `emulate_foreign_item_inner` for increased
@@ -978,14 +996,15 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     fn check_shim<'a, const N: usize>(
         &mut self,
         abi: ExternAbi,
+        _fnabi: &FnAbi<'tcx, Ty<'tcx>>,
         exp_abi: ExternAbi,
         link_name: Symbol,
         args: &'a [OpTy<'tcx>],
     ) -> InterpResult<'tcx, &'a [OpTy<'tcx>; N]>
     where
         &'a [OpTy<'tcx>; N]: TryFrom<&'a [OpTy<'tcx>]>,
     {
-        self.check_abi_and_shim_symbol_clash(abi, exp_abi, link_name)?;
+        self.check_abi_and_shim_symbol_clash(_fnabi, exp_abi, link_name)?;
         check_arg_count(args)
     }
 

src/tools/miri/src/machine.rs

@@ -1023,7 +1023,7 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {
             // Any needed call to `goto_block` will be performed by `emulate_foreign_item`.
             let args = ecx.copy_fn_args(args); // FIXME: Should `InPlace` arguments be reset to uninit?
             let link_name = Symbol::intern(ecx.tcx.symbol_name(instance).name);
-            return ecx.emulate_foreign_item(link_name, abi, &args, dest, ret, unwind);
+            return ecx.emulate_foreign_item(link_name, abi, _fnabi, &args, dest, ret, unwind);
         }
 
         // Otherwise, load the MIR.

src/tools/miri/src/shims/backtrace.rs

@@ -3,6 +3,7 @@ use rustc_ast::ast::Mutability;
 use rustc_middle::ty::layout::LayoutOf as _;
 use rustc_middle::ty::{self, Instance, Ty};
 use rustc_span::{BytePos, Loc, Symbol, hygiene};
+use rustc_target::callconv::FnAbi;
 
 use crate::helpers::check_min_arg_count;
 use crate::*;
@@ -11,13 +12,13 @@ impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
 pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     fn handle_miri_backtrace_size(
         &mut self,
-        abi: ExternAbi,
+        fnabi: &FnAbi<'tcx, Ty<'tcx>>,
         link_name: Symbol,
         args: &[OpTy<'tcx>],
         dest: &MPlaceTy<'tcx>,
     ) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
-        let [flags] = this.check_shim(abi, ExternAbi::Rust, link_name, args)?;
+        let [flags] = this.check_shim(fnabi, ExternAbi::Rust, link_name, args)?;
 
         let flags = this.read_scalar(flags)?.to_u64()?;
         if flags != 0 {
@@ -137,13 +138,13 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
     fn handle_miri_resolve_frame(
         &mut self,
-        abi: ExternAbi,
+        fnabi: &FnAbi<'tcx, Ty<'tcx>>,
         link_name: Symbol,
         args: &[OpTy<'tcx>],
         dest: &MPlaceTy<'tcx>,
     ) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
-        let [ptr, flags] = this.check_shim(abi, ExternAbi::Rust, link_name, args)?;
+        let [ptr, flags] = this.check_shim(fnabi, ExternAbi::Rust, link_name, args)?;
 
         let flags = this.read_scalar(flags)?.to_u64()?;
 
@@ -215,14 +216,14 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
     fn handle_miri_resolve_frame_names(
         &mut self,
-        abi: ExternAbi,
+        fnabi: &FnAbi<'tcx, Ty<'tcx>>,
         link_name: Symbol,
         args: &[OpTy<'tcx>],
     ) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
 
         let [ptr, flags, name_ptr, filename_ptr] =
-            this.check_shim(abi, ExternAbi::Rust, link_name, args)?;
+            this.check_shim(fnabi, ExternAbi::Rust, link_name, args)?;
 
         let flags = this.read_scalar(flags)?.to_u64()?;
         if flags != 0 {