src/librustc_mir/transform/const_prop.rs

   1 // Copyright 2017 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 //! Propagates constants for early reporting of statically known
  12 //! assertion failures
  13
  14
  15 use rustc::hir::def::Def;
  16 use rustc::mir::{Constant, Location, Place, Mir, Operand, Rvalue, Local};
  17 use rustc::mir::{NullOp, StatementKind, Statement, BasicBlock, LocalKind};
  18 use rustc::mir::{TerminatorKind, ClearCrossCrate, SourceInfo, BinOp, ProjectionElem};
  19 use rustc::mir::visit::{Visitor, PlaceContext};
  20 use rustc::mir::interpret::{ConstEvalErr, EvalErrorKind};
  21 use rustc::ty::{TyCtxt, self, Instance};
  22 use rustc::mir::interpret::{Value, Scalar, GlobalId, EvalResult};
  23 use interpret::EvalContext;
  24 use interpret::CompileTimeEvaluator;
  25 use interpret::{eval_promoted, mk_borrowck_eval_cx, ValTy};
  26 use transform::{MirPass, MirSource};
  27 use syntax::codemap::{Span, DUMMY_SP};
  28 use rustc::ty::subst::Substs;
  29 use rustc_data_structures::indexed_vec::IndexVec;
  30 use rustc::ty::ParamEnv;
  31 use rustc::ty::layout::{
  32     LayoutOf, TyLayout, LayoutError,
  33     HasTyCtxt, TargetDataLayout, HasDataLayout,
  34 };
  35
  36 pub struct ConstProp;
  37
  38 impl MirPass for ConstProp {
  39     fn run_pass<'a, 'tcx>(&self,
  40                           tcx: TyCtxt<'a, 'tcx, 'tcx>,
  41                           source: MirSource,
  42                           mir: &mut Mir<'tcx>) {
  43         // will be evaluated by miri and produce its errors there
  44         if source.promoted.is_some() {
  45             return;
  46         }
  47         match tcx.describe_def(source.def_id) {
  48             // skip statics/consts because they'll be evaluated by miri anyway
  49             Some(Def::Const(..)) |
  50             Some(Def::Static(..)) => return,
  51             // we still run on associated constants, because they might not get evaluated
  52             // within the current crate
  53             _ => {},
  54         }
  55         trace!("ConstProp starting for {:?}", source.def_id);
  56
  57         // FIXME(oli-obk, eddyb) Optimize locals (or even local paths) to hold
  58         // constants, instead of just checking for const-folding succeeding.
  59         // That would require an uniform one-def no-mutation analysis
  60         // and RPO (or recursing when needing the value of a local).
  61         let mut optimization_finder = ConstPropagator::new(mir, tcx, source);
  62         optimization_finder.visit_mir(mir);
  63
  64         trace!("ConstProp done for {:?}", source.def_id);
  65     }
  66 }
  67
  68 type Const<'tcx> = (Value, ty::Ty<'tcx>, Span);
  69
  70 /// Finds optimization opportunities on the MIR.
  71 struct ConstPropagator<'b, 'a, 'tcx:'a+'b> {
  72     ecx: EvalContext<'a, 'b, 'tcx, CompileTimeEvaluator>,
  73     mir: &'b Mir<'tcx>,
  74     tcx: TyCtxt<'a, 'tcx, 'tcx>,
  75     source: MirSource,
  76     places: IndexVec<Local, Option<Const<'tcx>>>,
  77     can_const_prop: IndexVec<Local, bool>,
  78     param_env: ParamEnv<'tcx>,
  79 }
  80
  81 impl<'a, 'b, 'tcx> LayoutOf for &'a ConstPropagator<'a, 'b, 'tcx> {
  82     type Ty = ty::Ty<'tcx>;
  83     type TyLayout = Result<TyLayout<'tcx>, LayoutError<'tcx>>;
  84
  85     fn layout_of(self, ty: ty::Ty<'tcx>) -> Self::TyLayout {
  86         self.tcx.layout_of(self.param_env.and(ty))
  87     }
  88 }
  89
  90 impl<'a, 'b, 'tcx> HasDataLayout for &'a ConstPropagator<'a, 'b, 'tcx> {
  91     #[inline]
  92     fn data_layout(&self) -> &TargetDataLayout {
  93         &self.tcx.data_layout
  94     }
  95 }
  96
  97 impl<'a, 'b, 'tcx> HasTyCtxt<'tcx> for &'a ConstPropagator<'a, 'b, 'tcx> {
  98     #[inline]
  99     fn tcx<'c>(&'c self) -> TyCtxt<'c, 'tcx, 'tcx> {
 100         self.tcx
 101     }
 102 }
 103
 104 impl<'b, 'a, 'tcx:'b> ConstPropagator<'b, 'a, 'tcx> {
 105     fn new(
 106         mir: &'b Mir<'tcx>,
 107         tcx: TyCtxt<'a, 'tcx, 'tcx>,
 108         source: MirSource,
 109     ) -> ConstPropagator<'b, 'a, 'tcx> {
 110         let param_env = tcx.param_env(source.def_id);
 111         let substs = Substs::identity_for_item(tcx, source.def_id);
 112         let instance = Instance::new(source.def_id, substs);
 113         let ecx = mk_borrowck_eval_cx(tcx, instance, mir, DUMMY_SP).unwrap();
 114         ConstPropagator {
 115             ecx,
 116             mir,
 117             tcx,
 118             source,
 119             param_env,
 120             can_const_prop: CanConstProp::check(mir),
 121             places: IndexVec::from_elem(None, &mir.local_decls),
 122         }
 123     }
 124
 125     fn use_ecx<F, T>(
 126         &mut self,
 127         source_info: SourceInfo,
 128         f: F
 129     ) -> Option<T>
 130     where
 131         F: FnOnce(&mut Self) -> EvalResult<'tcx, T>,
 132     {
 133         self.ecx.tcx.span = source_info.span;
 134         let lint_root = match self.mir.source_scope_local_data {
 135             ClearCrossCrate::Set(ref ivs) => {
 136                 use rustc_data_structures::indexed_vec::Idx;
 137                 //FIXME(#51314): remove this check
 138                 if source_info.scope.index() >= ivs.len() {
 139                     return None;
 140                 }
 141                 ivs[source_info.scope].lint_root
 142             },
 143             ClearCrossCrate::Clear => return None,
 144         };
 145         let r = match f(self) {
 146             Ok(val) => Some(val),
 147             Err(error) => {
 148                 let (stacktrace, span) = self.ecx.generate_stacktrace(None);
 149                 let diagnostic = ConstEvalErr { span, error, stacktrace };
 150                 use rustc::mir::interpret::EvalErrorKind::*;
 151                 match diagnostic.error.kind {
 152                     // don't report these, they make no sense in a const prop context
 153                     | MachineError(_)
 154                     // at runtime these transformations might make sense
 155                     // FIXME: figure out the rules and start linting
 156                     | FunctionPointerTyMismatch(..)
 157                     // fine at runtime, might be a register address or sth
 158                     | ReadBytesAsPointer
 159                     // fine at runtime
 160                     | ReadForeignStatic
 161                     | Unimplemented(_)
 162                     // don't report const evaluator limits
 163                     | StackFrameLimitReached
 164                     | NoMirFor(..)
 165                     | InlineAsm
 166                     => {},
 167
 168                     | InvalidMemoryAccess
 169                     | DanglingPointerDeref
 170                     | DoubleFree
 171                     | InvalidFunctionPointer
 172                     | InvalidBool
 173                     | InvalidDiscriminant
 174                     | PointerOutOfBounds { .. }
 175                     | InvalidNullPointerUsage
 176                     | MemoryLockViolation { .. }
 177                     | MemoryAcquireConflict { .. }
 178                     | ValidationFailure(..)
 179                     | InvalidMemoryLockRelease { .. }
 180                     | DeallocatedLockedMemory { .. }
 181                     | InvalidPointerMath
 182                     | ReadUndefBytes
 183                     | DeadLocal
 184                     | InvalidBoolOp(_)
 185                     | DerefFunctionPointer
 186                     | ExecuteMemory
 187                     | Intrinsic(..)
 188                     | InvalidChar(..)
 189                     | AbiViolation(_)
 190                     | AlignmentCheckFailed{..}
 191                     | CalledClosureAsFunction
 192                     | VtableForArgumentlessMethod
 193                     | ModifiedConstantMemory
 194                     | AssumptionNotHeld
 195                     // FIXME: should probably be removed and turned into a bug! call
 196                     | TypeNotPrimitive(_)
 197                     | ReallocatedWrongMemoryKind(_, _)
 198                     | DeallocatedWrongMemoryKind(_, _)
 199                     | ReallocateNonBasePtr
 200                     | DeallocateNonBasePtr
 201                     | IncorrectAllocationInformation(..)
 202                     | UnterminatedCString(_)
 203                     | HeapAllocZeroBytes
 204                     | HeapAllocNonPowerOfTwoAlignment(_)
 205                     | Unreachable
 206                     | ReadFromReturnPointer
 207                     | GeneratorResumedAfterReturn
 208                     | GeneratorResumedAfterPanic
 209                     | ReferencedConstant(_)
 210                     | InfiniteLoop
 211                     => {
 212                         // FIXME: report UB here
 213                     },
 214
 215                     | OutOfTls
 216                     | TlsOutOfBounds
 217                     | PathNotFound(_)
 218                     => bug!("these should not be in rustc, but in miri's machine errors"),
 219
 220                     | Layout(_)
 221                     | UnimplementedTraitSelection
 222                     | TypeckError
 223                     | TooGeneric
 224                     | CheckMatchError
 225                     // these are just noise
 226                     => {},
 227
 228                     // non deterministic
 229                     | ReadPointerAsBytes
 230                     // FIXME: implement
 231                     => {},
 232
 233                     | Panic
 234                     | BoundsCheck{..}
 235                     | Overflow(_)
 236                     | OverflowNeg
 237                     | DivisionByZero
 238                     | RemainderByZero
 239                     => {
 240                         diagnostic.report_as_lint(
 241                             self.ecx.tcx,
 242                             "this expression will panic at runtime",
 243                             lint_root,
 244                         );
 245                     }
 246                 }
 247                 None
 248             },
 249         };
 250         self.ecx.tcx.span = DUMMY_SP;
 251         r
 252     }
 253
 254     fn eval_constant(
 255         &mut self,
 256         c: &Constant<'tcx>,
 257         source_info: SourceInfo,
 258     ) -> Option<Const<'tcx>> {
 259         self.ecx.tcx.span = source_info.span;
 260         match self.ecx.const_to_value(c.literal.val) {
 261             Ok(val) => Some((val, c.literal.ty, c.span)),
 262             Err(error) => {
 263                 let (stacktrace, span) = self.ecx.generate_stacktrace(None);
 264                 let err = ConstEvalErr {
 265                     span,
 266                     error,
 267                     stacktrace,
 268                 };
 269                 err.report_as_error(
 270                     self.tcx.at(source_info.span),
 271                     "could not evaluate constant",
 272                 );
 273                 None
 274             },
 275         }
 276     }
 277
 278     fn eval_place(&mut self, place: &Place<'tcx>, source_info: SourceInfo) -> Option<Const<'tcx>> {
 279         match *place {
 280             Place::Local(loc) => self.places[loc].clone(),
 281             Place::Projection(ref proj) => match proj.elem {
 282                 ProjectionElem::Field(field, _) => {
 283                     trace!("field proj on {:?}", proj.base);
 284                     let (base, ty, span) = self.eval_place(&proj.base, source_info)?;
 285                     let valty = self.use_ecx(source_info, |this| {
 286                         this.ecx.read_field(base, None, field, ty)
 287                     })?;
 288                     Some((valty.value, valty.ty, span))
 289                 },
 290                 _ => None,
 291             },
 292             Place::Promoted(ref promoted) => {
 293                 let generics = self.tcx.generics_of(self.source.def_id);
 294                 if generics.requires_monomorphization(self.tcx) {
 295                     // FIXME: can't handle code with generics
 296                     return None;
 297                 }
 298                 let substs = Substs::identity_for_item(self.tcx, self.source.def_id);
 299                 let instance = Instance::new(self.source.def_id, substs);
 300                 let cid = GlobalId {
 301                     instance,
 302                     promoted: Some(promoted.0),
 303                 };
 304                 // cannot use `const_eval` here, because that would require having the MIR
 305                 // for the current function available, but we're producing said MIR right now
 306                 let (value, _, ty) = self.use_ecx(source_info, |this| {
 307                     eval_promoted(&mut this.ecx, cid, this.mir, this.param_env)
 308                 })?;
 309                 let val = (value, ty, source_info.span);
 310                 trace!("evaluated promoted {:?} to {:?}", promoted, val);
 311                 Some(val)
 312             },
 313             _ => None,
 314         }
 315     }
 316
 317     fn eval_operand(&mut self, op: &Operand<'tcx>, source_info: SourceInfo) -> Option<Const<'tcx>> {
 318         match *op {
 319             Operand::Constant(ref c) => self.eval_constant(c, source_info),
 320             | Operand::Move(ref place)
 321             | Operand::Copy(ref place) => self.eval_place(place, source_info),
 322         }
 323     }
 324
 325     fn const_prop(
 326         &mut self,
 327         rvalue: &Rvalue<'tcx>,
 328         place_ty: ty::Ty<'tcx>,
 329         source_info: SourceInfo,
 330     ) -> Option<Const<'tcx>> {
 331         let span = source_info.span;
 332         match *rvalue {
 333             // This branch exists for the sanity type check
 334             Rvalue::Use(Operand::Constant(ref c)) => {
 335                 assert_eq!(c.ty, place_ty);
 336                 self.eval_constant(c, source_info)
 337             },
 338             Rvalue::Use(ref op) => {
 339                 self.eval_operand(op, source_info)
 340             },
 341             Rvalue::Repeat(..) |
 342             Rvalue::Ref(..) |
 343             Rvalue::Aggregate(..) |
 344             Rvalue::NullaryOp(NullOp::Box, _) |
 345             Rvalue::Discriminant(..) => None,
 346
 347             Rvalue::Cast(kind, ref operand, _) => {
 348                 let (value, ty, span) = self.eval_operand(operand, source_info)?;
 349                 self.use_ecx(source_info, |this| {
 350                     let dest_ptr = this.ecx.alloc_ptr(place_ty)?;
 351                     let place_align = this.ecx.layout_of(place_ty)?.align;
 352                     let dest = ::interpret::Place::from_ptr(dest_ptr, place_align);
 353                     this.ecx.cast(ValTy { value, ty }, kind, place_ty, dest)?;
 354                     Ok((
 355                         Value::ByRef(dest_ptr.into(), place_align),
 356                         place_ty,
 357                         span,
 358                     ))
 359                 })
 360             }
 361
 362             // FIXME(oli-obk): evaluate static/constant slice lengths
 363             Rvalue::Len(_) => None,
 364             Rvalue::NullaryOp(NullOp::SizeOf, ty) => {
 365                 let param_env = self.tcx.param_env(self.source.def_id);
 366                 type_size_of(self.tcx, param_env, ty).map(|n| (
 367                     Value::Scalar(Scalar::Bits {
 368                         bits: n as u128,
 369                         defined: self.tcx.data_layout.pointer_size.bits() as u8,
 370                     }),
 371                     self.tcx.types.usize,
 372                     span,
 373                 ))
 374             }
 375             Rvalue::UnaryOp(op, ref arg) => {
 376                 let def_id = if self.tcx.is_closure(self.source.def_id) {
 377                     self.tcx.closure_base_def_id(self.source.def_id)
 378                 } else {
 379                     self.source.def_id
 380                 };
 381                 let generics = self.tcx.generics_of(def_id);
 382                 if generics.requires_monomorphization(self.tcx) {
 383                     // FIXME: can't handle code with generics
 384                     return None;
 385                 }
 386
 387                 let val = self.eval_operand(arg, source_info)?;
 388                 let prim = self.use_ecx(source_info, |this| {
 389                     this.ecx.value_to_scalar(ValTy { value: val.0, ty: val.1 })
 390                 })?;
 391                 let val = self.use_ecx(source_info, |this| this.ecx.unary_op(op, prim, val.1))?;
 392                 Some((Value::Scalar(val), place_ty, span))
 393             }
 394             Rvalue::CheckedBinaryOp(op, ref left, ref right) |
 395             Rvalue::BinaryOp(op, ref left, ref right) => {
 396                 trace!("rvalue binop {:?} for {:?} and {:?}", op, left, right);
 397                 let right = self.eval_operand(right, source_info)?;
 398                 let def_id = if self.tcx.is_closure(self.source.def_id) {
 399                     self.tcx.closure_base_def_id(self.source.def_id)
 400                 } else {
 401                     self.source.def_id
 402                 };
 403                 let generics = self.tcx.generics_of(def_id);
 404                 if generics.requires_monomorphization(self.tcx) {
 405                     // FIXME: can't handle code with generics
 406                     return None;
 407                 }
 408
 409                 let r = self.use_ecx(source_info, |this| {
 410                     this.ecx.value_to_scalar(ValTy { value: right.0, ty: right.1 })
 411                 })?;
 412                 if op == BinOp::Shr || op == BinOp::Shl {
 413                     let left_ty = left.ty(self.mir, self.tcx);
 414                     let left_bits = self
 415                         .tcx
 416                         .layout_of(self.param_env.and(left_ty))
 417                         .unwrap()
 418                         .size
 419                         .bits();
 420                     let right_size = self.tcx.layout_of(self.param_env.and(right.1)).unwrap().size;
 421                     if r.to_bits(right_size).ok().map_or(false, |b| b >= left_bits as u128) {
 422                         let source_scope_local_data = match self.mir.source_scope_local_data {
 423                             ClearCrossCrate::Set(ref data) => data,
 424                             ClearCrossCrate::Clear => return None,
 425                         };
 426                         let dir = if op == BinOp::Shr {
 427                             "right"
 428                         } else {
 429                             "left"
 430                         };
 431                         let node_id = source_scope_local_data[source_info.scope].lint_root;
 432                         self.tcx.lint_node(
 433                             ::rustc::lint::builtin::EXCEEDING_BITSHIFTS,
 434                             node_id,
 435                             span,
 436                             &format!("attempt to shift {} with overflow", dir));
 437                         return None;
 438                     }
 439                 }
 440                 let left = self.eval_operand(left, source_info)?;
 441                 let l = self.use_ecx(source_info, |this| {
 442                     this.ecx.value_to_scalar(ValTy { value: left.0, ty: left.1 })
 443                 })?;
 444                 trace!("const evaluating {:?} for {:?} and {:?}", op, left, right);
 445                 let (val, overflow) = self.use_ecx(source_info, |this| {
 446                     this.ecx.binary_op(op, l, left.1, r, right.1)
 447                 })?;
 448                 let val = if let Rvalue::CheckedBinaryOp(..) = *rvalue {
 449                     Value::ScalarPair(
 450                         val,
 451                         Scalar::from_bool(overflow),
 452                     )
 453                 } else {
 454                     if overflow {
 455                         let err = EvalErrorKind::Overflow(op).into();
 456                         let _: Option<()> = self.use_ecx(source_info, |_| Err(err));
 457                         return None;
 458                     }
 459                     Value::Scalar(val)
 460                 };
 461                 Some((val, place_ty, span))
 462             },
 463         }
 464     }
 465 }
 466
 467 fn type_size_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 468                           param_env: ty::ParamEnv<'tcx>,
 469                           ty: ty::Ty<'tcx>) -> Option<u64> {
 470     tcx.layout_of(param_env.and(ty)).ok().map(|layout| layout.size.bytes())
 471 }
 472
 473 struct CanConstProp {
 474     can_const_prop: IndexVec<Local, bool>,
 475     // false at the beginning, once set, there are not allowed to be any more assignments
 476     found_assignment: IndexVec<Local, bool>,
 477 }
 478
 479 impl CanConstProp {
 480     /// returns true if `local` can be propagated
 481     fn check(mir: &Mir) -> IndexVec<Local, bool> {
 482         let mut cpv = CanConstProp {
 483             can_const_prop: IndexVec::from_elem(true, &mir.local_decls),
 484             found_assignment: IndexVec::from_elem(false, &mir.local_decls),
 485         };
 486         for (local, val) in cpv.can_const_prop.iter_enumerated_mut() {
 487             // cannot use args at all
 488             // cannot use locals because if x < y { y - x } else { x - y } would
 489             //        lint for x != y
 490             // FIXME(oli-obk): lint variables until they are used in a condition
 491             // FIXME(oli-obk): lint if return value is constant
 492             *val = mir.local_kind(local) == LocalKind::Temp;
 493         }
 494         cpv.visit_mir(mir);
 495         cpv.can_const_prop
 496     }
 497 }
 498
 499 impl<'tcx> Visitor<'tcx> for CanConstProp {
 500     fn visit_local(
 501         &mut self,
 502         &local: &Local,
 503         context: PlaceContext<'tcx>,
 504         _: Location,
 505     ) {
 506         use rustc::mir::visit::PlaceContext::*;
 507         match context {
 508             // Constants must have at most one write
 509             // FIXME(oli-obk): we could be more powerful here, if the multiple writes
 510             // only occur in independent execution paths
 511             Store => if self.found_assignment[local] {
 512                 self.can_const_prop[local] = false;
 513             } else {
 514                 self.found_assignment[local] = true
 515             },
 516             // Reading constants is allowed an arbitrary number of times
 517             Copy | Move |
 518             StorageDead | StorageLive |
 519             Validate |
 520             Projection(_) |
 521             Inspect => {},
 522             _ => self.can_const_prop[local] = false,
 523         }
 524     }
 525 }
 526
 527 impl<'b, 'a, 'tcx> Visitor<'tcx> for ConstPropagator<'b, 'a, 'tcx> {
 528     fn visit_constant(
 529         &mut self,
 530         constant: &Constant<'tcx>,
 531         location: Location,
 532     ) {
 533         trace!("visit_constant: {:?}", constant);
 534         self.super_constant(constant, location);
 535         let source_info = *self.mir.source_info(location);
 536         self.eval_constant(constant, source_info);
 537     }
 538
 539     fn visit_statement(
 540         &mut self,
 541         block: BasicBlock,
 542         statement: &Statement<'tcx>,
 543         location: Location,
 544     ) {
 545         trace!("visit_statement: {:?}", statement);
 546         if let StatementKind::Assign(ref place, ref rval) = statement.kind {
 547             let place_ty = place
 548                 .ty(&self.mir.local_decls, self.tcx)
 549                 .to_ty(self.tcx);
 550             if let Some(value) = self.const_prop(rval, place_ty, statement.source_info) {
 551                 if let Place::Local(local) = *place {
 552                     trace!("checking whether {:?} can be stored to {:?}", value, local);
 553                     if self.can_const_prop[local] {
 554                         trace!("storing {:?} to {:?}", value, local);
 555                         assert!(self.places[local].is_none());
 556                         self.places[local] = Some(value);
 557                     }
 558                 }
 559             }
 560         }
 561         self.super_statement(block, statement, location);
 562     }
 563
 564     fn visit_terminator_kind(
 565         &mut self,
 566         block: BasicBlock,
 567         kind: &TerminatorKind<'tcx>,
 568         location: Location,
 569     ) {
 570         self.super_terminator_kind(block, kind, location);
 571         let source_info = *self.mir.source_info(location);
 572         if let TerminatorKind::Assert { expected, msg, cond, .. } = kind {
 573             if let Some(value) = self.eval_operand(cond, source_info) {
 574                 trace!("assertion on {:?} should be {:?}", value, expected);
 575                 if Value::Scalar(Scalar::from_bool(*expected)) != value.0 {
 576                     // poison all places this operand references so that further code
 577                     // doesn't use the invalid value
 578                     match cond {
 579                         Operand::Move(ref place) | Operand::Copy(ref place) => {
 580                             let mut place = place;
 581                             while let Place::Projection(ref proj) = *place {
 582                                 place = &proj.base;
 583                             }
 584                             if let Place::Local(local) = *place {
 585                                 self.places[local] = None;
 586                             }
 587                         },
 588                         Operand::Constant(_) => {}
 589                     }
 590                     let span = self.mir[block]
 591                         .terminator
 592                         .as_ref()
 593                         .unwrap()
 594                         .source_info
 595                         .span;
 596                     let node_id = self
 597                         .tcx
 598                         .hir
 599                         .as_local_node_id(self.source.def_id)
 600                         .expect("some part of a failing const eval must be local");
 601                     use rustc::mir::interpret::EvalErrorKind::*;
 602                     let msg = match msg {
 603                         Overflow(_) |
 604                         OverflowNeg |
 605                         DivisionByZero |
 606                         RemainderByZero => msg.description().to_owned(),
 607                         BoundsCheck { ref len, ref index } => {
 608                             let len = self
 609                                 .eval_operand(len, source_info)
 610                                 .expect("len must be const");
 611                             let len = match len.0 {
 612                                 Value::Scalar(Scalar::Bits { bits, ..}) => bits,
 613                                 _ => bug!("const len not primitive: {:?}", len),
 614                             };
 615                             let index = self
 616                                 .eval_operand(index, source_info)
 617                                 .expect("index must be const");
 618                             let index = match index.0 {
 619                                 Value::Scalar(Scalar::Bits { bits, .. }) => bits,
 620                                 _ => bug!("const index not primitive: {:?}", index),
 621                             };
 622                             format!(
 623                                 "index out of bounds: \
 624                                 the len is {} but the index is {}",
 625                                 len,
 626                                 index,
 627                             )
 628                         },
 629                         // Need proper const propagator for these
 630                         _ => return,
 631                     };
 632                     self.tcx.lint_node(
 633                         ::rustc::lint::builtin::CONST_ERR,
 634                         node_id,
 635                         span,
 636                         &msg,
 637                     );
 638                 }
 639             }
 640         }
 641     }
 642 }