[BROKEN] rustc_mir: use FnAbi to get abi::call::Conv in miri.

Author: eddyb

src/librustc/mir/interpret/error.rs

@@ -10,7 +10,7 @@ use crate::ty::query::TyCtxtAt;
 use backtrace::Backtrace;
 use errors::DiagnosticBuilder;
 use rustc_macros::HashStable;
-use rustc_target::spec::abi::Abi;
+use rustc_target::abi;
 use syntax_pos::{Pos, Span};
 use syntax::symbol::Symbol;
 
@@ -396,7 +396,7 @@ pub enum UnsupportedOpInfo<'tcx> {
     Unsupported(String),
 
     // -- Everything below is not categorized yet --
-    FunctionAbiMismatch(Abi, Abi),
+    FunctionAbiMismatch(abi::call::Conv, abi::call::Conv),
     FunctionArgMismatch(Ty<'tcx>, Ty<'tcx>),
     FunctionRetMismatch(Ty<'tcx>, Ty<'tcx>),
     FunctionArgCountMismatch,
@@ -460,9 +460,9 @@ impl fmt::Debug for UnsupportedOpInfo<'tcx> {
                 write!(f, "type validation failed: {}", err)
             }
             NoMirFor(ref func) => write!(f, "no MIR for `{}`", func),
-            FunctionAbiMismatch(caller_abi, callee_abi) =>
+            FunctionAbiMismatch(caller_conv, callee_conv) =>
                 write!(f, "tried to call a function with ABI {:?} using caller ABI {:?}",
-                    callee_abi, caller_abi),
+                    callee_conv, caller_conv),
             FunctionArgMismatch(caller_ty, callee_ty) =>
                 write!(f, "tried to call a function with argument of type {:?} \
                            passing data of type {:?}",

src/librustc_mir/interpret/terminator.rs

@@ -1,9 +1,10 @@
 use std::borrow::Cow;
 
-use rustc::{mir, ty};
-use rustc::ty::Instance;
-use rustc::ty::layout::{self, TyLayout, LayoutOf};
+use rustc::mir;
+use rustc::ty::{self, Instance, Ty};
+use rustc::ty::layout::{self, FnAbiExt, TyLayout, LayoutOf};
 use syntax::source_map::Span;
+use rustc_target::abi::call::FnAbi;
 use rustc_target::spec::abi::Abi;
 
 use super::{
@@ -60,16 +61,22 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 ..
             } => {
                 let func = self.eval_operand(func, None)?;
-                let (fn_val, abi) = match func.layout.ty.kind {
+                let (fn_val, abi, fn_abi) = match func.layout.ty.kind {
                     ty::FnPtr(sig) => {
                         let caller_abi = sig.abi();
                         let fn_ptr = self.read_scalar(func)?.not_undef()?;
                         let fn_val = self.memory.get_fn(fn_ptr)?;
-                        (fn_val, caller_abi)
+                        // FIXME(eddyb) compute `extra_args` to pass to
+                        // `FnAbi::of_fn_ptr` to support C variadics.
+                        (fn_val, caller_abi, FnAbi::of_fn_ptr(self, sig, &[]))
                     }
                     ty::FnDef(def_id, substs) => {
                         let sig = func.layout.ty.fn_sig(*self.tcx);
-                        (FnVal::Instance(self.resolve(def_id, substs)?), sig.abi())
+                        let instance = self.resolve(def_id, substs)?;
+                        // FIXME(eddyb) compute `extra_args` to pass to
+                        // `FnAbi::of_instance` to support C variadics.
+                        let fn_abi = FnAbi::of_instance(self, instance, &[]);
+                        (FnVal::Instance(instance), sig.abi(), fn_abi)
                     },
                     _ => {
                         bug!("invalid callee of type {:?}", func.layout.ty)
@@ -84,6 +91,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                     fn_val,
                     terminator.source_info.span,
                     abi,
+                    &fn_abi,
                     &args[..],
                     ret,
                     *cleanup
@@ -234,7 +242,10 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         &mut self,
         fn_val: FnVal<'tcx, M::ExtraFnVal>,
         span: Span,
+        // FIXME(eddyb) this shouldn't be needed, its main purpose
+        // right now is special-casing `RustCall` and intrinsics.
         caller_abi: Abi,
+        caller_fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
         args: &[OpTy<'tcx, M::PointerTag>],
         ret: Option<(PlaceTy<'tcx, M::PointerTag>, mir::BasicBlock)>,
         unwind: Option<mir::BasicBlock>
@@ -249,26 +260,14 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         };
 
         // ABI check
+        // FIXME(eddyb) check every aspect of `FnAbi` and use it below
+        // for adjusting various details (such as ignoring ZSTs).
         {
-            let callee_abi = {
-                let instance_ty = instance.ty(*self.tcx);
-                match instance_ty.kind {
-                    ty::FnDef(..) =>
-                        instance_ty.fn_sig(*self.tcx).abi(),
-                    ty::Closure(..) => Abi::RustCall,
-                    ty::Generator(..) => Abi::Rust,
-                    _ => bug!("unexpected callee ty: {:?}", instance_ty),
-                }
-            };
-            let normalize_abi = |abi| match abi {
-                Abi::Rust | Abi::RustCall | Abi::RustIntrinsic | Abi::PlatformIntrinsic =>
-                    // These are all the same ABI, really.
-                    Abi::Rust,
-                abi =>
-                    abi,
-            };
-            if normalize_abi(caller_abi) != normalize_abi(callee_abi) {
-                throw_unsup!(FunctionAbiMismatch(caller_abi, callee_abi))
+            // FIXME(eddyb) compute `extra_args` to pass to
+            // `FnAbi::of_instance` to support C variadics.
+            let callee_fn_abi = FnAbi::of_instance(self, instance, &[]);
+            if caller_fn_abi.conv != callee_fn_abi.conv {
+                throw_unsup!(FunctionAbiMismatch(caller_fn_abi.conv, callee_fn_abi.conv))
             }
         }
 
@@ -444,7 +443,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 });
                 trace!("Patched self operand to {:#?}", args[0]);
                 // recurse with concrete function
-                self.eval_fn_call(drop_fn, span, caller_abi, &args, ret, unwind)
+                self.eval_fn_call(drop_fn, span, caller_abi, caller_fn_abi, &args, ret, unwind)
             }
         }
     }
@@ -479,10 +478,15 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         let ty = self.tcx.mk_unit(); // return type is ()
         let dest = MPlaceTy::dangling(self.layout_of(ty)?, self);
 
+        // FIXME(eddyb) perhaps compute this more like the way it's done in
+        // `rustc_codegen_ssa::mir::block`?
+        let fn_abi = FnAbi::of_instance(self, instance, &[]);
+
         self.eval_fn_call(
             FnVal::Instance(instance),
             span,
             Abi::Rust,
+            &fn_abi,
             &[arg.into()],
             Some((dest.into(), target)),
             unwind

src/librustc_target/abi/call/mod.rs

@@ -2,6 +2,8 @@ use crate::abi::{self, Abi, Align, FieldPlacement, Size};
 use crate::abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods};
 use crate::spec::{self, HasTargetSpec};
 
+use rustc_macros::HashStable_Generic;
+
 mod aarch64;
 mod amdgpu;
 mod arm;
@@ -488,7 +490,8 @@ impl<'a, Ty> ArgAbi<'a, Ty> {
     }
 }
 
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, RustcEncodable, RustcDecodable)]
+#[derive(HashStable_Generic)]
 pub enum Conv {
     // General language calling conventions, for which every target
     // should have its own backend (e.g. LLVM) support.