introduce Reveal::Selection and deduplication for eval const queries

Author: b-naber

compiler/rustc_middle/src/mir/interpret/mod.rs

@@ -95,8 +95,10 @@ mod pointer;
 mod queries;
 mod value;
 
+use std::cell::RefCell;
 use std::convert::TryFrom;
 use std::fmt;
+use std::fmt::Debug;
 use std::io;
 use std::io::{Read, Write};
 use std::num::{NonZeroU32, NonZeroU64};
@@ -106,10 +108,13 @@ use rustc_ast::LitKind;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::sync::{HashMapExt, Lock};
 use rustc_data_structures::tiny_list::TinyList;
+use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
-use rustc_macros::HashStable;
+use rustc_hir::definitions::DefPathData;
+use rustc_middle::traits::Reveal;
 use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_serialize::{Decodable, Encodable};
+use rustc_span::{Pos, Span};
 use rustc_target::abi::Endian;
 
 use crate::mir;
@@ -446,6 +451,88 @@ impl<'tcx> AllocMap<'tcx> {
     }
 }
 
+/// What we store about a frame in an interpreter backtrace.
+#[derive(Debug)]
+pub struct FrameInfo<'tcx> {
+    pub instance: ty::Instance<'tcx>,
+    pub span: Span,
+    pub lint_root: Option<hir::HirId>,
+}
+
+impl<'tcx> fmt::Display for FrameInfo<'tcx> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        ty::tls::with(|tcx| {
+            if tcx.def_key(self.instance.def_id()).disambiguated_data.data
+                == DefPathData::ClosureExpr
+            {
+                write!(f, "inside closure")?;
+            } else {
+                write!(f, "inside `{}`", self.instance)?;
+            }
+            if !self.span.is_dummy() {
+                let sm = tcx.sess.source_map();
+                let lo = sm.lookup_char_pos(self.span.lo());
+                write!(
+                    f,
+                    " at {}:{}:{}",
+                    sm.filename_for_diagnostics(&lo.file.name),
+                    lo.line,
+                    lo.col.to_usize() + 1
+                )?;
+            }
+            Ok(())
+        })
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum ConstDedupResult<T: Clone + Copy + Debug> {
+    Selection(T),
+    UserFacing(T),
+    All(T),
+}
+
+impl<T: Clone + Copy + Debug> ConstDedupResult<T> {
+    pub fn new(reveal: Reveal, val: T) -> Self {
+        match reveal {
+            Reveal::Selection => ConstDedupResult::Selection(val),
+            Reveal::UserFacing => ConstDedupResult::UserFacing(val),
+            Reveal::All => ConstDedupResult::All(val),
+        }
+    }
+}
+
+/// Used to store results of calls to `eval_to_allocation_raw` and
+/// `eval_to_const_value_raw`.
+#[derive(Debug)]
+pub struct ConstDedupMap<'tcx> {
+    // interning for deduplication of `eval_to_allocation_raw`
+    pub alloc_map: RefCell<FxHashMap<GlobalId<'tcx>, ConstDedupResult<ConstAlloc<'tcx>>>>,
+
+    // interning for deduplication of `eval_to_const_value_raw`
+    pub const_val_map: RefCell<FxHashMap<GlobalId<'tcx>, ConstDedupResult<ConstValue<'tcx>>>>,
+}
+
+impl<'tcx> ConstDedupMap<'tcx> {
+    pub fn new() -> Self {
+        ConstDedupMap { alloc_map: Default::default(), const_val_map: Default::default() }
+    }
+
+    #[instrument(skip(self), level = "debug")]
+    fn insert_alloc(&self, id: GlobalId<'tcx>, val: ConstDedupResult<ConstAlloc<'tcx>>) {
+        let mut alloc_map = self.alloc_map.borrow_mut();
+        alloc_map.insert(id, val);
+        debug!("alloc_map after update: {:#?}", alloc_map);
+    }
+
+    #[instrument(skip(self), level = "debug")]
+    fn insert_const_val(&self, id: GlobalId<'tcx>, val: ConstDedupResult<ConstValue<'tcx>>) {
+        let mut const_val_map = self.const_val_map.borrow_mut();
+        const_val_map.insert(id, val);
+        debug!("const_val_map after update: {:#?}", const_val_map);
+    }
+}
+
 impl<'tcx> TyCtxt<'tcx> {
     /// Obtains a new allocation ID that can be referenced but does not
     /// yet have an allocation backing it.
@@ -554,6 +641,129 @@ impl<'tcx> TyCtxt<'tcx> {
     fn set_alloc_id_same_memory(self, id: AllocId, mem: &'tcx Allocation) {
         self.alloc_map.lock().alloc_map.insert_same(id, GlobalAlloc::Memory(mem));
     }
+
+    /// Store the result of a call to `eval_to_allocation_raw` in order to
+    /// allow deduplication.
+    #[instrument(skip(self), level = "debug")]
+    pub fn save_alloc_for_dedup(self, id: GlobalId<'tcx>, val: ConstDedupResult<ConstAlloc<'tcx>>) {
+        let dedup_const_map = self.dedup_const_map.lock();
+        dedup_const_map.insert_alloc(id, val);
+        debug!("dedup_const_map after insert: {:#?}", dedup_const_map);
+    }
+
+    /// Store the result of a call to `eval_to_const_value_raw` in order to deduplicate it.
+    #[instrument(skip(self), level = "debug")]
+    pub fn save_const_value_for_dedup(
+        self,
+        id: GlobalId<'tcx>,
+        val: ConstDedupResult<ConstValue<'tcx>>,
+    ) {
+        let dedup_const_map = self.dedup_const_map.lock();
+        dedup_const_map.insert_const_val(id, val);
+        debug!("dedup_const_map after insert: {:#?}", dedup_const_map);
+    }
+
+    /// Tries to deduplicate a call to `eval_to_allocation_raw`. If deduplication isn't
+    /// successful `eval_to_allocation_raw` query is executed.
+    #[instrument(skip(self, opt_span), level = "debug")]
+    pub fn dedup_eval_alloc_raw(
+        self,
+        key: ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>,
+        opt_span: Option<Span>,
+    ) -> EvalToAllocationRawResult<'tcx> {
+        use ConstDedupResult::*;
+
+        let (param_env, id) = key.into_parts();
+        let dedup_const_map = self.dedup_const_map.lock();
+        debug!("dedup_const_map: {:#?}", dedup_const_map);
+        let alloc_map = dedup_const_map.alloc_map.borrow();
+        debug!("alloc_map: {:#?}", alloc_map);
+
+        let dedup_result = alloc_map.get(&id);
+        debug!(?dedup_result);
+
+        match param_env.reveal() {
+            Reveal::Selection => match dedup_result {
+                Some(Selection(alloc) | UserFacing(alloc)) => return Ok(*alloc),
+                _ => {}
+            },
+            Reveal::UserFacing => match dedup_result {
+                Some(Selection(alloc) | UserFacing(alloc)) => {
+                    return Ok(*alloc);
+                }
+                _ => {}
+            },
+            Reveal::All => match dedup_result {
+                Some(Selection(alloc) | UserFacing(alloc) | All(alloc)) => {
+                    return Ok(*alloc);
+                }
+                _ => {}
+            },
+        }
+
+        // Important to drop the lock here
+        drop(alloc_map);
+        drop(dedup_const_map);
+
+        debug!("unable to deduplicate");
+
+        // We weren't able to deduplicate
+        match opt_span {
+            Some(span) => self.at(span).eval_to_allocation_raw(key),
+            None => self.eval_to_allocation_raw(key),
+        }
+    }
+
+    /// Tries to deduplicate a call to `eval_to_const_value_raw`. If deduplication isn't
+    /// successful, `eval_to_const_value_raw` query is executed.
+    #[instrument(skip(self), level = "debug")]
+    pub fn dedup_eval_const_value_raw(
+        self,
+        key: ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>,
+        opt_span: Option<Span>,
+    ) -> EvalToConstValueResult<'tcx> {
+        use ConstDedupResult::*;
+
+        let (param_env, id) = key.into_parts();
+        let dedup_const_map = self.dedup_const_map.lock();
+        debug!("dedup_const_map: {:#?}", dedup_const_map);
+        let const_val_map = dedup_const_map.const_val_map.borrow();
+        debug!("const_val_map: {:#?}", const_val_map);
+
+        let dedup_result = const_val_map.get(&id);
+        debug!(?dedup_result);
+
+        match param_env.reveal() {
+            Reveal::Selection => match dedup_result {
+                Some(Selection(const_val) | UserFacing(const_val)) => return Ok(*const_val),
+                _ => {}
+            },
+            Reveal::UserFacing => match dedup_result {
+                Some(Selection(const_value) | UserFacing(const_value)) => {
+                    return Ok(*const_value);
+                }
+                _ => {}
+            },
+            Reveal::All => match dedup_result {
+                Some(Selection(const_value) | UserFacing(const_value) | All(const_value)) => {
+                    return Ok(*const_value);
+                }
+                _ => {}
+            },
+        }
+
+        // Important to drop the lock here
+        drop(const_val_map);
+        drop(dedup_const_map);
+
+        debug!("unable to deduplicate");
+
+        // We weren't able to deduplicate
+        match opt_span {
+            Some(span) => self.at(span).eval_to_const_value_raw(key),
+            None => self.eval_to_const_value_raw(key),
+        }
+    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////

compiler/rustc_middle/src/ty/consts/kind.rs

@@ -3,6 +3,7 @@ use std::fmt;
 
 use crate::mir::interpret::{AllocId, ConstValue, Scalar};
 use crate::mir::Promoted;
+use crate::traits::Reveal;
 use crate::ty::subst::{InternalSubsts, SubstsRef};
 use crate::ty::ParamEnv;
 use crate::ty::{self, TyCtxt, TypeFoldable};
@@ -160,10 +161,15 @@ impl<'tcx> ConstKind<'tcx> {
             // Note that we erase regions *before* calling `with_reveal_all_normalized`,
             // so that we don't try to invoke this query with
             // any region variables.
-            let param_env_and = tcx
-                .erase_regions(param_env)
-                .with_reveal_all_normalized(tcx)
-                .and(tcx.erase_regions(unevaluated));
+            let param_env_and = match param_env.reveal() {
+                Reveal::Selection => {
+                    tcx.erase_regions(param_env).and(tcx.erase_regions(unevaluated))
+                }
+                _ => tcx
+                    .erase_regions(param_env)
+                    .with_reveal_all_normalized(tcx)
+                    .and(tcx.erase_regions(unevaluated)),
+            };
 
             // HACK(eddyb) when the query key would contain inference variables,
             // attempt using identity substs and `ParamEnv` instead, that will succeed

compiler/rustc_middle/src/ty/context.rs

@@ -1043,6 +1043,10 @@ pub struct GlobalCtxt<'tcx> {
     /// Stores memory for globals (statics/consts).
     pub(crate) alloc_map: Lock<interpret::AllocMap<'tcx>>,
 
+    /// Used to deduplicate calls to `eval_to_allocation_raw` and
+    /// `eval_to_const_value_raw`.
+    pub dedup_const_map: Lock<interpret::ConstDedupMap<'tcx>>,
+
     output_filenames: Arc<OutputFilenames>,
 }
 
@@ -1187,6 +1191,7 @@ impl<'tcx> TyCtxt<'tcx> {
             stability_interner: Default::default(),
             const_stability_interner: Default::default(),
             alloc_map: Lock::new(interpret::AllocMap::new()),
+            dedup_const_map: Lock::new(interpret::ConstDedupMap::new()),
             output_filenames: Arc::new(output_filenames),
         }
     }

