compiler/rustc_const_eval/src/const_eval/machine.rs

   1 use rustc_middle::mir;
   2 use rustc_middle::ty::{self, Ty};
   3 use std::borrow::Borrow;
   4 use std::collections::hash_map::Entry;
   5 use std::hash::Hash;
   6
   7 use rustc_data_structures::fx::FxHashMap;
   8 use std::fmt;
   9
  10 use rustc_ast::Mutability;
  11 use rustc_hir::def_id::DefId;
  12 use rustc_middle::mir::AssertMessage;
  13 use rustc_session::Limit;
  14 use rustc_span::symbol::{sym, Symbol};
  15 use rustc_target::abi::{Align, Size};
  16 use rustc_target::spec::abi::Abi;
  17
  18 use crate::interpret::{
  19     self, compile_time_machine, AllocId, Allocation, Frame, ImmTy, InterpCx, InterpResult, OpTy,
  20     PlaceTy, Scalar, StackPopUnwind,
  21 };
  22
  23 use super::error::*;
  24
  25 impl<'mir, 'tcx> InterpCx<'mir, 'tcx, CompileTimeInterpreter<'mir, 'tcx>> {
  26     /// "Intercept" a function call to a panic-related function
  27     /// because we have something special to do for it.
  28     /// If this returns successfully (`Ok`), the function should just be evaluated normally.
  29     fn hook_special_const_fn(
  30         &mut self,
  31         instance: ty::Instance<'tcx>,
  32         args: &[OpTy<'tcx>],
  33     ) -> InterpResult<'tcx, Option<ty::Instance<'tcx>>> {
  34         // All `#[rustc_do_not_const_check]` functions should be hooked here.
  35         let def_id = instance.def_id();
  36
  37         if Some(def_id) == self.tcx.lang_items().const_eval_select() {
  38             // redirect to const_eval_select_ct
  39             if let Some(const_eval_select) = self.tcx.lang_items().const_eval_select_ct() {
  40                 return Ok(Some(
  41                     ty::Instance::resolve(
  42                         *self.tcx,
  43                         ty::ParamEnv::reveal_all(),
  44                         const_eval_select,
  45                         instance.substs,
  46                     )
  47                     .unwrap()
  48                     .unwrap(),
  49                 ));
  50             }
  51         } else if Some(def_id) == self.tcx.lang_items().panic_display()
  52             || Some(def_id) == self.tcx.lang_items().begin_panic_fn()
  53         {
  54             // &str or &&str
  55             assert!(args.len() == 1);
  56
  57             let mut msg_place = self.deref_operand(&args[0])?;
  58             while msg_place.layout.ty.is_ref() {
  59                 msg_place = self.deref_operand(&msg_place.into())?;
  60             }
  61
  62             let msg = Symbol::intern(self.read_str(&msg_place)?);
  63             let span = self.find_closest_untracked_caller_location();
  64             let (file, line, col) = self.location_triple_for_span(span);
  65             return Err(ConstEvalErrKind::Panic { msg, file, line, col }.into());
  66         } else if Some(def_id) == self.tcx.lang_items().panic_fmt() {
  67             // For panic_fmt, call const_panic_fmt instead.
  68             if let Some(const_panic_fmt) = self.tcx.lang_items().const_panic_fmt() {
  69                 return Ok(Some(
  70                     ty::Instance::resolve(
  71                         *self.tcx,
  72                         ty::ParamEnv::reveal_all(),
  73                         const_panic_fmt,
  74                         self.tcx.intern_substs(&[]),
  75                     )
  76                     .unwrap()
  77                     .unwrap(),
  78                 ));
  79             }
  80         }
  81         Ok(None)
  82     }
  83 }
  84
  85 /// Extra machine state for CTFE, and the Machine instance
  86 pub struct CompileTimeInterpreter<'mir, 'tcx> {
  87     /// For now, the number of terminators that can be evaluated before we throw a resource
  88     /// exhaustion error.
  89     ///
  90     /// Setting this to `0` disables the limit and allows the interpreter to run forever.
  91     pub steps_remaining: usize,
  92
  93     /// The virtual call stack.
  94     pub(crate) stack: Vec<Frame<'mir, 'tcx, AllocId, ()>>,
  95 }
  96
  97 #[derive(Copy, Clone, Debug)]
  98 pub struct MemoryExtra {
  99     /// We need to make sure consts never point to anything mutable, even recursively. That is
 100     /// relied on for pattern matching on consts with references.
 101     /// To achieve this, two pieces have to work together:
 102     /// * Interning makes everything outside of statics immutable.
 103     /// * Pointers to allocations inside of statics can never leak outside, to a non-static global.
 104     /// This boolean here controls the second part.
 105     pub(super) can_access_statics: bool,
 106 }
 107
 108 impl<'mir, 'tcx> CompileTimeInterpreter<'mir, 'tcx> {
 109     pub(super) fn new(const_eval_limit: Limit) -> Self {
 110         CompileTimeInterpreter { steps_remaining: const_eval_limit.0, stack: Vec::new() }
 111     }
 112 }
 113
 114 impl<K: Hash + Eq, V> interpret::AllocMap<K, V> for FxHashMap<K, V> {
 115     #[inline(always)]
 116     fn contains_key<Q: ?Sized + Hash + Eq>(&mut self, k: &Q) -> bool
 117     where
 118         K: Borrow<Q>,
 119     {
 120         FxHashMap::contains_key(self, k)
 121     }
 122
 123     #[inline(always)]
 124     fn insert(&mut self, k: K, v: V) -> Option<V> {
 125         FxHashMap::insert(self, k, v)
 126     }
 127
 128     #[inline(always)]
 129     fn remove<Q: ?Sized + Hash + Eq>(&mut self, k: &Q) -> Option<V>
 130     where
 131         K: Borrow<Q>,
 132     {
 133         FxHashMap::remove(self, k)
 134     }
 135
 136     #[inline(always)]
 137     fn filter_map_collect<T>(&self, mut f: impl FnMut(&K, &V) -> Option<T>) -> Vec<T> {
 138         self.iter().filter_map(move |(k, v)| f(k, &*v)).collect()
 139     }
 140
 141     #[inline(always)]
 142     fn get_or<E>(&self, k: K, vacant: impl FnOnce() -> Result<V, E>) -> Result<&V, E> {
 143         match self.get(&k) {
 144             Some(v) => Ok(v),
 145             None => {
 146                 vacant()?;
 147                 bug!("The CTFE machine shouldn't ever need to extend the alloc_map when reading")
 148             }
 149         }
 150     }
 151
 152     #[inline(always)]
 153     fn get_mut_or<E>(&mut self, k: K, vacant: impl FnOnce() -> Result<V, E>) -> Result<&mut V, E> {
 154         match self.entry(k) {
 155             Entry::Occupied(e) => Ok(e.into_mut()),
 156             Entry::Vacant(e) => {
 157                 let v = vacant()?;
 158                 Ok(e.insert(v))
 159             }
 160         }
 161     }
 162 }
 163
 164 crate type CompileTimeEvalContext<'mir, 'tcx> =
 165     InterpCx<'mir, 'tcx, CompileTimeInterpreter<'mir, 'tcx>>;
 166
 167 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
 168 pub enum MemoryKind {
 169     Heap,
 170 }
 171
 172 impl fmt::Display for MemoryKind {
 173     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 174         match self {
 175             MemoryKind::Heap => write!(f, "heap allocation"),
 176         }
 177     }
 178 }
 179
 180 impl interpret::MayLeak for MemoryKind {
 181     #[inline(always)]
 182     fn may_leak(self) -> bool {
 183         match self {
 184             MemoryKind::Heap => false,
 185         }
 186     }
 187 }
 188
 189 impl interpret::MayLeak for ! {
 190     #[inline(always)]
 191     fn may_leak(self) -> bool {
 192         // `self` is uninhabited
 193         self
 194     }
 195 }
 196
 197 impl<'mir, 'tcx: 'mir> CompileTimeEvalContext<'mir, 'tcx> {
 198     fn guaranteed_eq(&mut self, a: Scalar, b: Scalar) -> bool {
 199         match (a, b) {
 200             // Comparisons between integers are always known.
 201             (Scalar::Int { .. }, Scalar::Int { .. }) => a == b,
 202             // Equality with integers can never be known for sure.
 203             (Scalar::Int { .. }, Scalar::Ptr(..)) | (Scalar::Ptr(..), Scalar::Int { .. }) => false,
 204             // FIXME: return `true` for when both sides are the same pointer, *except* that
 205             // some things (like functions and vtables) do not have stable addresses
 206             // so we need to be careful around them (see e.g. #73722).
 207             (Scalar::Ptr(..), Scalar::Ptr(..)) => false,
 208         }
 209     }
 210
 211     fn guaranteed_ne(&mut self, a: Scalar, b: Scalar) -> bool {
 212         match (a, b) {
 213             // Comparisons between integers are always known.
 214             (Scalar::Int(_), Scalar::Int(_)) => a != b,
 215             // Comparisons of abstract pointers with null pointers are known if the pointer
 216             // is in bounds, because if they are in bounds, the pointer can't be null.
 217             // Inequality with integers other than null can never be known for sure.
 218             (Scalar::Int(int), Scalar::Ptr(ptr, _)) | (Scalar::Ptr(ptr, _), Scalar::Int(int)) => {
 219                 int.is_null() && !self.memory.ptr_may_be_null(ptr.into())
 220             }
 221             // FIXME: return `true` for at least some comparisons where we can reliably
 222             // determine the result of runtime inequality tests at compile-time.
 223             // Examples include comparison of addresses in different static items.
 224             (Scalar::Ptr(..), Scalar::Ptr(..)) => false,
 225         }
 226     }
 227 }
 228
 229 impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir, 'tcx> {
 230     compile_time_machine!(<'mir, 'tcx>);
 231
 232     type MemoryKind = MemoryKind;
 233
 234     type MemoryExtra = MemoryExtra;
 235
 236     const PANIC_ON_ALLOC_FAIL: bool = false; // will be raised as a proper error
 237
 238     fn load_mir(
 239         ecx: &InterpCx<'mir, 'tcx, Self>,
 240         instance: ty::InstanceDef<'tcx>,
 241     ) -> InterpResult<'tcx, &'tcx mir::Body<'tcx>> {
 242         match instance {
 243             ty::InstanceDef::Item(def) => {
 244                 if ecx.tcx.is_ctfe_mir_available(def.did) {
 245                     Ok(ecx.tcx.mir_for_ctfe_opt_const_arg(def))
 246                 } else {
 247                     let path = ecx.tcx.def_path_str(def.did);
 248                     Err(ConstEvalErrKind::NeedsRfc(format!("calling extern function `{}`", path))
 249                         .into())
 250                 }
 251             }
 252             _ => Ok(ecx.tcx.instance_mir(instance)),
 253         }
 254     }
 255
 256     fn find_mir_or_eval_fn(
 257         ecx: &mut InterpCx<'mir, 'tcx, Self>,
 258         instance: ty::Instance<'tcx>,
 259         _abi: Abi,
 260         args: &[OpTy<'tcx>],
 261         _ret: Option<(&PlaceTy<'tcx>, mir::BasicBlock)>,
 262         _unwind: StackPopUnwind, // unwinding is not supported in consts
 263     ) -> InterpResult<'tcx, Option<&'mir mir::Body<'tcx>>> {
 264         debug!("find_mir_or_eval_fn: {:?}", instance);
 265
 266         // Only check non-glue functions
 267         if let ty::InstanceDef::Item(def) = instance.def {
 268             // Execution might have wandered off into other crates, so we cannot do a stability-
 269             // sensitive check here.  But we can at least rule out functions that are not const
 270             // at all.
 271             if !ecx.tcx.is_const_fn_raw(def.did) {
 272                 // allow calling functions marked with #[default_method_body_is_const].
 273                 if !ecx.tcx.has_attr(def.did, sym::default_method_body_is_const) {
 274                     // We certainly do *not* want to actually call the fn
 275                     // though, so be sure we return here.
 276                     throw_unsup_format!("calling non-const function `{}`", instance)
 277                 }
 278             }
 279
 280             if let Some(new_instance) = ecx.hook_special_const_fn(instance, args)? {
 281                 // We call another const fn instead.
 282                 return Self::find_mir_or_eval_fn(ecx, new_instance, _abi, args, _ret, _unwind);
 283             }
 284         }
 285         // This is a const fn. Call it.
 286         Ok(Some(ecx.load_mir(instance.def, None)?))
 287     }
 288
 289     fn call_intrinsic(
 290         ecx: &mut InterpCx<'mir, 'tcx, Self>,
 291         instance: ty::Instance<'tcx>,
 292         args: &[OpTy<'tcx>],
 293         ret: Option<(&PlaceTy<'tcx>, mir::BasicBlock)>,
 294         _unwind: StackPopUnwind,
 295     ) -> InterpResult<'tcx> {
 296         // Shared intrinsics.
 297         if ecx.emulate_intrinsic(instance, args, ret)? {
 298             return Ok(());
 299         }
 300         let intrinsic_name = ecx.tcx.item_name(instance.def_id());
 301
 302         // CTFE-specific intrinsics.
 303         let (dest, ret) = match ret {
 304             None => {
 305                 return Err(ConstEvalErrKind::NeedsRfc(format!(
 306                     "calling intrinsic `{}`",
 307                     intrinsic_name
 308                 ))
 309                 .into());
 310             }
 311             Some(p) => p,
 312         };
 313         match intrinsic_name {
 314             sym::ptr_guaranteed_eq | sym::ptr_guaranteed_ne => {
 315                 let a = ecx.read_immediate(&args[0])?.to_scalar()?;
 316                 let b = ecx.read_immediate(&args[1])?.to_scalar()?;
 317                 let cmp = if intrinsic_name == sym::ptr_guaranteed_eq {
 318                     ecx.guaranteed_eq(a, b)
 319                 } else {
 320                     ecx.guaranteed_ne(a, b)
 321                 };
 322                 ecx.write_scalar(Scalar::from_bool(cmp), dest)?;
 323             }
 324             sym::const_allocate => {
 325                 let size = ecx.read_scalar(&args[0])?.to_machine_usize(ecx)?;
 326                 let align = ecx.read_scalar(&args[1])?.to_machine_usize(ecx)?;
 327
 328                 let align = match Align::from_bytes(align) {
 329                     Ok(a) => a,
 330                     Err(err) => throw_ub_format!("align has to be a power of 2, {}", err),
 331                 };
 332
 333                 let ptr = ecx.memory.allocate(
 334                     Size::from_bytes(size as u64),
 335                     align,
 336                     interpret::MemoryKind::Machine(MemoryKind::Heap),
 337                 )?;
 338                 ecx.write_pointer(ptr, dest)?;
 339             }
 340             _ => {
 341                 return Err(ConstEvalErrKind::NeedsRfc(format!(
 342                     "calling intrinsic `{}`",
 343                     intrinsic_name
 344                 ))
 345                 .into());
 346             }
 347         }
 348
 349         ecx.go_to_block(ret);
 350         Ok(())
 351     }
 352
 353     fn assert_panic(
 354         ecx: &mut InterpCx<'mir, 'tcx, Self>,
 355         msg: &AssertMessage<'tcx>,
 356         _unwind: Option<mir::BasicBlock>,
 357     ) -> InterpResult<'tcx> {
 358         use rustc_middle::mir::AssertKind::*;
 359         // Convert `AssertKind<Operand>` to `AssertKind<Scalar>`.
 360         let eval_to_int =
 361             |op| ecx.read_immediate(&ecx.eval_operand(op, None)?).map(|x| x.to_const_int());
 362         let err = match msg {
 363             BoundsCheck { ref len, ref index } => {
 364                 let len = eval_to_int(len)?;
 365                 let index = eval_to_int(index)?;
 366                 BoundsCheck { len, index }
 367             }
 368             Overflow(op, l, r) => Overflow(*op, eval_to_int(l)?, eval_to_int(r)?),
 369             OverflowNeg(op) => OverflowNeg(eval_to_int(op)?),
 370             DivisionByZero(op) => DivisionByZero(eval_to_int(op)?),
 371             RemainderByZero(op) => RemainderByZero(eval_to_int(op)?),
 372             ResumedAfterReturn(generator_kind) => ResumedAfterReturn(*generator_kind),
 373             ResumedAfterPanic(generator_kind) => ResumedAfterPanic(*generator_kind),
 374         };
 375         Err(ConstEvalErrKind::AssertFailure(err).into())
 376     }
 377
 378     fn abort(_ecx: &mut InterpCx<'mir, 'tcx, Self>, msg: String) -> InterpResult<'tcx, !> {
 379         Err(ConstEvalErrKind::Abort(msg).into())
 380     }
 381
 382     fn binary_ptr_op(
 383         _ecx: &InterpCx<'mir, 'tcx, Self>,
 384         _bin_op: mir::BinOp,
 385         _left: &ImmTy<'tcx>,
 386         _right: &ImmTy<'tcx>,
 387     ) -> InterpResult<'tcx, (Scalar, bool, Ty<'tcx>)> {
 388         Err(ConstEvalErrKind::NeedsRfc("pointer arithmetic or comparison".to_string()).into())
 389     }
 390
 391     fn box_alloc(
 392         _ecx: &mut InterpCx<'mir, 'tcx, Self>,
 393         _dest: &PlaceTy<'tcx>,
 394     ) -> InterpResult<'tcx> {
 395         Err(ConstEvalErrKind::NeedsRfc("heap allocations via `box` keyword".to_string()).into())
 396     }
 397
 398     fn before_terminator(ecx: &mut InterpCx<'mir, 'tcx, Self>) -> InterpResult<'tcx> {
 399         // The step limit has already been hit in a previous call to `before_terminator`.
 400         if ecx.machine.steps_remaining == 0 {
 401             return Ok(());
 402         }
 403
 404         ecx.machine.steps_remaining -= 1;
 405         if ecx.machine.steps_remaining == 0 {
 406             throw_exhaust!(StepLimitReached)
 407         }
 408
 409         Ok(())
 410     }
 411
 412     #[inline(always)]
 413     fn init_frame_extra(
 414         ecx: &mut InterpCx<'mir, 'tcx, Self>,
 415         frame: Frame<'mir, 'tcx>,
 416     ) -> InterpResult<'tcx, Frame<'mir, 'tcx>> {
 417         // Enforce stack size limit. Add 1 because this is run before the new frame is pushed.
 418         if !ecx.recursion_limit.value_within_limit(ecx.stack().len() + 1) {
 419             throw_exhaust!(StackFrameLimitReached)
 420         } else {
 421             Ok(frame)
 422         }
 423     }
 424
 425     #[inline(always)]
 426     fn stack(
 427         ecx: &'a InterpCx<'mir, 'tcx, Self>,
 428     ) -> &'a [Frame<'mir, 'tcx, Self::PointerTag, Self::FrameExtra>] {
 429         &ecx.machine.stack
 430     }
 431
 432     #[inline(always)]
 433     fn stack_mut(
 434         ecx: &'a mut InterpCx<'mir, 'tcx, Self>,
 435     ) -> &'a mut Vec<Frame<'mir, 'tcx, Self::PointerTag, Self::FrameExtra>> {
 436         &mut ecx.machine.stack
 437     }
 438
 439     fn before_access_global(
 440         memory_extra: &MemoryExtra,
 441         alloc_id: AllocId,
 442         allocation: &Allocation,
 443         static_def_id: Option<DefId>,
 444         is_write: bool,
 445     ) -> InterpResult<'tcx> {
 446         if is_write {
 447             // Write access. These are never allowed, but we give a targeted error message.
 448             if allocation.mutability == Mutability::Not {
 449                 Err(err_ub!(WriteToReadOnly(alloc_id)).into())
 450             } else {
 451                 Err(ConstEvalErrKind::ModifiedGlobal.into())
 452             }
 453         } else {
 454             // Read access. These are usually allowed, with some exceptions.
 455             if memory_extra.can_access_statics {
 456                 // Machine configuration allows us read from anything (e.g., `static` initializer).
 457                 Ok(())
 458             } else if static_def_id.is_some() {
 459                 // Machine configuration does not allow us to read statics
 460                 // (e.g., `const` initializer).
 461                 // See const_eval::machine::MemoryExtra::can_access_statics for why
 462                 // this check is so important: if we could read statics, we could read pointers
 463                 // to mutable allocations *inside* statics. These allocations are not themselves
 464                 // statics, so pointers to them can get around the check in `validity.rs`.
 465                 Err(ConstEvalErrKind::ConstAccessesStatic.into())
 466             } else {
 467                 // Immutable global, this read is fine.
 468                 // But make sure we never accept a read from something mutable, that would be
 469                 // unsound. The reason is that as the content of this allocation may be different
 470                 // now and at run-time, so if we permit reading now we might return the wrong value.
 471                 assert_eq!(allocation.mutability, Mutability::Not);
 472                 Ok(())
 473             }
 474         }
 475     }
 476 }
 477
 478 // Please do not add any code below the above `Machine` trait impl. I (oli-obk) plan more cleanups
 479 // so we can end up having a file with just that impl, but for now, let's keep the impl discoverable
 480 // at the bottom of this file.