src/librustc_codegen_ssa/mir/constant.rs

   1 use rustc::mir::interpret::ErrorHandled;
   2 use rustc::mir;
   3 use rustc_index::vec::Idx;
   4 use rustc::ty::{self, Ty};
   5 use rustc::ty::layout::{self, HasTyCtxt};
   6 use syntax::source_map::Span;
   7 use crate::traits::*;
   8 use crate::mir::operand::OperandRef;
   9
  10 use super::FunctionCx;
  11
  12 impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
  13     pub fn eval_mir_constant_to_operand(
  14         &mut self,
  15         bx: &mut Bx,
  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)
  24                 if self.cx.tcx().is_static(def_id) => {
  25                     assert!(substs.is_empty(), "we don't support generic statics yet");
  26                     let static_ = bx.get_static(def_id);
  27                     // we treat operands referring to statics as if they were `&STATIC` instead
  28                     let ptr_ty = self.cx.tcx().mk_mut_ptr(self.monomorphize(&constant.literal.ty));
  29                     let layout = bx.layout_of(ptr_ty);
  30                     Ok(OperandRef::from_immediate_or_packed_pair(bx, static_, layout))
  31                 }
  32             _ => {
  33                 let val = self.eval_mir_constant(constant)?;
  34                 Ok(OperandRef::from_const(bx, val))
  35             }
  36         }
  37     }
  38
  39     pub fn eval_mir_constant(
  40         &mut self,
  41         constant: &mir::Constant<'tcx>,
  42     ) -> Result<&'tcx ty::Const<'tcx>, ErrorHandled> {
  43         match constant.literal.val {
  44             ty::ConstKind::Unevaluated(def_id, substs) => {
  45                 let substs = self.monomorphize(&substs);
  46                 let instance = ty::Instance::resolve(
  47                     self.cx.tcx(), ty::ParamEnv::reveal_all(), def_id, substs,
  48                 ).unwrap();
  49                 let cid = mir::interpret::GlobalId {
  50                     instance,
  51                     promoted: None,
  52                 };
  53                 self.cx.tcx().const_eval(ty::ParamEnv::reveal_all().and(cid)).map_err(|err| {
  54                     self.cx.tcx().sess.span_err(constant.span, "erroneous constant encountered");
  55                     err
  56                 })
  57             },
  58             _ => Ok(self.monomorphize(&constant.literal)),
  59         }
  60     }
  61
  62     /// process constant containing SIMD shuffle indices
  63     pub fn simd_shuffle_indices(
  64         &mut self,
  65         bx: &Bx,
  66         span: Span,
  67         ty: Ty<'tcx>,
  68         constant: Result<&'tcx ty::Const<'tcx>, ErrorHandled>,
  69     ) -> (Bx::Value, Ty<'tcx>) {
  70         constant
  71             .map(|c| {
  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),
  76                 };
  77                 let values: Vec<_> = (0..fields).map(|field| {
  78                     let field = bx.tcx().const_field(
  79                         ty::ParamEnv::reveal_all().and((&c, mir::Field::new(field as usize)))
  80                     );
  81                     if let Some(prim) = field.val.try_to_scalar() {
  82                         let layout = bx.layout_of(field_ty);
  83                         let scalar = match layout.abi {
  84                             layout::Abi::Scalar(ref x) => x,
  85                             _ => bug!("from_const: invalid ByVal layout: {:#?}", layout)
  86                         };
  87                         bx.scalar_to_backend(
  88                             prim, scalar,
  89                             bx.immediate_backend_type(layout),
  90                         )
  91                     } else {
  92                         bug!("simd shuffle field {:?}", field)
  93                     }
  94                 }).collect();
  95                 let llval = bx.const_struct(&values, false);
  96                 (llval, c.ty)
  97             })
  98             .unwrap_or_else(|_| {
  99                 bx.tcx().sess.span_err(
 100                     span,
 101                     "could not evaluate shuffle_indices at compile time",
 102                 );
 103                 // We've errored, so we don't have to produce working code.
 104                 let ty = self.monomorphize(&ty);
 105                 let llty = bx.backend_type(bx.layout_of(ty));
 106                 (bx.const_undef(llty), ty)
 107             })
 108     }
 109 }