compiler/rustc_middle/src/ty/mod.rs

@@ -150,11 +150,7 @@ pub struct MainDefinition {
 
 impl MainDefinition {
     pub fn opt_fn_def_id(self) -> Option<DefId> {
-        if let Res::Def(DefKind::Fn, def_id) = self.res {
-            Some(def_id)
-        } else {
-            None
-        }
+        if let Res::Def(DefKind::Fn, def_id) = self.res { Some(def_id) } else { None }
     }
 }
 
@@ -1184,11 +1180,7 @@ impl WithOptConstParam<LocalDefId> {
     }
 
     pub fn def_id_for_type_of(self) -> DefId {
-        if let Some(did) = self.const_param_did {
-            did
-        } else {
-            self.did.to_def_id()
-        }
+        if let Some(did) = self.const_param_did { did } else { self.did.to_def_id() }
     }
 }
 
@@ -1245,23 +1237,28 @@ struct ParamTag {
 }
 
 unsafe impl rustc_data_structures::tagged_ptr::Tag for ParamTag {
-    const BITS: usize = 2;
+    const BITS: usize = 3;
     #[inline]
     fn into_usize(self) -> usize {
         match self {
-            Self { reveal: traits::Reveal::UserFacing, constness: hir::Constness::NotConst } => 0,
-            Self { reveal: traits::Reveal::All, constness: hir::Constness::NotConst } => 1,
-            Self { reveal: traits::Reveal::UserFacing, constness: hir::Constness::Const } => 2,
-            Self { reveal: traits::Reveal::All, constness: hir::Constness::Const } => 3,
+            Self { reveal: traits::Reveal::Selection, constness: hir::Constness::NotConst } => 0,
+            Self { reveal: traits::Reveal::UserFacing, constness: hir::Constness::NotConst } => 1,
+            Self { reveal: traits::Reveal::All, constness: hir::Constness::NotConst } => 2,
+            Self { reveal: traits::Reveal::Selection, constness: hir::Constness::Const } => 3,
+            Self { reveal: traits::Reveal::UserFacing, constness: hir::Constness::Const } => 4,
+            Self { reveal: traits::Reveal::All, constness: hir::Constness::Const } => 5,
         }
     }
+
     #[inline]
     unsafe fn from_usize(ptr: usize) -> Self {
         match ptr {
-            0 => Self { reveal: traits::Reveal::UserFacing, constness: hir::Constness::NotConst },
-            1 => Self { reveal: traits::Reveal::All, constness: hir::Constness::NotConst },
-            2 => Self { reveal: traits::Reveal::UserFacing, constness: hir::Constness::Const },
-            3 => Self { reveal: traits::Reveal::All, constness: hir::Constness::Const },
+            0 => Self { reveal: traits::Reveal::Selection, constness: hir::Constness::NotConst },
+            1 => Self { reveal: traits::Reveal::UserFacing, constness: hir::Constness::NotConst },
+            2 => Self { reveal: traits::Reveal::All, constness: hir::Constness::NotConst },
+            3 => Self { reveal: traits::Reveal::Selection, constness: hir::Constness::Const },
+            4 => Self { reveal: traits::Reveal::UserFacing, constness: hir::Constness::Const },
+            5 => Self { reveal: traits::Reveal::All, constness: hir::Constness::Const },
             _ => std::hint::unreachable_unchecked(),
         }
     }
@@ -1352,7 +1349,7 @@ impl<'tcx> ParamEnv<'tcx> {
     }
 
     pub fn with_reveal_selection(mut self) -> Self {
-        self.packed.set_tag(Reveal::Selection);
+        self.packed.set_tag(ParamTag { reveal: Reveal::Selection, ..self.packed.tag() });
         self
     }