1 use crate::mir::operand::OperandRef;
4 use rustc::mir::interpret::ErrorHandled;
5 use rustc::ty::layout::{self, HasTyCtxt};
6 use rustc::ty::{self, Ty};
7 use rustc_index::vec::Idx;
8 use rustc_span::source_map::Span;
10 use super::FunctionCx;
12 impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
13 pub fn eval_mir_constant_to_operand(
16 constant: &mir::Constant<'tcx>,
17 ) -> Result<OperandRef<'tcx, Bx::Value>, ErrorHandled> {
18 match constant.literal.val {
19 // Special case unevaluated statics, because statics have an identity and thus should
20 // use `get_static` to get at their id.
21 // FIXME(oli-obk): can we unify this somehow, maybe by making const eval of statics
22 // always produce `&STATIC`. This may also simplify how const eval works with statics.
23 ty::ConstKind::Unevaluated(def_id, substs, None) if self.cx.tcx().is_static(def_id) => {
24 assert!(substs.is_empty(), "we don't support generic statics yet");
25 let static_ = bx.get_static(def_id);
26 // we treat operands referring to statics as if they were `&STATIC` instead
27 let ptr_ty = self.cx.tcx().mk_mut_ptr(self.monomorphize(&constant.literal.ty));
28 let layout = bx.layout_of(ptr_ty);
29 Ok(OperandRef::from_immediate_or_packed_pair(bx, static_, layout))
32 let val = self.eval_mir_constant(constant)?;
33 Ok(OperandRef::from_const(bx, val))
38 pub fn eval_mir_constant(
40 constant: &mir::Constant<'tcx>,
41 ) -> Result<&'tcx ty::Const<'tcx>, ErrorHandled> {
42 match constant.literal.val {
43 ty::ConstKind::Unevaluated(def_id, substs, promoted) => {
44 let substs = self.monomorphize(&substs);
47 .const_eval_resolve(ty::ParamEnv::reveal_all(), def_id, substs, promoted, None)
49 if promoted.is_none() {
53 .span_err(constant.span, "erroneous constant encountered");
58 _ => Ok(self.monomorphize(&constant.literal)),
62 /// process constant containing SIMD shuffle indices
63 pub fn simd_shuffle_indices(
68 constant: Result<&'tcx ty::Const<'tcx>, ErrorHandled>,
69 ) -> (Bx::Value, Ty<'tcx>) {
72 let field_ty = c.ty.builtin_index().unwrap();
73 let fields = match c.ty.kind {
74 ty::Array(_, n) => n.eval_usize(bx.tcx(), ty::ParamEnv::reveal_all()),
75 _ => bug!("invalid simd shuffle type: {}", c.ty),
77 let values: Vec<_> = (0..fields)
79 let field = bx.tcx().const_field(
80 ty::ParamEnv::reveal_all().and((&c, mir::Field::new(field as usize))),
82 if let Some(prim) = field.val.try_to_scalar() {
83 let layout = bx.layout_of(field_ty);
84 let scalar = match layout.abi {
85 layout::Abi::Scalar(ref x) => x,
86 _ => bug!("from_const: invalid ByVal layout: {:#?}", layout),
88 bx.scalar_to_backend(prim, scalar, bx.immediate_backend_type(layout))
90 bug!("simd shuffle field {:?}", field)
94 let llval = bx.const_struct(&values, false);
98 bx.tcx().sess.span_err(span, "could not evaluate shuffle_indices at compile time");
99 // We've errored, so we don't have to produce working code.
100 let ty = self.monomorphize(&ty);
101 let llty = bx.backend_type(bx.layout_of(ty));
102 (bx.const_undef(llty), ty)