enforced => enforcable mitigation

Author: Ariel Ben-Yehuda

compiler/rustc_metadata/src/creader.rs

@@ -25,7 +25,7 @@ use rustc_middle::ty::data_structures::IndexSet;
 use rustc_middle::ty::{TyCtxt, TyCtxtFeed};
 use rustc_proc_macro::bridge::client::ProcMacro;
 use rustc_session::Session;
-use rustc_session::config::enforced_mitigations::EnforcedMitigationLevel;
+use rustc_session::config::enforcable_mitigations::EnforcableMitigationLevel;
 use rustc_session::config::{
     CrateType, ExtendedTargetModifierInfo, ExternLocation, Externs, OptionsTargetModifiers,
     TargetModifier,
@@ -458,7 +458,7 @@ impl CStore {
 
     pub fn report_session_incompatibilities(&self, tcx: TyCtxt<'_>, krate: &Crate) {
         self.report_incompatible_target_modifiers(tcx, krate);
-        self.report_incompatible_enforced_mitigations(tcx, krate);
+        self.report_incompatible_enforcable_mitigations(tcx, krate);
         self.report_incompatible_async_drop_feature(tcx, krate);
     }
 
@@ -483,8 +483,8 @@ impl CStore {
         }
     }
 
-    pub fn report_incompatible_enforced_mitigations(&self, tcx: TyCtxt<'_>, krate: &Crate) {
-        let my_mitigations = tcx.sess.gather_enabled_enforced_mitigations();
+    pub fn report_incompatible_enforcable_mitigations(&self, tcx: TyCtxt<'_>, krate: &Crate) {
+        let my_mitigations = tcx.sess.gather_enabled_enforcable_mitigations();
         let mut my_mitigations: BTreeMap<_, _> =
             my_mitigations.iter().map(|mitigation| (mitigation.kind, mitigation)).collect();
         for skipped_mitigation in tcx.sess.opts.allowed_partial_mitigations(tcx.sess.edition()) {
@@ -496,12 +496,12 @@ impl CStore {
             if data.is_proc_macro_crate() {
                 continue;
             }
-            let their_mitigations = data.enforced_mitigations();
+            let their_mitigations = data.enabled_enforcable_mitigations();
             for my_mitigation in my_mitigations.values() {
                 let their_mitigation = their_mitigations
                     .iter()
                     .find(|mitigation| mitigation.kind == my_mitigation.kind)
-                    .map_or(EnforcedMitigationLevel::Enabled(false), |m| m.level);
+                    .map_or(EnforcableMitigationLevel::Enabled(false), |m| m.level);
                 if their_mitigation < my_mitigation.level {
                     let errors = errors_per_mitigation.entry(my_mitigation.kind).or_insert(0);
                     if *errors >= MAX_ERRORS_PER_MITIGATION {

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -30,7 +30,7 @@ use rustc_proc_macro::bridge::client::ProcMacro;
 use rustc_serialize::opaque::MemDecoder;
 use rustc_serialize::{Decodable, Decoder};
 use rustc_session::config::TargetModifier;
-use rustc_session::config::enforced_mitigations::EnforcedMitigation;
+use rustc_session::config::enforcable_mitigations::EnforcableMitigation;
 use rustc_session::cstore::{CrateSource, ExternCrate};
 use rustc_span::hygiene::HygieneDecodeContext;
 use rustc_span::{
@@ -81,8 +81,8 @@ pub(crate) type CrateNumMap = IndexVec<CrateNum, CrateNum>;
 /// Target modifiers - abi or exploit mitigations flags that cause unsoundness when mixed
 pub(crate) type TargetModifiers = Vec<TargetModifier>;
 
-/// Enforced Mitigations
-pub(crate) type EnforcedMitigations = Vec<EnforcedMitigation>;
+/// The set of enforcable mitigations (RFC 3855) that are currently enabled for this crate
+pub(crate) type EnforcableMitigations = Vec<EnforcableMitigation>;
 
 pub(crate) struct CrateMetadata {
     /// The primary crate data - binary metadata blob.
@@ -965,11 +965,11 @@ impl CrateRoot {
         self.target_modifiers.decode(metadata)
     }
 
-    pub(crate) fn decode_enforced_mitigations<'a>(
+    pub(crate) fn decode_enforcable_mitigations<'a>(
         &self,
         metadata: &'a MetadataBlob,
-    ) -> impl ExactSizeIterator<Item = EnforcedMitigation> {
-        self.enforced_mitigations.decode(metadata)
+    ) -> impl ExactSizeIterator<Item = EnforcableMitigation> {
+        self.enforcable_mitigations.decode(metadata)
     }
 }
 
@@ -1959,8 +1959,8 @@ impl CrateMetadata {
         self.root.decode_target_modifiers(&self.blob).collect()
     }
 
-    pub(crate) fn enforced_mitigations(&self) -> EnforcedMitigations {
-        self.root.decode_enforced_mitigations(&self.blob).collect()
+    pub(crate) fn enabled_enforcable_mitigations(&self) -> EnforcableMitigations {
+        self.root.decode_enforcable_mitigations(&self.blob).collect()
     }
 
     /// Keep `new_extern_crate` if it looks better in diagnostics

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -27,7 +27,7 @@ use rustc_middle::ty::codec::TyEncoder;
 use rustc_middle::ty::fast_reject::{self, TreatParams};
 use rustc_middle::{bug, span_bug};
 use rustc_serialize::{Decodable, Decoder, Encodable, Encoder, opaque};
-use rustc_session::config::enforced_mitigations::EnforcedMitigation;
+use rustc_session::config::enforcable_mitigations::EnforcableMitigation;
 use rustc_session::config::{CrateType, OptLevel, TargetModifier};
 use rustc_span::hygiene::HygieneEncodeContext;
 use rustc_span::{
@@ -716,8 +716,8 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         // `SourceFiles` we actually need to encode.
         let source_map = stat!("source-map", || self.encode_source_map());
         let target_modifiers = stat!("target-modifiers", || self.encode_target_modifiers());
-        let enforced_mitigations =
-            stat!("enforced-mitigations", || self.encode_enforced_mitigations());
+        let enforcable_mitigations =
+            stat!("enforced-mitigations", || self.encode_enabled_enforcable_mitigations());
 
         let root = stat!("final", || {
             let attrs = tcx.hir_krate_attrs();
@@ -763,7 +763,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 foreign_modules,
                 source_map,
                 target_modifiers,
-                enforced_mitigations,
+                enforcable_mitigations,
                 traits,
                 impls,
                 incoherent_impls,
@@ -2098,10 +2098,10 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         self.lazy_array(tcx.sess.opts.gather_target_modifiers())
     }
 
-    fn encode_enforced_mitigations(&mut self) -> LazyArray<EnforcedMitigation> {
+    fn encode_enabled_enforcable_mitigations(&mut self) -> LazyArray<EnforcableMitigation> {
         empty_proc_macro!(self);
         let tcx = self.tcx;
-        self.lazy_array(tcx.sess.gather_enabled_enforced_mitigations())
+        self.lazy_array(tcx.sess.gather_enabled_enforcable_mitigations())
     }
 
     fn encode_lib_features(&mut self) -> LazyArray<(Symbol, FeatureStability)> {

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -34,7 +34,7 @@ use rustc_middle::ty::fast_reject::SimplifiedType;
 use rustc_middle::ty::{self, Ty, TyCtxt, UnusedGenericParams};
 use rustc_middle::util::Providers;
 use rustc_serialize::opaque::FileEncoder;
-use rustc_session::config::enforced_mitigations::EnforcedMitigation;
+use rustc_session::config::enforcable_mitigations::EnforcableMitigation;
 use rustc_session::config::{SymbolManglingVersion, TargetModifier};
 use rustc_session::cstore::{CrateDepKind, ForeignModule, LinkagePreference, NativeLib};
 use rustc_span::edition::Edition;
@@ -284,7 +284,7 @@ pub(crate) struct CrateRoot {
 
     source_map: LazyTable<u32, Option<LazyValue<rustc_span::SourceFile>>>,
     target_modifiers: LazyArray<TargetModifier>,
-    enforced_mitigations: LazyArray<EnforcedMitigation>,
+    enforcable_mitigations: LazyArray<EnforcableMitigation>,
 
     compiler_builtins: bool,
     needs_allocator: bool,

compiler/rustc_metadata/src/rmeta/parameterized.rs

@@ -118,7 +118,7 @@ trivially_parameterized_over_tcx! {
     rustc_middle::ty::adjustment::CoerceUnsizedInfo,
     rustc_middle::ty::fast_reject::SimplifiedType,
     rustc_session::config::TargetModifier,
-    rustc_session::config::enforced_mitigations::EnforcedMitigation,
+    rustc_session::config::enforcable_mitigations::EnforcableMitigation,
     rustc_session::cstore::ForeignModule,
     rustc_session::cstore::LinkagePreference,
     rustc_session::cstore::NativeLib,

compiler/rustc_session/src/options.rs

@@ -19,7 +19,7 @@ use rustc_target::spec::{
     TargetTuple, TlsModel,
 };
 
-use crate::config::enforced_mitigations::MitigationEnablement;
+use crate::config::enforcable_mitigations::MitigationEnablement;
 use crate::config::*;
 use crate::search_paths::SearchPath;
 use crate::utils::NativeLib;
@@ -84,7 +84,7 @@ pub struct TargetModifier {
     pub value_name: String,
 }
 
-pub mod enforced_mitigations;
+pub mod enforcable_mitigations;
 
 mod target_modifier_consistency_check {
     use super::*;
@@ -883,14 +883,14 @@ mod desc {
         "either a boolean (`yes`, `no`, `on`, `off`, etc), or `nll` (default: `nll`)";
     pub(crate) const parse_align: &str = "a number that is a power of 2 between 1 and 2^29";
     pub(crate) const parse_allow_partial_mitigations: &str =
-        super::enforced_mitigations::EnforcedMitigationKind::KINDS;
+        super::enforcable_mitigations::EnforcableMitigationKind::KINDS;
 }
 
 pub mod parse {
     use std::str::FromStr;
 
     pub(crate) use super::*;
-    use crate::config::enforced_mitigations::MitigationEnablement;
+    use crate::config::enforcable_mitigations::MitigationEnablement;
     pub(crate) const MAX_THREADS_CAP: usize = 256;
 
     /// This is for boolean options that don't take a value, and are true simply

…sion/src/options/enforced_mitigations.rs …on/src/options/enforcable_mitigations.rscompiler/rustc_session/src/options/enforced_mitigations.rs renamed to compiler/rustc_session/src/options/enforcable_mitigations.rs compiler/rustc_session/src/options/enforced_mitigations.rs renamed to compiler/rustc_session/src/options/enforcable_mitigations.rs

@@ -10,66 +10,66 @@ use crate::config::Options;
 use crate::options::CFGuard;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Encodable, BlobDecodable)]
-pub enum EnforcedMitigationLevel {
+pub enum EnforcableMitigationLevel {
     // Enabled(false) should be the bottom of the Ord hierarchy
     Enabled(bool),
     StackProtector(StackProtector),
 }
 
-impl EnforcedMitigationLevel {
+impl EnforcableMitigationLevel {
     pub fn level_str(&self) -> &'static str {
         match self {
-            EnforcedMitigationLevel::StackProtector(StackProtector::All) => "=all",
-            EnforcedMitigationLevel::StackProtector(StackProtector::Basic) => "=basic",
-            EnforcedMitigationLevel::StackProtector(StackProtector::Strong) => "=strong",
+            EnforcableMitigationLevel::StackProtector(StackProtector::All) => "=all",
+            EnforcableMitigationLevel::StackProtector(StackProtector::Basic) => "=basic",
+            EnforcableMitigationLevel::StackProtector(StackProtector::Strong) => "=strong",
             // currently `=disabled` should not appear
-            EnforcedMitigationLevel::Enabled(false) => "=disabled",
-            EnforcedMitigationLevel::StackProtector(StackProtector::None)
-            | EnforcedMitigationLevel::Enabled(true) => "",
+            EnforcableMitigationLevel::Enabled(false) => "=disabled",
+            EnforcableMitigationLevel::StackProtector(StackProtector::None)
+            | EnforcableMitigationLevel::Enabled(true) => "",
         }
     }
 }
 
-impl std::fmt::Display for EnforcedMitigationLevel {
+impl std::fmt::Display for EnforcableMitigationLevel {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            EnforcedMitigationLevel::StackProtector(StackProtector::All) => {
+            EnforcableMitigationLevel::StackProtector(StackProtector::All) => {
                 write!(f, "all")
             }
-            EnforcedMitigationLevel::StackProtector(StackProtector::Basic) => {
+            EnforcableMitigationLevel::StackProtector(StackProtector::Basic) => {
                 write!(f, "basic")
             }
-            EnforcedMitigationLevel::StackProtector(StackProtector::Strong) => {
+            EnforcableMitigationLevel::StackProtector(StackProtector::Strong) => {
                 write!(f, "strong")
             }
-            EnforcedMitigationLevel::Enabled(true) => {
+            EnforcableMitigationLevel::Enabled(true) => {
                 write!(f, "enabled")
             }
-            EnforcedMitigationLevel::StackProtector(StackProtector::None)
-            | EnforcedMitigationLevel::Enabled(false) => {
+            EnforcableMitigationLevel::StackProtector(StackProtector::None)
+            | EnforcableMitigationLevel::Enabled(false) => {
                 write!(f, "disabled")
             }
         }
     }
 }
 
-impl From<bool> for EnforcedMitigationLevel {
+impl From<bool> for EnforcableMitigationLevel {
     fn from(value: bool) -> Self {
-        EnforcedMitigationLevel::Enabled(value)
+        EnforcableMitigationLevel::Enabled(value)
     }
 }
 
-impl From<StackProtector> for EnforcedMitigationLevel {
+impl From<StackProtector> for EnforcableMitigationLevel {
     fn from(value: StackProtector) -> Self {
-        EnforcedMitigationLevel::StackProtector(value)
+        EnforcableMitigationLevel::StackProtector(value)
     }
 }
 
-pub struct EnforcedMitigationKindParseError;
+pub struct EnforcableMitigationKindParseError;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Encodable, BlobDecodable)]
 pub struct MitigationEnablement {
-    pub kind: EnforcedMitigationKind,
+    pub kind: EnforcableMitigationKind,
     pub enabled: bool,
 }
 
@@ -82,58 +82,58 @@ macro_rules! intersperse {
 macro_rules! enforced_mitigations {
     ([$self:ident] enum $kind:ident {$(($name:ident, $text:expr, $since:ident, $code:expr)),*}) => {
         #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Encodable, BlobDecodable)]
-        pub enum EnforcedMitigationKind {
+        pub enum EnforcableMitigationKind {
             $($name),*
         }
 
-        impl std::fmt::Display for EnforcedMitigationKind {
+        impl std::fmt::Display for EnforcableMitigationKind {
             fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                 match self {
-                    $(EnforcedMitigationKind::$name => write!(f, $text)),*
+                    $(EnforcableMitigationKind::$name => write!(f, $text)),*
                 }
             }
         }
 
-        impl EnforcedMitigationKind {
+        impl EnforcableMitigationKind {
             pub(crate) const KINDS: &'static str = concat!("comma-separated list of mitigation kinds (available: ",
                 intersperse!(", ", ($(concat!("`", $text, "`")),*)), ")");
         }
 
-        impl FromStr for EnforcedMitigationKind {
-            type Err = EnforcedMitigationKindParseError;
+        impl FromStr for EnforcableMitigationKind {
+            type Err = EnforcableMitigationKindParseError;
 
-            fn from_str(v: &str) -> Result<EnforcedMitigationKind, EnforcedMitigationKindParseError> {
+            fn from_str(v: &str) -> Result<EnforcableMitigationKind, EnforcableMitigationKindParseError> {
                 match v {
-                    $($text => Ok(EnforcedMitigationKind::$name)),*
+                    $($text => Ok(EnforcableMitigationKind::$name)),*
                     ,
-                    _ => Err(EnforcedMitigationKindParseError),
+                    _ => Err(EnforcableMitigationKindParseError),
                 }
             }
         }
 
         #[allow(unused)]
-        impl EnforcedMitigationKind {
+        impl EnforcableMitigationKind {
             pub fn enforced_since(&self) -> Edition {
                 match self {
                     // Should change the enforced-since edition of StackProtector to 2015
                     // (all editions) when `-C stack-protector` is stabilized.
-                    $(EnforcedMitigationKind::$name => Edition::$since),*
+                    $(EnforcableMitigationKind::$name => Edition::$since),*
                 }
             }
         }
 
         impl Options {
-            pub fn all_enforced_mitigations(&self) -> impl Iterator<Item = EnforcedMitigationKind> {
-                [$(EnforcedMitigationKind::$name),*].into_iter()
+            pub fn all_enforced_mitigations(&self) -> impl Iterator<Item = EnforcableMitigationKind> {
+                [$(EnforcableMitigationKind::$name),*].into_iter()
             }
         }
 
         impl Session {
-            pub fn gather_enabled_enforced_mitigations(&$self) -> Vec<EnforcedMitigation> {
+            pub fn gather_enabled_enforcable_mitigations(&$self) -> Vec<EnforcableMitigation> {
                 let mut mitigations = [
                     $(
-                    EnforcedMitigation {
-                        kind: EnforcedMitigationKind::$name,
+                    EnforcableMitigation {
+                        kind: EnforcableMitigationKind::$name,
                         level: From::from($code),
                     }
                     ),*
@@ -147,25 +147,25 @@ macro_rules! enforced_mitigations {
 
 enforced_mitigations! {
     [self]
-    enum EnforcedMitigationKind {
+    enum EnforcableMitigationKind {
         (StackProtector, "stack-protector", EditionFuture, self.stack_protector()),
         (ControlFlowGuard, "control-flow-guard", EditionFuture, self.opts.cg.control_flow_guard == CFGuard::Checks)
     }
 }
 
 /// Enforced mitigations, see [RFC 3855](https://github.com/rust-lang/rfcs/pull/3855)
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Encodable, BlobDecodable)]
-pub struct EnforcedMitigation {
-    pub kind: EnforcedMitigationKind,
-    pub level: EnforcedMitigationLevel,
+pub struct EnforcableMitigation {
+    pub kind: EnforcableMitigationKind,
+    pub level: EnforcableMitigationLevel,
 }
 
 impl Options {
     // Return the list of mitigations that are allowed to be partial
     pub fn allowed_partial_mitigations(
         &self,
         edition: Edition,
-    ) -> impl Iterator<Item = EnforcedMitigationKind> {
+    ) -> impl Iterator<Item = EnforcableMitigationKind> {
         let mut result: BTreeSet<_> = self
             .all_enforced_mitigations()
             .filter(|mitigation| mitigation.enforced_since() > edition)