Rollup of 3 pull requests

src/librustc/mir/interpret/error.rs

@@ -215,6 +215,15 @@ fn print_backtrace(backtrace: &mut Backtrace) {
     eprintln!("\n\nAn error occurred in miri:\n{:?}", backtrace);
 }
 
+impl From<ErrorHandled> for InterpErrorInfo<'tcx> {
+    fn from(err: ErrorHandled) -> Self {
+        match err {
+            ErrorHandled::Reported => err_inval!(ReferencedConstant),
+            ErrorHandled::TooGeneric => err_inval!(TooGeneric),
+        }.into()
+    }
+}
+
 impl<'tcx> From<InterpError<'tcx>> for InterpErrorInfo<'tcx> {
     fn from(kind: InterpError<'tcx>) -> Self {
         let backtrace = match env::var("RUSTC_CTFE_BACKTRACE") {

src/librustc/query/mod.rs

@@ -449,15 +449,6 @@ rustc_queries! {
             no_force
             desc { "extract field of const" }
         }
-
-        /// Produces an absolute path representation of the given type. See also the documentation
-        /// on `std::any::type_name`.
-        query type_name(key: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
-            eval_always
-            no_force
-            desc { "get absolute path of type" }
-        }
-
     }
 
     TypeChecking {

src/librustc_codegen_llvm/common.rs

@@ -333,15 +333,21 @@ impl ConstMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         offset: Size,
     ) -> PlaceRef<'tcx, &'ll Value> {
         assert_eq!(alloc.align, layout.align.abi);
-        let init = const_alloc_to_llvm(self, alloc);
-        let base_addr = self.static_addr_of(init, alloc.align, None);
-
-        let llval = unsafe { llvm::LLVMConstInBoundsGEP(
-            self.const_bitcast(base_addr, self.type_i8p()),
-            &self.const_usize(offset.bytes()),
-            1,
-        )};
-        let llval = self.const_bitcast(llval, self.type_ptr_to(layout.llvm_type(self)));
+        let llty = self.type_ptr_to(layout.llvm_type(self));
+        let llval = if layout.size == Size::ZERO {
+            let llval = self.const_usize(alloc.align.bytes());
+            unsafe { llvm::LLVMConstIntToPtr(llval, llty) }
+        } else {
+            let init = const_alloc_to_llvm(self, alloc);
+            let base_addr = self.static_addr_of(init, alloc.align, None);
+
+            let llval = unsafe { llvm::LLVMConstInBoundsGEP(
+                self.const_bitcast(base_addr, self.type_i8p()),
+                &self.const_usize(offset.bytes()),
+                1,
+            )};
+            self.const_bitcast(llval, llty)
+        };
         PlaceRef::new_sized(llval, layout, alloc.align)
     }
 

src/librustc_codegen_llvm/intrinsic.rs

@@ -15,6 +15,7 @@ use rustc_codegen_ssa::glue;
 use rustc_codegen_ssa::base::{to_immediate, wants_msvc_seh, compare_simd_types};
 use rustc::ty::{self, Ty};
 use rustc::ty::layout::{self, LayoutOf, HasTyCtxt, Primitive};
+use rustc::mir::interpret::GlobalId;
 use rustc_codegen_ssa::common::{IntPredicate, TypeKind};
 use rustc::hir;
 use syntax::ast::{self, FloatTy};
@@ -81,13 +82,14 @@ fn get_simple_intrinsic(cx: &CodegenCx<'ll, '_>, name: &str) -> Option<&'ll Valu
 impl IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
     fn codegen_intrinsic_call(
         &mut self,
-        callee_ty: Ty<'tcx>,
+        instance: ty::Instance<'tcx>,
         fn_ty: &FnType<'tcx, Ty<'tcx>>,
         args: &[OperandRef<'tcx, &'ll Value>],
         llresult: &'ll Value,
         span: Span,
     ) {
         let tcx = self.tcx;
+        let callee_ty = instance.ty(tcx);
 
         let (def_id, substs) = match callee_ty.sty {
             ty::FnDef(def_id, substs) => (def_id, substs),
@@ -133,10 +135,6 @@ impl IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
                 let llfn = self.get_intrinsic(&("llvm.debugtrap"));
                 self.call(llfn, &[], None)
             }
-            "size_of" => {
-                let tp_ty = substs.type_at(0);
-                self.const_usize(self.size_of(tp_ty).bytes())
-            }
             "va_start" => {
                 self.va_start(args[0].immediate())
             }
@@ -188,10 +186,6 @@ impl IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
                     self.const_usize(self.size_of(tp_ty).bytes())
                 }
             }
-            "min_align_of" => {
-                let tp_ty = substs.type_at(0);
-                self.const_usize(self.align_of(tp_ty).bytes())
-            }
             "min_align_of_val" => {
                 let tp_ty = substs.type_at(0);
                 if let OperandValue::Pair(_, meta) = args[0].val {
@@ -201,18 +195,19 @@ impl IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
                     self.const_usize(self.align_of(tp_ty).bytes())
                 }
             }
