From eb89ca9b776fe4f55e1541c2fb7aba4d9ae38b7e Mon Sep 17 00:00:00 2001 From: Ariel Ben-Yehuda Date: Sun, 7 Dec 2025 12:14:23 +0000 Subject: [PATCH] enforced => enforcable mitigation --- compiler/rustc_metadata/src/creader.rs | 12 +-- compiler/rustc_metadata/src/rmeta/decoder.rs | 16 ++-- compiler/rustc_metadata/src/rmeta/encoder.rs | 12 +-- compiler/rustc_metadata/src/rmeta/mod.rs | 4 +- .../rustc_metadata/src/rmeta/parameterized.rs | 2 +- compiler/rustc_session/src/options.rs | 12 +-- ...tigations.rs => enforcable_mitigations.rs} | 84 +++++++++---------- 7 files changed, 69 insertions(+), 73 deletions(-) rename compiler/rustc_session/src/options/{enforced_mitigations.rs => enforcable_mitigations.rs} (60%) diff --git a/compiler/rustc_metadata/src/creader.rs b/compiler/rustc_metadata/src/creader.rs index d1ee527eeea4..972c1e2df932 100644 --- a/compiler/rustc_metadata/src/creader.rs +++ b/compiler/rustc_metadata/src/creader.rs @@ -25,7 +25,7 @@ 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, @@ -468,7 +468,7 @@ fn report_target_modifiers_extended( 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); } @@ -493,8 +493,8 @@ pub fn report_incompatible_target_modifiers(&self, tcx: TyCtxt<'_>, krate: &Crat } } - 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()) { @@ -506,12 +506,12 @@ pub fn report_incompatible_enforced_mitigations(&self, tcx: TyCtxt<'_>, krate: & 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 { diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs index 36bada1e59b1..7344be2cb317 100644 --- a/compiler/rustc_metadata/src/rmeta/decoder.rs +++ b/compiler/rustc_metadata/src/rmeta/decoder.rs @@ -30,7 +30,7 @@ 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::{ @@ -82,8 +82,8 @@ pub(crate) fn bytes(&self) -> &OwnedSlice { /// Target modifiers - abi or exploit mitigations flags that cause unsoundness when mixed pub(crate) type TargetModifiers = Vec; -/// Enforced Mitigations -pub(crate) type EnforcedMitigations = Vec; +/// The set of enforcable mitigations (RFC 3855) that are currently enabled for this crate +pub(crate) type EnforcableMitigations = Vec; pub(crate) struct CrateMetadata { /// The primary crate data - binary metadata blob. @@ -964,11 +964,11 @@ pub(crate) fn decode_target_modifiers<'a>( 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 { - self.enforced_mitigations.decode(metadata) + ) -> impl ExactSizeIterator { + self.enforcable_mitigations.decode(metadata) } } @@ -1952,8 +1952,8 @@ pub(crate) fn target_modifiers(&self) -> TargetModifiers { 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 diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs index 839b41cb4450..712c5aa0e2b8 100644 --- a/compiler/rustc_metadata/src/rmeta/encoder.rs +++ b/compiler/rustc_metadata/src/rmeta/encoder.rs @@ -27,7 +27,7 @@ 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 @@ macro_rules! stat { // `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(); @@ -761,7 +761,7 @@ macro_rules! stat { foreign_modules, source_map, target_modifiers, - enforced_mitigations, + enforcable_mitigations, traits, impls, incoherent_impls, @@ -2108,10 +2108,10 @@ fn encode_target_modifiers(&mut self) -> LazyArray { self.lazy_array(tcx.sess.opts.gather_target_modifiers()) } - fn encode_enforced_mitigations(&mut self) -> LazyArray { + fn encode_enabled_enforcable_mitigations(&mut self) -> LazyArray { 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)> { diff --git a/compiler/rustc_metadata/src/rmeta/mod.rs b/compiler/rustc_metadata/src/rmeta/mod.rs index ce423f325b5c..6d9627b9528d 100644 --- a/compiler/rustc_metadata/src/rmeta/mod.rs +++ b/compiler/rustc_metadata/src/rmeta/mod.rs @@ -36,7 +36,7 @@ use rustc_middle::ty::{self, Ty, TyCtxt}; 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; @@ -287,7 +287,7 @@ pub(crate) struct CrateRoot { source_map: LazyTable>>, target_modifiers: LazyArray, - enforced_mitigations: LazyArray, + enforcable_mitigations: LazyArray, compiler_builtins: bool, needs_allocator: bool, diff --git a/compiler/rustc_metadata/src/rmeta/parameterized.rs b/compiler/rustc_metadata/src/rmeta/parameterized.rs index 8debefd21a07..b993932eb70d 100644 --- a/compiler/rustc_metadata/src/rmeta/parameterized.rs +++ b/compiler/rustc_metadata/src/rmeta/parameterized.rs @@ -120,7 +120,7 @@ impl ParameterizedOverTcx for $ty { 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, diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs index 09710a13b6c5..4bf92c3304f8 100644 --- a/compiler/rustc_session/src/options.rs +++ b/compiler/rustc_session/src/options.rs @@ -20,7 +20,7 @@ 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; @@ -85,7 +85,7 @@ pub struct TargetModifier { pub value_name: String, } -pub mod enforced_mitigations; +pub mod enforcable_mitigations; mod target_modifier_consistency_check { use super::*; @@ -891,20 +891,16 @@ mod desc { pub(crate) const parse_mir_include_spans: &str = "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"; -<<<<<<< HEAD pub(crate) const parse_assert_incr_state: &str = "one of: `loaded`, `not-loaded`"; - pub(crate) const parse_allow_partial_mitigations: &str = super::EnforcedMitigationKind::KINDS; -======= pub(crate) const parse_allow_partial_mitigations: &str = - super::enforced_mitigations::EnforcedMitigationKind::KINDS; ->>>>>>> be3a932517e (address review comments) + 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; /// Ignore the value. Used for removed options where we don't actually want to store diff --git a/compiler/rustc_session/src/options/enforced_mitigations.rs b/compiler/rustc_session/src/options/enforcable_mitigations.rs similarity index 60% rename from compiler/rustc_session/src/options/enforced_mitigations.rs rename to compiler/rustc_session/src/options/enforcable_mitigations.rs index 731b519eda58..667dd0b8aadc 100644 --- a/compiler/rustc_session/src/options/enforced_mitigations.rs +++ b/compiler/rustc_session/src/options/enforcable_mitigations.rs @@ -10,66 +10,66 @@ 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 for EnforcedMitigationLevel { +impl From for EnforcableMitigationLevel { fn from(value: bool) -> Self { - EnforcedMitigationLevel::Enabled(value) + EnforcableMitigationLevel::Enabled(value) } } -impl From for EnforcedMitigationLevel { +impl From 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 { + fn from_str(v: &str) -> Result { 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 { - [$(EnforcedMitigationKind::$name),*].into_iter() + pub fn all_enforced_mitigations(&self) -> impl Iterator { + [$(EnforcableMitigationKind::$name),*].into_iter() } } impl Session { - pub fn gather_enabled_enforced_mitigations(&$self) -> Vec { + pub fn gather_enabled_enforcable_mitigations(&$self) -> Vec { let mut mitigations = [ $( - EnforcedMitigation { - kind: EnforcedMitigationKind::$name, + EnforcableMitigation { + kind: EnforcableMitigationKind::$name, level: From::from($code), } ),* @@ -147,7 +147,7 @@ pub fn gather_enabled_enforced_mitigations(&$self) -> Vec { 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) } @@ -155,9 +155,9 @@ enum EnforcedMitigationKind { /// 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 { @@ -165,7 +165,7 @@ impl Options { pub fn allowed_partial_mitigations( &self, edition: Edition, - ) -> impl Iterator { + ) -> impl Iterator { let mut result: BTreeSet<_> = self .all_enforced_mitigations() .filter(|mitigation| mitigation.enforced_since() > edition)