Reduce the chance of accidentally calling functions in CTFE

previously miri had a check for const fn and other cases that
CTFE requires. Instead the function call is completely
processed inside the machine. This allows CTFE to have full
control over what is called and miri to not have useless
CTFE-checks in normal mode.

Author: oli-obk

Cargo.toml

@@ -35,3 +35,4 @@ compiletest_rs = "0.2.6"
 
 [workspace]
 members = ["src/librustc_mir"]
+exclude = ["xargo"]

miri/lib.rs

@@ -17,6 +17,8 @@ use rustc::ty::{self, TyCtxt};
 use rustc::hir::def_id::DefId;
 use rustc::mir;
 
+use syntax::codemap::Span;
+
 use std::collections::{
     HashMap,
     BTreeMap,
@@ -25,7 +27,7 @@ use std::collections::{
 extern crate rustc_miri;
 pub use rustc_miri::interpret::*;
 
-mod missing_fns;
+mod fn_call;
 mod operator;
 
 pub fn eval_main<'a, 'tcx: 'a>(
@@ -304,17 +306,19 @@ impl<'b, 'a, 'tcx> MemoryMut<'b, 'a, 'tcx> {
 impl<'tcx> Machine<'tcx> for Evaluator {
     type Data = EvaluatorData;
     type MemoryData = MemoryData<'tcx>;
+
     /// Returns Ok() when the function was handled, fail otherwise
-    fn call_missing_fn<'a>(
+    fn eval_fn_call<'a>(
         ecx: &mut rustc_miri::interpret::EvalContext<'a, 'tcx, Self>,
         instance: ty::Instance<'tcx>,
         destination: Option<(Lvalue<'tcx>, mir::BasicBlock)>,
         arg_operands: &[mir::Operand<'tcx>],
+        span: Span,
         sig: ty::FnSig<'tcx>,
-        path: String,
-    ) -> EvalResult<'tcx> {
-        EvalContext(ecx).call_missing_fn(instance, destination, arg_operands, sig, path)
+    ) -> EvalResult<'tcx, bool> {
+        EvalContext(ecx).eval_fn_call(instance, destination, arg_operands, span, sig)
     }
+
     fn ptr_op<'a>(
         ecx: &rustc_miri::interpret::EvalContext<'a, 'tcx, Self>,
         bin_op: mir::BinOp,
@@ -325,8 +329,4 @@ impl<'tcx> Machine<'tcx> for Evaluator {
     ) -> EvalResult<'tcx, Option<(PrimVal, bool)>> {
         ImmEvalContext(ecx).ptr_op(bin_op, left, left_ty, right, right_ty)
     }
-
-    fn check_non_const_fn_call(_instance: ty::Instance<'tcx>) -> EvalResult<'tcx> {
-        Ok(())
-    }
 }