-            "pref_align_of" => {
-                let tp_ty = substs.type_at(0);
-                self.const_usize(self.layout_of(tp_ty).align.pref.bytes())
-            }
+            "size_of" |
+            "pref_align_of" |
+            "min_align_of" |
+            "needs_drop" |
+            "type_id" |
             "type_name" => {
-                let tp_ty = substs.type_at(0);
-                let ty_name = self.tcx.type_name(tp_ty);
+                let gid = GlobalId {
+                    instance,
+                    promoted: None,
+                };
+                let ty_name = self.tcx.const_eval(ty::ParamEnv::reveal_all().and(gid)).unwrap();
                 OperandRef::from_const(self, ty_name).immediate_or_packed_pair(self)
             }
-            "type_id" => {
-                self.const_u64(self.tcx.type_id_hash(substs.type_at(0)))
-            }
             "init" => {
                 let ty = substs.type_at(0);
                 if !self.layout_of(ty).is_zst() {
@@ -235,11 +230,6 @@ impl IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
             "uninit" | "forget" => {
                 return;
             }
-            "needs_drop" => {
-                let tp_ty = substs.type_at(0);
-
-                self.const_bool(self.type_needs_drop(tp_ty))
-            }
             "offset" => {
                 let ptr = args[0].immediate();
                 let offset = args[1].immediate();

src/librustc_codegen_ssa/mir/block.rs

@@ -666,8 +666,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             }).collect();
 
 
-            let callee_ty = instance.as_ref().unwrap().ty(bx.tcx());
-            bx.codegen_intrinsic_call(callee_ty, &fn_ty, &args, dest,
+            bx.codegen_intrinsic_call(*instance.as_ref().unwrap(), &fn_ty, &args, dest,
                                       terminator.source_info.span);
 
             if let ReturnDest::IndirectOperand(dst, _) = ret_dest {

src/librustc_codegen_ssa/traits/intrinsic.rs

@@ -1,6 +1,6 @@
 use super::BackendTypes;
 use crate::mir::operand::OperandRef;
-use rustc::ty::Ty;
+use rustc::ty::{self, Ty};
 use rustc_target::abi::call::FnType;
 use syntax_pos::Span;
 
@@ -10,7 +10,7 @@ pub trait IntrinsicCallMethods<'tcx>: BackendTypes {
     /// add them to librustc_codegen_llvm/context.rs
     fn codegen_intrinsic_call(
         &mut self,
-        callee_ty: Ty<'tcx>,
+        instance: ty::Instance<'tcx>,
         fn_ty: &FnType<'tcx, Ty<'tcx>>,
         args: &[OperandRef<'tcx, Self::Value>],
         llresult: Self::Value,

src/librustc_mir/const_eval.rs

@@ -15,6 +15,7 @@ use rustc::ty::{self, Ty, TyCtxt, subst::Subst};
 use rustc::ty::layout::{self, LayoutOf, VariantIdx};
 use rustc::traits::Reveal;
 use rustc_data_structures::fx::FxHashMap;
+use crate::interpret::eval_nullary_intrinsic;
 
 use syntax::source_map::{Span, DUMMY_SP};
 
@@ -612,6 +613,23 @@ pub fn const_eval_provider<'tcx>(
             other => return other,
         }
     }
+
+    // We call `const_eval` for zero arg intrinsics, too, in order to cache their value.
+    // Catch such calls and evaluate them instead of trying to load a constant's MIR.
+    if let ty::InstanceDef::Intrinsic(def_id) = key.value.instance.def {
+        let ty = key.value.instance.ty(tcx);
+        let substs = match ty.sty {
+            ty::FnDef(_, substs) => substs,
+            _ => bug!("intrinsic with type {:?}", ty),
+        };
+        return eval_nullary_intrinsic(tcx, key.param_env, def_id, substs)
+            .map_err(|error| {
+                let span = tcx.def_span(def_id);
+                let error = ConstEvalErr { error: error.kind, stacktrace: vec![], span };
+                error.report_as_error(tcx.at(span), "could not evaluate nullary intrinsic")
+            })
+    }
+
     tcx.const_eval_raw(key).and_then(|val| {
         validate_and_turn_into_const(tcx, val, key)
     })
@@ -680,63 +698,63 @@ pub fn const_eval_raw_provider<'tcx>(
         })
     }).map_err(|error| {
         let err = error_to_const_error(&ecx, error);
-        // errors in statics are always emitted as fatal errors
-        if tcx.is_static(def_id) {
-            // Ensure that if the above error was either `TooGeneric` or `Reported`
-            // an error must be reported.
+    // errors in statics are always emitted as fatal errors
+    if tcx.is_static(def_id) {
+        // Ensure that if the above error was either `TooGeneric` or `Reported`
+        // an error must be reported.
             let v = err.report_as_error(ecx.tcx, "could not evaluate static initializer");
-            tcx.sess.delay_span_bug(
-                err.span,
-                &format!("static eval failure did not emit an error: {:#?}", v)
-            );
-            v
-        } else if def_id.is_local() {
-            // constant defined in this crate, we can figure out a lint level!
-            match tcx.def_kind(def_id) {
-                // constants never produce a hard error at the definition site. Anything else is
-                // a backwards compatibility hazard (and will break old versions of winapi for sure)
-                //
-                // note that validation may still cause a hard error on this very same constant,
-                // because any code that existed before validation could not have failed validation
-                // thus preventing such a hard error from being a backwards compatibility hazard
-                Some(DefKind::Const) | Some(DefKind::AssocConst) => {
-                    let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
+        tcx.sess.delay_span_bug(
+            err.span,
+            &format!("static eval failure did not emit an error: {:#?}", v)
+        );
+        v
+    } else if def_id.is_local() {
+        // constant defined in this crate, we can figure out a lint level!
+        match tcx.def_kind(def_id) {
+            // constants never produce a hard error at the definition site. Anything else is
+            // a backwards compatibility hazard (and will break old versions of winapi for sure)
+            //
+            // note that validation may still cause a hard error on this very same constant,
+            // because any code that existed before validation could not have failed validation
+            // thus preventing such a hard error from being a backwards compatibility hazard
+            Some(DefKind::Const) | Some(DefKind::AssocConst) => {
+                let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
+                err.report_as_lint(
+                    tcx.at(tcx.def_span(def_id)),
+                    "any use of this value will cause an error",
+                    hir_id,
+                    Some(err.span),
+                )
+            },
+            // promoting runtime code is only allowed to error if it references broken constants
+            // any other kind of error will be reported to the user as a deny-by-default lint
+                _ => if let Some(p) = cid.promoted {
+                let span = tcx.promoted_mir(def_id)[p].span;
+                if let err_inval!(ReferencedConstant) = err.error {
+                    err.report_as_error(
+                        tcx.at(span),
+                        "evaluation of constant expression failed",
+                    )
+                } else {
                     err.report_as_lint(
-                        tcx.at(tcx.def_span(def_id)),
-                        "any use of this value will cause an error",
-                        hir_id,
+                        tcx.at(span),
+                        "reaching this expression at runtime will panic or abort",
+                        tcx.hir().as_local_hir_id(def_id).unwrap(),
                         Some(err.span),
                     )
-                },
-                // promoting runtime code is only allowed to error if it references broken constants
-                // any other kind of error will be reported to the user as a deny-by-default lint
-                _ => if let Some(p) = cid.promoted {
-                    let span = tcx.promoted_mir(def_id)[p].span;
-                    if let err_inval!(ReferencedConstant) = err.error {
-                        err.report_as_error(
-                            tcx.at(span),
-                            "evaluation of constant expression failed",
-                        )
-                    } else {
-                        err.report_as_lint(
-                            tcx.at(span),
-                            "reaching this expression at runtime will panic or abort",
-                            tcx.hir().as_local_hir_id(def_id).unwrap(),
-                            Some(err.span),
-                        )
-                    }
-                // anything else (array lengths, enum initializers, constant patterns) are reported
-                // as hard errors
-                } else {
-                    err.report_as_error(
+                }
+            // anything else (array lengths, enum initializers, constant patterns) are reported
+            // as hard errors
+            } else {
+                err.report_as_error(
                         ecx.tcx,
-                        "evaluation of constant value failed",
-                    )
-                },
-            }
-        } else {
-            // use of broken constant from other crate
-            err.report_as_error(ecx.tcx, "could not evaluate constant")
+                    "evaluation of constant value failed",
+                )
+            },
         }
+    } else {
+        // use of broken constant from other crate
+            err.report_as_error(ecx.tcx, "could not evaluate constant")
+    }
     })
 }

src/librustc_mir/interpret/eval_context.rs

@@ -14,7 +14,6 @@ use rustc::ty::{self, Ty, TyCtxt, TypeFoldable};
 use rustc::ty::query::TyCtxtAt;
 use rustc_data_structures::indexed_vec::IndexVec;
 use rustc::mir::interpret::{
-    ErrorHandled,
     GlobalId, Scalar, Pointer, FrameInfo, AllocId,
     InterpResult, truncate, sign_extend,
 };
@@ -696,14 +695,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         // Our result will later be validated anyway, and there seems no good reason
         // to have to fail early here.  This is also more consistent with
         // `Memory::get_static_alloc` which has to use `const_eval_raw` to avoid cycles.
-        let val = self.tcx.const_eval_raw(param_env.and(gid)).map_err(|err| {
-            match err {
-                ErrorHandled::Reported =>
-                    err_inval!(ReferencedConstant),
-                ErrorHandled::TooGeneric =>
-                    err_inval!(TooGeneric),
-            }
-        })?;
+        let val = self.tcx.const_eval_raw(param_env.and(gid))?;
         self.raw_const_to_mplace(val)
     }