From de2408aeedea7ca8c9d0792c329b15aef7c2f5e7 Mon Sep 17 00:00:00 2001 From: Ariel Ben-Yehuda Date: Mon, 24 Nov 2025 13:56:38 +0000 Subject: [PATCH 01/11] Implement `-Z allow-partial-mitigations` (RFC 3855) This implements `-Z allow-partial-mitigations` as an unstable option, currently with support for control-flow-guard and stack-protector. As a difference from the RFC, we have `-Z allow-partial-mitigations=!foo` rather than `-Z deny-partial-mitigations=foo`, since I couldn't find an easy way to have an allow/deny pair of flags where the latter flag wins. To allow for stabilization, this is only enabled starting from the next edition. Maybe a better policy is possible (bikeshed). --- compiler/rustc_interface/src/passes.rs | 3 +- compiler/rustc_metadata/src/creader.rs | 51 +++++- compiler/rustc_metadata/src/errors.rs | 18 ++ compiler/rustc_metadata/src/rmeta/decoder.rs | 18 +- compiler/rustc_metadata/src/rmeta/encoder.rs | 11 +- compiler/rustc_metadata/src/rmeta/mod.rs | 3 +- .../rustc_metadata/src/rmeta/parameterized.rs | 1 + compiler/rustc_session/src/config.rs | 12 ++ compiler/rustc_session/src/options.rs | 173 +++++++++++++++++- compiler/rustc_target/src/spec/mod.rs | 1 + tests/ui/README.md | 6 + .../err-allow-partial-mitigations.both.stderr | 92 ++++++++++ ...r-allow-partial-mitigations.disable.stderr | 47 +++++ ...-partial-mitigations.enable-disable.stderr | 47 +++++ .../err-allow-partial-mitigations.rs | 43 +++++ .../err-allow-partial-mitigations.sp.stderr | 47 +++++ ...ow-partial-mitigations.wrong-enable.stderr | 47 +++++ .../ok-allow-partial-mitigations-minicore.rs | 18 ++ .../ok-allow-partial-mitigations.rs | 11 ++ 19 files changed, 639 insertions(+), 10 deletions(-) create mode 100644 tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.both.stderr create mode 100644 tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.disable.stderr create mode 100644 tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.enable-disable.stderr create mode 100644 tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.rs create mode 100644 tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.sp.stderr create mode 100644 tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.wrong-enable.stderr create mode 100644 tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations-minicore.rs create mode 100644 tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations.rs diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs index 43efce545fc28..1f4b6bee0394b 100644 --- a/compiler/rustc_interface/src/passes.rs +++ b/compiler/rustc_interface/src/passes.rs @@ -303,8 +303,7 @@ fn configure_and_expand( resolver.resolve_crate(&krate); - CStore::from_tcx(tcx).report_incompatible_target_modifiers(tcx, &krate); - CStore::from_tcx(tcx).report_incompatible_async_drop_feature(tcx, &krate); + CStore::from_tcx(tcx).report_session_incompatibilities(tcx, &krate); krate } diff --git a/compiler/rustc_metadata/src/creader.rs b/compiler/rustc_metadata/src/creader.rs index 3c8ea1a9f43d4..7434a3f9e29bc 100644 --- a/compiler/rustc_metadata/src/creader.rs +++ b/compiler/rustc_metadata/src/creader.rs @@ -1,5 +1,6 @@ //! Validates all used crates and extern libraries and loads their metadata +use std::collections::BTreeMap; use std::error::Error; use std::path::Path; use std::str::FromStr; @@ -24,8 +25,8 @@ use rustc_middle::ty::data_structures::IndexSet; use rustc_middle::ty::{TyCtxt, TyCtxtFeed}; use rustc_proc_macro::bridge::client::ProcMacro; use rustc_session::config::{ - CrateType, ExtendedTargetModifierInfo, ExternLocation, Externs, OptionsTargetModifiers, - TargetModifier, + CrateType, EnforcedMitigationLevel, ExtendedTargetModifierInfo, ExternLocation, Externs, + OptionsTargetModifiers, TargetModifier, }; use rustc_session::cstore::{CrateDepKind, CrateSource, ExternCrate, ExternCrateSource}; use rustc_session::output::validate_crate_name; @@ -463,6 +464,12 @@ 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_async_drop_feature(tcx, krate); + } + pub fn report_incompatible_target_modifiers(&self, tcx: TyCtxt<'_>, krate: &Crate) { for flag_name in &tcx.sess.opts.cg.unsafe_allow_abi_mismatch { if !OptionsTargetModifiers::is_target_modifier(flag_name) { @@ -484,6 +491,46 @@ impl CStore { } } + pub fn report_incompatible_enforced_mitigations(&self, tcx: TyCtxt<'_>, krate: &Crate) { + let my_mitigations = tcx.sess.gather_enabled_enforced_mitigations(); + let mut my_mitigations: BTreeMap<_, _> = my_mitigations + .iter() + .filter(|mitigation| mitigation.kind.enforced_since() <= tcx.sess.edition()) + .map(|mitigation| (mitigation.kind, mitigation)) + .collect(); + for skipped_mitigation in tcx.sess.opts.allowed_partial_mitigations() { + my_mitigations.remove(&skipped_mitigation); + } + const MAX_ERRORS_PER_MITIGATION: usize = 5; + let mut errors_per_mitigation = BTreeMap::new(); + for (_cnum, data) in self.iter_crate_data() { + if data.is_proc_macro_crate() { + continue; + } + let their_mitigations = data.enforced_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); + if their_mitigation < my_mitigation.level { + let errors = errors_per_mitigation.entry(my_mitigation.kind).or_insert(0); + if *errors >= MAX_ERRORS_PER_MITIGATION { + continue; + } + *errors += 1; + + tcx.dcx().emit_err(errors::MitigationLessStrictInDependency { + span: krate.spans.inner_span.shrink_to_lo(), + mitigation_name: my_mitigation.kind.to_string(), + mitigation_level: my_mitigation.level.level_str().to_string(), + extern_crate: data.name(), + }); + } + } + } + } + // Report about async drop types in dependency if async drop feature is disabled pub fn report_incompatible_async_drop_feature(&self, tcx: TyCtxt<'_>, krate: &Crate) { if tcx.features().async_drop() { diff --git a/compiler/rustc_metadata/src/errors.rs b/compiler/rustc_metadata/src/errors.rs index 8b2895d70004a..79568dcec81ec 100644 --- a/compiler/rustc_metadata/src/errors.rs +++ b/compiler/rustc_metadata/src/errors.rs @@ -696,3 +696,21 @@ pub(crate) struct UnusedCrateDependency { pub extern_crate: Symbol, pub local_crate: Symbol, } + +#[derive(Diagnostic)] +#[diag( + "your program uses the crate `{$extern_crate}`, that is not compiled with `{$mitigation_name}{$mitigation_level}` enabled" +)] +#[note( + "recompile `{$extern_crate}` with `{$mitigation_name}{$mitigation_level}` enabled, or use `-Z allow-partial-mitigations={$mitigation_name}` to allow creating an artifact that has the mitigation only partially enabled " +)] +#[help( + "it is possible to disable `-Z allow-partial-mitigations={$mitigation_name}` via `-Z deny-partial-mitigations={$mitigation_name}`" +)] +pub struct MitigationLessStrictInDependency { + #[primary_span] + pub span: Span, + pub mitigation_name: String, + pub mitigation_level: String, + pub extern_crate: Symbol, +} diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs index fc541f952d229..613501805f729 100644 --- a/compiler/rustc_metadata/src/rmeta/decoder.rs +++ b/compiler/rustc_metadata/src/rmeta/decoder.rs @@ -29,7 +29,7 @@ use rustc_middle::{bug, implement_ty_decoder}; 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::{EnforcedMitigation, TargetModifier}; use rustc_session::cstore::{CrateSource, ExternCrate}; use rustc_span::hygiene::HygieneDecodeContext; use rustc_span::{ @@ -78,9 +78,12 @@ impl MetadataBlob { /// own crate numbers. pub(crate) type CrateNumMap = IndexVec; -/// Target modifiers - abi or exploit mitigations flags +/// Target modifiers - abi or exploit mitigations flags that cause unsoundness when mixed pub(crate) type TargetModifiers = Vec; +/// Enforced Mitigations +pub(crate) type EnforcedMitigations = Vec; + pub(crate) struct CrateMetadata { /// The primary crate data - binary metadata blob. blob: MetadataBlob, @@ -959,6 +962,13 @@ impl CrateRoot { ) -> impl ExactSizeIterator { self.target_modifiers.decode(metadata) } + + pub(crate) fn decode_enforced_mitigations<'a>( + &self, + metadata: &'a MetadataBlob, + ) -> impl ExactSizeIterator { + self.enforced_mitigations.decode(metadata) + } } impl<'a> CrateMetadataRef<'a> { @@ -1941,6 +1951,10 @@ 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() + } + /// Keep `new_extern_crate` if it looks better in diagnostics pub(crate) fn update_extern_crate_diagnostics( &mut self, diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs index 8bf919dab8e79..ae7c3310f7a9c 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::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::{CrateType, OptLevel, TargetModifier}; +use rustc_session::config::{CrateType, EnforcedMitigation, OptLevel, TargetModifier}; use rustc_span::hygiene::HygieneEncodeContext; use rustc_span::{ ByteSymbol, ExternalSource, FileName, SourceFile, SpanData, SpanEncoder, StableSourceFileId, @@ -715,6 +715,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 root = stat!("final", || { let attrs = tcx.hir_krate_attrs(); @@ -758,6 +760,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { foreign_modules, source_map, target_modifiers, + enforced_mitigations, traits, impls, incoherent_impls, @@ -2104,6 +2107,12 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { self.lazy_array(tcx.sess.opts.gather_target_modifiers()) } + fn encode_enforced_mitigations(&mut self) -> LazyArray { + empty_proc_macro!(self); + let tcx = self.tcx; + self.lazy_array(tcx.sess.gather_enabled_enforced_mitigations()) + } + fn encode_lib_features(&mut self) -> LazyArray<(Symbol, FeatureStability)> { empty_proc_macro!(self); let tcx = self.tcx; diff --git a/compiler/rustc_metadata/src/rmeta/mod.rs b/compiler/rustc_metadata/src/rmeta/mod.rs index 9dee913e8389c..9128a52c90fd2 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::fast_reject::SimplifiedType; use rustc_middle::ty::{self, Ty, TyCtxt}; use rustc_middle::util::Providers; use rustc_serialize::opaque::FileEncoder; -use rustc_session::config::{SymbolManglingVersion, TargetModifier}; +use rustc_session::config::{EnforcedMitigation, SymbolManglingVersion, TargetModifier}; use rustc_session::cstore::{CrateDepKind, ForeignModule, LinkagePreference, NativeLib}; use rustc_span::edition::Edition; use rustc_span::hygiene::{ExpnIndex, MacroKind, SyntaxContextKey}; @@ -286,6 +286,7 @@ pub(crate) struct CrateRoot { source_map: LazyTable>>, target_modifiers: LazyArray, + enforced_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 8a9de07836db4..ee22a08850bca 100644 --- a/compiler/rustc_metadata/src/rmeta/parameterized.rs +++ b/compiler/rustc_metadata/src/rmeta/parameterized.rs @@ -119,6 +119,7 @@ trivially_parameterized_over_tcx! { rustc_middle::ty::Visibility, rustc_middle::ty::adjustment::CoerceUnsizedInfo, rustc_middle::ty::fast_reject::SimplifiedType, + rustc_session::config::EnforcedMitigation, rustc_session::config::TargetModifier, rustc_session::cstore::ForeignModule, rustc_session::cstore::LinkagePreference, diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs index e4ef1d40d72d5..bdc07c5ad528e 100644 --- a/compiler/rustc_session/src/config.rs +++ b/compiler/rustc_session/src/config.rs @@ -1494,6 +1494,18 @@ impl Options { pub fn autodiff_enabled(&self) -> bool { self.unstable_opts.autodiff.contains(&AutoDiff::Enable) } + + pub fn allowed_partial_mitigations(&self) -> impl Iterator { + let mut result = BTreeSet::default(); + for mitigation in &self.unstable_opts.allow_partial_mitigations { + if mitigation.enabled { + result.insert(mitigation.kind); + } else { + result.remove(&mitigation.kind); + } + } + result.into_iter() + } } impl UnstableOptions { diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs index 027a7045791e4..2fac722473762 100644 --- a/compiler/rustc_session/src/options.rs +++ b/compiler/rustc_session/src/options.rs @@ -1,7 +1,7 @@ use std::collections::BTreeMap; use std::num::{IntErrorKind, NonZero}; use std::path::PathBuf; -use std::str; +use std::str::{self, FromStr}; use rustc_abi::Align; use rustc_data_structures::fx::FxIndexMap; @@ -11,7 +11,7 @@ use rustc_errors::{ColorConfig, TerminalUrl}; use rustc_feature::UnstableFeatures; use rustc_hashes::Hash64; use rustc_hir::attrs::CollapseMacroDebuginfo; -use rustc_macros::{BlobDecodable, Encodable}; +use rustc_macros::{BlobDecodable, Decodable, Encodable}; use rustc_span::edition::Edition; use rustc_span::{RealFileName, RemapPathScopeComponents, SourceFileHashAlgorithm}; use rustc_target::spec::{ @@ -84,6 +84,151 @@ pub struct TargetModifier { pub value_name: String, } +#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Encodable, BlobDecodable)] +pub enum EnforcedMitigationLevel { + // Enabled(false) should be the bottom of the Ord hierarchy + Enabled(bool), + StackProtector(StackProtector), +} + +impl EnforcedMitigationLevel { + pub fn level_str(&self) -> &'static str { + match self { + EnforcedMitigationLevel::StackProtector(StackProtector::All) => "=all", + EnforcedMitigationLevel::StackProtector(StackProtector::Basic) => "=basic", + EnforcedMitigationLevel::StackProtector(StackProtector::Strong) => "=strong", + // currently `=disabled` should not appear + EnforcedMitigationLevel::Enabled(false) => "=disabled", + EnforcedMitigationLevel::StackProtector(StackProtector::None) + | EnforcedMitigationLevel::Enabled(true) => "", + } + } +} + +impl std::fmt::Display for EnforcedMitigationLevel { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + EnforcedMitigationLevel::StackProtector(StackProtector::All) => { + write!(f, "all") + } + EnforcedMitigationLevel::StackProtector(StackProtector::Basic) => { + write!(f, "basic") + } + EnforcedMitigationLevel::StackProtector(StackProtector::Strong) => { + write!(f, "strong") + } + EnforcedMitigationLevel::Enabled(true) => { + write!(f, "enabled") + } + EnforcedMitigationLevel::StackProtector(StackProtector::None) + | EnforcedMitigationLevel::Enabled(false) => { + write!(f, "disabled") + } + } + } +} + +impl From for EnforcedMitigationLevel { + fn from(value: bool) -> Self { + EnforcedMitigationLevel::Enabled(value) + } +} + +impl From for EnforcedMitigationLevel { + fn from(value: StackProtector) -> Self { + EnforcedMitigationLevel::StackProtector(value) + } +} + +pub struct EnforcedMitigationKindParseError; + +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Encodable, Decodable)] +pub struct MitigationEnablement { + pub kind: EnforcedMitigationKind, + pub enabled: bool, +} + +macro_rules! intersperse { + ($sep:expr, ($first:expr $(, $rest:expr)* $(,)?)) => { + concat!($first $(, $sep, $rest)*) + }; +} + +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 { + $($name),* + } + + impl std::fmt::Display for EnforcedMitigationKind { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + $(EnforcedMitigationKind::$name => write!(f, $text)),* + } + } + } + + impl EnforcedMitigationKind { + const KINDS: &'static str = concat!("comma-separated list of mitigation kinds (available: ", + intersperse!(", ", ($(concat!("`", $text, "`")),*)), ")"); + } + + impl FromStr for EnforcedMitigationKind { + type Err = EnforcedMitigationKindParseError; + + fn from_str(v: &str) -> Result { + match v { + $($text => Ok(EnforcedMitigationKind::$name)),* + , + _ => Err(EnforcedMitigationKindParseError), + } + } + } + + #[allow(unused)] + impl EnforcedMitigationKind { + 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),* + } + } + } + + impl Session { + pub fn gather_enabled_enforced_mitigations(&$self) -> Vec { + let mut mitigations = [ + $( + EnforcedMitigation { + kind: EnforcedMitigationKind::$name, + level: From::from($code), + } + ),* + ]; + mitigations.sort(); + mitigations.into_iter().collect() + } + } + } +} + +enforced_mitigations! { + [self] + enum EnforcedMitigationKind { + (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, +} + mod target_modifier_consistency_check { use super::*; pub(super) fn sanitizer(l: &TargetModifier, r: Option<&TargetModifier>) -> bool { @@ -889,6 +1034,7 @@ 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_assert_incr_state: &str = "one of: `loaded`, `not-loaded`"; + pub(crate) const parse_allow_partial_mitigations: &str = super::EnforcedMitigationKind::KINDS; } pub mod parse { @@ -2062,6 +2208,7 @@ pub mod parse { true } +<<<<<<< HEAD pub(crate) fn parse_assert_incr_state( slot: &mut Option, v: Option<&str>, @@ -2072,6 +2219,26 @@ pub mod parse { _ => return false, }; true +======= + pub(crate) fn parse_allow_partial_mitigations( + slot: &mut Vec, + v: Option<&str>, + ) -> bool { + match v { + Some(s) => { + for sub in s.split(',') { + let (sub, enabled) = + if sub.starts_with('!') { (&sub[1..], false) } else { (sub, true) }; + match sub.parse() { + Ok(kind) => slot.push(MitigationEnablement { kind, enabled }), + Err(_) => return false, + } + } + true + } + None => false, + } +>>>>>>> 615d0911bd2 (Implement `-Z allow-partial-mitigations` (RFC 3855)) } } @@ -2237,6 +2404,8 @@ options! { // tidy-alphabetical-start allow_features: Option> = (None, parse_opt_comma_list, [TRACKED], "only allow the listed language features to be enabled in code (comma separated)"), + allow_partial_mitigations: Vec = (Vec::new(), parse_allow_partial_mitigations, [UNTRACKED], + "Allow mitigations not enabled for all dependency crates (comma separated list)"), always_encode_mir: bool = (false, parse_bool, [TRACKED], "encode MIR of all functions into the crate metadata (default: no)"), annotate_moves: AnnotateMoves = (AnnotateMoves::Disabled, parse_annotate_moves, [TRACKED], diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs index 68d6162bd590e..a533220197d05 100644 --- a/compiler/rustc_target/src/spec/mod.rs +++ b/compiler/rustc_target/src/spec/mod.rs @@ -1347,6 +1347,7 @@ impl FramePointer { crate::target_spec_enum! { /// Controls use of stack canaries. + #[derive(Encodable, BlobDecodable, HashStable_Generic)] pub enum StackProtector { /// Disable stack canary generation. None = "none", diff --git a/tests/ui/README.md b/tests/ui/README.md index a9e7f022c2b60..ab9b58aa4981f 100644 --- a/tests/ui/README.md +++ b/tests/ui/README.md @@ -22,6 +22,12 @@ These tests exercise `#![feature(allocator_api)]` and the `#[global_allocator]` See [Allocator traits and `std::heap` #32838](https://github.com/rust-lang/rust/issues/32838). +## `tests/ui/allow-partial-mitigations` + +These tests exercise the check against partial mitigation enforcement. + +See [the mitigation enforcement RFC](https://github.com/rust-lang/rfcs/pull/3855). + ## `tests/ui/annotate-moves` These tests exercise the `annotate-moves` feature. diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.both.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.both.stderr new file mode 100644 index 0000000000000..35801653495ef --- /dev/null +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.both.stderr @@ -0,0 +1,92 @@ +error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `std`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `std` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` + +error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `core`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `core` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` + +error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `alloc`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `alloc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` + +error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `compiler_builtins`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `compiler_builtins` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` + +error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `libc`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `libc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` + +error: aborting due to 10 previous errors + diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.disable.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.disable.stderr new file mode 100644 index 0000000000000..f0e48e02347b3 --- /dev/null +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.disable.stderr @@ -0,0 +1,47 @@ +error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: aborting due to 5 previous errors + diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.enable-disable.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.enable-disable.stderr new file mode 100644 index 0000000000000..f0e48e02347b3 --- /dev/null +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.enable-disable.stderr @@ -0,0 +1,47 @@ +error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: aborting due to 5 previous errors + diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.rs b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.rs new file mode 100644 index 0000000000000..0aa1c5933ea53 --- /dev/null +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.rs @@ -0,0 +1,43 @@ +// ignore-tidy-linelength +//@ revisions: sp both disable enable-disable wrong-enable +//@ check-fail +//@ ignore-nvptx64 stack protector is not supported +//@ ignore-wasm32-unknown-unknown stack protector is not supported +//@ edition:future +//@ [both] compile-flags: -Z unstable-options -C control-flow-guard=on -Z stack-protector=all +//@ [sp] compile-flags: -Z unstable-options -Z stack-protector=all +//@ [disable] compile-flags: -Z unstable-options -Z allow-partial-mitigations=!stack-protector -Z stack-protector=all +//@ [enable-disable] compile-flags: -Z unstable-options -Z allow-partial-mitigations=stack-protector -Z allow-partial-mitigations=!stack-protector -Z stack-protector=all +//@ [wrong-enable] compile-flags: -Z unstable-options -Z allow-partial-mitigations=control-flow-guard -Z stack-protector=all + +fn main() {} +//[both]~^ ERROR that is not compiled with +//[both]~| ERROR that is not compiled with +//[both]~| ERROR that is not compiled with +//[both]~| ERROR that is not compiled with +//[both]~| ERROR that is not compiled with +//[both]~| ERROR that is not compiled with +//[both]~| ERROR that is not compiled with +//[both]~| ERROR that is not compiled with +//[both]~| ERROR that is not compiled with +//[both]~| ERROR that is not compiled with +//[sp]~^^^^^^^^^^^ ERROR that is not compiled with +//[sp]~| ERROR that is not compiled with +//[sp]~| ERROR that is not compiled with +//[sp]~| ERROR that is not compiled with +//[sp]~| ERROR that is not compiled with +//[disable]~^^^^^^^^^^^^^^^^ ERROR that is not compiled with +//[disable]~| ERROR that is not compiled with +//[disable]~| ERROR that is not compiled with +//[disable]~| ERROR that is not compiled with +//[disable]~| ERROR that is not compiled with +//[enable-disable]~^^^^^^^^^^^^^^^^^^^^^ ERROR that is not compiled with +//[enable-disable]~| ERROR that is not compiled with +//[enable-disable]~| ERROR that is not compiled with +//[enable-disable]~| ERROR that is not compiled with +//[enable-disable]~| ERROR that is not compiled with +//[wrong-enable]~^^^^^^^^^^^^^^^^^^^^^^^^^^ ERROR that is not compiled with +//[wrong-enable]~| ERROR that is not compiled with +//[wrong-enable]~| ERROR that is not compiled with +//[wrong-enable]~| ERROR that is not compiled with +//[wrong-enable]~| ERROR that is not compiled with diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.sp.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.sp.stderr new file mode 100644 index 0000000000000..f0e48e02347b3 --- /dev/null +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.sp.stderr @@ -0,0 +1,47 @@ +error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: aborting due to 5 previous errors + diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.wrong-enable.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.wrong-enable.stderr new file mode 100644 index 0000000000000..f0e48e02347b3 --- /dev/null +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.wrong-enable.stderr @@ -0,0 +1,47 @@ +error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:13:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: aborting due to 5 previous errors + diff --git a/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations-minicore.rs b/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations-minicore.rs new file mode 100644 index 0000000000000..16eecd455dbe0 --- /dev/null +++ b/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations-minicore.rs @@ -0,0 +1,18 @@ +// ignore-tidy-linelength +//@ check-pass +//@ add-minicore +//@ edition:future +//@ revisions: default deny +//@[default] compile-flags: -Z unstable-options -Z stack-protector=all +//@[deny] compile-flags: -Z allow-partial-mitigations=!stack-protector -Z unstable-options -Z stack-protector=all + +// ^ enables stack-protector for both minicore and this crate + +#![crate_type = "lib"] +#![feature(no_core)] +#![no_std] +#![no_core] + +extern crate minicore; + +pub fn foo() {} diff --git a/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations.rs b/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations.rs new file mode 100644 index 0000000000000..c0ec555305841 --- /dev/null +++ b/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations.rs @@ -0,0 +1,11 @@ +// ignore-tidy-linelength +//@ revisions: sp both disable-enable +//@ check-pass +//@ edition:future +//@ ignore-nvptx64 stack protector is not supported +//@ ignore-wasm32-unknown-unknown stack protector is not supported +//@ [both] compile-flags: -Z unstable-options -Z allow-partial-mitigations=stack-protector,control-flow-guard -C control-flow-guard=on -Z stack-protector=all +//@ [sp] compile-flags: -Z unstable-options -Z allow-partial-mitigations=stack-protector -Z stack-protector=all +//@ [disable-enable] compile-flags: -Z unstable-options -Z allow-partial-mitigations=!stack-protector -Z allow-partial-mitigations=stack-protector -Z stack-protector=all + +fn main() {} From daedc77e8431d712a4f2351eb61b84e278bdfaea Mon Sep 17 00:00:00 2001 From: Ariel Ben-Yehuda Date: Wed, 26 Nov 2025 20:14:39 +0000 Subject: [PATCH 02/11] address review comments --- compiler/rustc_metadata/src/creader.rs | 6 +- compiler/rustc_metadata/src/rmeta/decoder.rs | 3 +- compiler/rustc_metadata/src/rmeta/encoder.rs | 3 +- compiler/rustc_metadata/src/rmeta/mod.rs | 3 +- .../rustc_metadata/src/rmeta/parameterized.rs | 2 +- compiler/rustc_session/src/config.rs | 1 + compiler/rustc_session/src/options.rs | 161 ++---------------- .../src/options/enforced_mitigations.rs | 153 +++++++++++++++++ 8 files changed, 177 insertions(+), 155 deletions(-) create mode 100644 compiler/rustc_session/src/options/enforced_mitigations.rs diff --git a/compiler/rustc_metadata/src/creader.rs b/compiler/rustc_metadata/src/creader.rs index 7434a3f9e29bc..685aeb125c34c 100644 --- a/compiler/rustc_metadata/src/creader.rs +++ b/compiler/rustc_metadata/src/creader.rs @@ -24,9 +24,11 @@ use rustc_middle::bug; 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::{ - CrateType, EnforcedMitigationLevel, ExtendedTargetModifierInfo, ExternLocation, Externs, - OptionsTargetModifiers, TargetModifier, + CrateType, ExtendedTargetModifierInfo, ExternLocation, Externs, OptionsTargetModifiers, + TargetModifier, }; use rustc_session::cstore::{CrateDepKind, CrateSource, ExternCrate, ExternCrateSource}; use rustc_session::output::validate_crate_name; diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs index 613501805f729..36bada1e59b1b 100644 --- a/compiler/rustc_metadata/src/rmeta/decoder.rs +++ b/compiler/rustc_metadata/src/rmeta/decoder.rs @@ -29,7 +29,8 @@ use rustc_middle::{bug, implement_ty_decoder}; use rustc_proc_macro::bridge::client::ProcMacro; use rustc_serialize::opaque::MemDecoder; use rustc_serialize::{Decodable, Decoder}; -use rustc_session::config::{EnforcedMitigation, TargetModifier}; +use rustc_session::config::TargetModifier; +use rustc_session::config::enforced_mitigations::EnforcedMitigation; use rustc_session::cstore::{CrateSource, ExternCrate}; use rustc_span::hygiene::HygieneDecodeContext; use rustc_span::{ diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs index ae7c3310f7a9c..839b41cb4450d 100644 --- a/compiler/rustc_metadata/src/rmeta/encoder.rs +++ b/compiler/rustc_metadata/src/rmeta/encoder.rs @@ -27,7 +27,8 @@ 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::{CrateType, EnforcedMitigation, OptLevel, TargetModifier}; +use rustc_session::config::enforced_mitigations::EnforcedMitigation; +use rustc_session::config::{CrateType, OptLevel, TargetModifier}; use rustc_span::hygiene::HygieneEncodeContext; use rustc_span::{ ByteSymbol, ExternalSource, FileName, SourceFile, SpanData, SpanEncoder, StableSourceFileId, diff --git a/compiler/rustc_metadata/src/rmeta/mod.rs b/compiler/rustc_metadata/src/rmeta/mod.rs index 9128a52c90fd2..ce423f325b5c9 100644 --- a/compiler/rustc_metadata/src/rmeta/mod.rs +++ b/compiler/rustc_metadata/src/rmeta/mod.rs @@ -36,7 +36,8 @@ use rustc_middle::ty::fast_reject::SimplifiedType; use rustc_middle::ty::{self, Ty, TyCtxt}; use rustc_middle::util::Providers; use rustc_serialize::opaque::FileEncoder; -use rustc_session::config::{EnforcedMitigation, SymbolManglingVersion, TargetModifier}; +use rustc_session::config::enforced_mitigations::EnforcedMitigation; +use rustc_session::config::{SymbolManglingVersion, TargetModifier}; use rustc_session::cstore::{CrateDepKind, ForeignModule, LinkagePreference, NativeLib}; use rustc_span::edition::Edition; use rustc_span::hygiene::{ExpnIndex, MacroKind, SyntaxContextKey}; diff --git a/compiler/rustc_metadata/src/rmeta/parameterized.rs b/compiler/rustc_metadata/src/rmeta/parameterized.rs index ee22a08850bca..8debefd21a070 100644 --- a/compiler/rustc_metadata/src/rmeta/parameterized.rs +++ b/compiler/rustc_metadata/src/rmeta/parameterized.rs @@ -119,8 +119,8 @@ trivially_parameterized_over_tcx! { rustc_middle::ty::Visibility, rustc_middle::ty::adjustment::CoerceUnsizedInfo, rustc_middle::ty::fast_reject::SimplifiedType, - rustc_session::config::EnforcedMitigation, rustc_session::config::TargetModifier, + rustc_session::config::enforced_mitigations::EnforcedMitigation, rustc_session::cstore::ForeignModule, rustc_session::cstore::LinkagePreference, rustc_session::cstore::NativeLib, diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs index bdc07c5ad528e..1a7b38c9f5189 100644 --- a/compiler/rustc_session/src/config.rs +++ b/compiler/rustc_session/src/config.rs @@ -33,6 +33,7 @@ use rustc_target::spec::{ use tracing::debug; pub use crate::config::cfg::{Cfg, CheckCfg, ExpectedValues}; +use crate::config::enforced_mitigations::EnforcedMitigationKind; use crate::config::native_libs::parse_native_libs; pub use crate::config::print_request::{PrintKind, PrintRequest}; use crate::errors::FileWriteFail; diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs index 2fac722473762..09710a13b6c5a 100644 --- a/compiler/rustc_session/src/options.rs +++ b/compiler/rustc_session/src/options.rs @@ -1,7 +1,7 @@ use std::collections::BTreeMap; use std::num::{IntErrorKind, NonZero}; use std::path::PathBuf; -use std::str::{self, FromStr}; +use std::str; use rustc_abi::Align; use rustc_data_structures::fx::FxIndexMap; @@ -11,7 +11,7 @@ use rustc_errors::{ColorConfig, TerminalUrl}; use rustc_feature::UnstableFeatures; use rustc_hashes::Hash64; use rustc_hir::attrs::CollapseMacroDebuginfo; -use rustc_macros::{BlobDecodable, Decodable, Encodable}; +use rustc_macros::{BlobDecodable, Encodable}; use rustc_span::edition::Edition; use rustc_span::{RealFileName, RemapPathScopeComponents, SourceFileHashAlgorithm}; use rustc_target::spec::{ @@ -20,6 +20,7 @@ use rustc_target::spec::{ TargetTuple, TlsModel, }; +use crate::config::enforced_mitigations::MitigationEnablement; use crate::config::*; use crate::search_paths::SearchPath; use crate::utils::NativeLib; @@ -84,150 +85,7 @@ pub struct TargetModifier { pub value_name: String, } -#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Encodable, BlobDecodable)] -pub enum EnforcedMitigationLevel { - // Enabled(false) should be the bottom of the Ord hierarchy - Enabled(bool), - StackProtector(StackProtector), -} - -impl EnforcedMitigationLevel { - pub fn level_str(&self) -> &'static str { - match self { - EnforcedMitigationLevel::StackProtector(StackProtector::All) => "=all", - EnforcedMitigationLevel::StackProtector(StackProtector::Basic) => "=basic", - EnforcedMitigationLevel::StackProtector(StackProtector::Strong) => "=strong", - // currently `=disabled` should not appear - EnforcedMitigationLevel::Enabled(false) => "=disabled", - EnforcedMitigationLevel::StackProtector(StackProtector::None) - | EnforcedMitigationLevel::Enabled(true) => "", - } - } -} - -impl std::fmt::Display for EnforcedMitigationLevel { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - EnforcedMitigationLevel::StackProtector(StackProtector::All) => { - write!(f, "all") - } - EnforcedMitigationLevel::StackProtector(StackProtector::Basic) => { - write!(f, "basic") - } - EnforcedMitigationLevel::StackProtector(StackProtector::Strong) => { - write!(f, "strong") - } - EnforcedMitigationLevel::Enabled(true) => { - write!(f, "enabled") - } - EnforcedMitigationLevel::StackProtector(StackProtector::None) - | EnforcedMitigationLevel::Enabled(false) => { - write!(f, "disabled") - } - } - } -} - -impl From for EnforcedMitigationLevel { - fn from(value: bool) -> Self { - EnforcedMitigationLevel::Enabled(value) - } -} - -impl From for EnforcedMitigationLevel { - fn from(value: StackProtector) -> Self { - EnforcedMitigationLevel::StackProtector(value) - } -} - -pub struct EnforcedMitigationKindParseError; - -#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Encodable, Decodable)] -pub struct MitigationEnablement { - pub kind: EnforcedMitigationKind, - pub enabled: bool, -} - -macro_rules! intersperse { - ($sep:expr, ($first:expr $(, $rest:expr)* $(,)?)) => { - concat!($first $(, $sep, $rest)*) - }; -} - -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 { - $($name),* - } - - impl std::fmt::Display for EnforcedMitigationKind { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - $(EnforcedMitigationKind::$name => write!(f, $text)),* - } - } - } - - impl EnforcedMitigationKind { - const KINDS: &'static str = concat!("comma-separated list of mitigation kinds (available: ", - intersperse!(", ", ($(concat!("`", $text, "`")),*)), ")"); - } - - impl FromStr for EnforcedMitigationKind { - type Err = EnforcedMitigationKindParseError; - - fn from_str(v: &str) -> Result { - match v { - $($text => Ok(EnforcedMitigationKind::$name)),* - , - _ => Err(EnforcedMitigationKindParseError), - } - } - } - - #[allow(unused)] - impl EnforcedMitigationKind { - 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),* - } - } - } - - impl Session { - pub fn gather_enabled_enforced_mitigations(&$self) -> Vec { - let mut mitigations = [ - $( - EnforcedMitigation { - kind: EnforcedMitigationKind::$name, - level: From::from($code), - } - ),* - ]; - mitigations.sort(); - mitigations.into_iter().collect() - } - } - } -} - -enforced_mitigations! { - [self] - enum EnforcedMitigationKind { - (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 mod enforced_mitigations; mod target_modifier_consistency_check { use super::*; @@ -1033,14 +891,20 @@ 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) } pub mod parse { use std::str::FromStr; pub(crate) use super::*; + use crate::config::enforced_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 @@ -2208,7 +2072,6 @@ pub mod parse { true } -<<<<<<< HEAD pub(crate) fn parse_assert_incr_state( slot: &mut Option, v: Option<&str>, @@ -2219,7 +2082,8 @@ pub mod parse { _ => return false, }; true -======= + } + pub(crate) fn parse_allow_partial_mitigations( slot: &mut Vec, v: Option<&str>, @@ -2238,7 +2102,6 @@ pub mod parse { } None => false, } ->>>>>>> 615d0911bd2 (Implement `-Z allow-partial-mitigations` (RFC 3855)) } } diff --git a/compiler/rustc_session/src/options/enforced_mitigations.rs b/compiler/rustc_session/src/options/enforced_mitigations.rs new file mode 100644 index 0000000000000..7b965595fbdde --- /dev/null +++ b/compiler/rustc_session/src/options/enforced_mitigations.rs @@ -0,0 +1,153 @@ +use std::str::FromStr; + +use rustc_macros::{BlobDecodable, Encodable}; +use rustc_span::edition::Edition; +use rustc_target::spec::StackProtector; + +use crate::Session; +use crate::options::CFGuard; + +#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Encodable, BlobDecodable)] +pub enum EnforcedMitigationLevel { + // Enabled(false) should be the bottom of the Ord hierarchy + Enabled(bool), + StackProtector(StackProtector), +} + +impl EnforcedMitigationLevel { + pub fn level_str(&self) -> &'static str { + match self { + EnforcedMitigationLevel::StackProtector(StackProtector::All) => "=all", + EnforcedMitigationLevel::StackProtector(StackProtector::Basic) => "=basic", + EnforcedMitigationLevel::StackProtector(StackProtector::Strong) => "=strong", + // currently `=disabled` should not appear + EnforcedMitigationLevel::Enabled(false) => "=disabled", + EnforcedMitigationLevel::StackProtector(StackProtector::None) + | EnforcedMitigationLevel::Enabled(true) => "", + } + } +} + +impl std::fmt::Display for EnforcedMitigationLevel { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + EnforcedMitigationLevel::StackProtector(StackProtector::All) => { + write!(f, "all") + } + EnforcedMitigationLevel::StackProtector(StackProtector::Basic) => { + write!(f, "basic") + } + EnforcedMitigationLevel::StackProtector(StackProtector::Strong) => { + write!(f, "strong") + } + EnforcedMitigationLevel::Enabled(true) => { + write!(f, "enabled") + } + EnforcedMitigationLevel::StackProtector(StackProtector::None) + | EnforcedMitigationLevel::Enabled(false) => { + write!(f, "disabled") + } + } + } +} + +impl From for EnforcedMitigationLevel { + fn from(value: bool) -> Self { + EnforcedMitigationLevel::Enabled(value) + } +} + +impl From for EnforcedMitigationLevel { + fn from(value: StackProtector) -> Self { + EnforcedMitigationLevel::StackProtector(value) + } +} + +pub struct EnforcedMitigationKindParseError; + +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Encodable, BlobDecodable)] +pub struct MitigationEnablement { + pub kind: EnforcedMitigationKind, + pub enabled: bool, +} + +macro_rules! intersperse { + ($sep:expr, ($first:expr $(, $rest:expr)* $(,)?)) => { + concat!($first $(, $sep, $rest)*) + }; +} + +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 { + $($name),* + } + + impl std::fmt::Display for EnforcedMitigationKind { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + $(EnforcedMitigationKind::$name => write!(f, $text)),* + } + } + } + + impl EnforcedMitigationKind { + pub(crate) const KINDS: &'static str = concat!("comma-separated list of mitigation kinds (available: ", + intersperse!(", ", ($(concat!("`", $text, "`")),*)), ")"); + } + + impl FromStr for EnforcedMitigationKind { + type Err = EnforcedMitigationKindParseError; + + fn from_str(v: &str) -> Result { + match v { + $($text => Ok(EnforcedMitigationKind::$name)),* + , + _ => Err(EnforcedMitigationKindParseError), + } + } + } + + #[allow(unused)] + impl EnforcedMitigationKind { + 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),* + } + } + } + + impl Session { + pub fn gather_enabled_enforced_mitigations(&$self) -> Vec { + let mut mitigations = [ + $( + EnforcedMitigation { + kind: EnforcedMitigationKind::$name, + level: From::from($code), + } + ),* + ]; + mitigations.sort(); + mitigations.into_iter().collect() + } + } + } +} + +enforced_mitigations! { + [self] + enum EnforcedMitigationKind { + (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, +} From 51b2b93239a99970db1bbdc41f9765e12a184b03 Mon Sep 17 00:00:00 2001 From: Ariel Ben-Yehuda Date: Thu, 27 Nov 2025 15:00:09 +0000 Subject: [PATCH 03/11] allow denying mitigations in earlier editions --- compiler/rustc_metadata/src/creader.rs | 9 ++-- compiler/rustc_session/src/config.rs | 13 ----- .../src/options/enforced_mitigations.rs | 29 ++++++++++++ ...low-partial-mitigations-current-edition.rs | 17 +++++++ ...partial-mitigations-current-edition.stderr | 47 +++++++++++++++++++ 5 files changed, 96 insertions(+), 19 deletions(-) create mode 100644 tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.rs create mode 100644 tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.stderr diff --git a/compiler/rustc_metadata/src/creader.rs b/compiler/rustc_metadata/src/creader.rs index 685aeb125c34c..d1ee527eeea42 100644 --- a/compiler/rustc_metadata/src/creader.rs +++ b/compiler/rustc_metadata/src/creader.rs @@ -495,12 +495,9 @@ impl CStore { pub fn report_incompatible_enforced_mitigations(&self, tcx: TyCtxt<'_>, krate: &Crate) { let my_mitigations = tcx.sess.gather_enabled_enforced_mitigations(); - let mut my_mitigations: BTreeMap<_, _> = my_mitigations - .iter() - .filter(|mitigation| mitigation.kind.enforced_since() <= tcx.sess.edition()) - .map(|mitigation| (mitigation.kind, mitigation)) - .collect(); - for skipped_mitigation in tcx.sess.opts.allowed_partial_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()) { my_mitigations.remove(&skipped_mitigation); } const MAX_ERRORS_PER_MITIGATION: usize = 5; diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs index 1a7b38c9f5189..e4ef1d40d72d5 100644 --- a/compiler/rustc_session/src/config.rs +++ b/compiler/rustc_session/src/config.rs @@ -33,7 +33,6 @@ use rustc_target::spec::{ use tracing::debug; pub use crate::config::cfg::{Cfg, CheckCfg, ExpectedValues}; -use crate::config::enforced_mitigations::EnforcedMitigationKind; use crate::config::native_libs::parse_native_libs; pub use crate::config::print_request::{PrintKind, PrintRequest}; use crate::errors::FileWriteFail; @@ -1495,18 +1494,6 @@ impl Options { pub fn autodiff_enabled(&self) -> bool { self.unstable_opts.autodiff.contains(&AutoDiff::Enable) } - - pub fn allowed_partial_mitigations(&self) -> impl Iterator { - let mut result = BTreeSet::default(); - for mitigation in &self.unstable_opts.allow_partial_mitigations { - if mitigation.enabled { - result.insert(mitigation.kind); - } else { - result.remove(&mitigation.kind); - } - } - result.into_iter() - } } impl UnstableOptions { diff --git a/compiler/rustc_session/src/options/enforced_mitigations.rs b/compiler/rustc_session/src/options/enforced_mitigations.rs index 7b965595fbdde..731b519eda58e 100644 --- a/compiler/rustc_session/src/options/enforced_mitigations.rs +++ b/compiler/rustc_session/src/options/enforced_mitigations.rs @@ -1,3 +1,4 @@ +use std::collections::BTreeSet; use std::str::FromStr; use rustc_macros::{BlobDecodable, Encodable}; @@ -5,6 +6,7 @@ use rustc_span::edition::Edition; use rustc_target::spec::StackProtector; use crate::Session; +use crate::config::Options; use crate::options::CFGuard; #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Encodable, BlobDecodable)] @@ -120,6 +122,12 @@ macro_rules! enforced_mitigations { } } + impl Options { + pub fn all_enforced_mitigations(&self) -> impl Iterator { + [$(EnforcedMitigationKind::$name),*].into_iter() + } + } + impl Session { pub fn gather_enabled_enforced_mitigations(&$self) -> Vec { let mut mitigations = [ @@ -151,3 +159,24 @@ pub struct EnforcedMitigation { pub kind: EnforcedMitigationKind, pub level: EnforcedMitigationLevel, } + +impl Options { + // Return the list of mitigations that are allowed to be partial + pub fn allowed_partial_mitigations( + &self, + edition: Edition, + ) -> impl Iterator { + let mut result: BTreeSet<_> = self + .all_enforced_mitigations() + .filter(|mitigation| mitigation.enforced_since() > edition) + .collect(); + for mitigation in &self.unstable_opts.allow_partial_mitigations { + if mitigation.enabled { + result.insert(mitigation.kind); + } else { + result.remove(&mitigation.kind); + } + } + result.into_iter() + } +} diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.rs b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.rs new file mode 100644 index 0000000000000..1299e5e003cac --- /dev/null +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.rs @@ -0,0 +1,17 @@ +// ignore-tidy-linelength +//@ check-fail +//@ ignore-nvptx64 stack protector is not supported +//@ ignore-wasm32-unknown-unknown stack protector is not supported +//@ edition: 2024 +//@ compile-flags: -Z allow-partial-mitigations=!control-flow-guard -C control-flow-guard=on + +// check that in edition 2024, it is still possible to explicitly +// disallow partial mitigations (in edition=future, they are +// disallowed by default) + +fn main() {} +//~^ ERROR that is not compiled with +//~| ERROR that is not compiled with +//~| ERROR that is not compiled with +//~| ERROR that is not compiled with +//~| ERROR that is not compiled with diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.stderr new file mode 100644 index 0000000000000..02e9154986791 --- /dev/null +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.stderr @@ -0,0 +1,47 @@ +error: your program uses the crate `std`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations-current-edition.rs:12:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `std` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` + +error: your program uses the crate `core`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations-current-edition.rs:12:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `core` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` + +error: your program uses the crate `alloc`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations-current-edition.rs:12:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `alloc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` + +error: your program uses the crate `compiler_builtins`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations-current-edition.rs:12:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `compiler_builtins` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` + +error: your program uses the crate `libc`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations-current-edition.rs:12:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `libc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` + +error: aborting due to 5 previous errors + From eb89ca9b776fe4f55e1541c2fb7aba4d9ae38b7e Mon Sep 17 00:00:00 2001 From: Ariel Ben-Yehuda Date: Sun, 7 Dec 2025 12:14:23 +0000 Subject: [PATCH 04/11] 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 d1ee527eeea42..972c1e2df9323 100644 --- a/compiler/rustc_metadata/src/creader.rs +++ b/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, @@ -468,7 +468,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); } @@ -493,8 +493,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()) { @@ -506,12 +506,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 { diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs index 36bada1e59b1b..7344be2cb3178 100644 --- a/compiler/rustc_metadata/src/rmeta/decoder.rs +++ b/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::{ @@ -82,8 +82,8 @@ pub(crate) type CrateNumMap = IndexVec; /// 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 @@ 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 { - self.enforced_mitigations.decode(metadata) + ) -> impl ExactSizeIterator { + self.enforcable_mitigations.decode(metadata) } } @@ -1952,8 +1952,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 diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs index 839b41cb4450d..712c5aa0e2b83 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::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(); @@ -761,7 +761,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { foreign_modules, source_map, target_modifiers, - enforced_mitigations, + enforcable_mitigations, traits, impls, incoherent_impls, @@ -2108,10 +2108,10 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { 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 ce423f325b5c9..6d9627b9528d9 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::fast_reject::SimplifiedType; 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 8debefd21a070..b993932eb70dc 100644 --- a/compiler/rustc_metadata/src/rmeta/parameterized.rs +++ b/compiler/rustc_metadata/src/rmeta/parameterized.rs @@ -120,7 +120,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, diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs index 09710a13b6c5a..4bf92c3304f89 100644 --- a/compiler/rustc_session/src/options.rs +++ b/compiler/rustc_session/src/options.rs @@ -20,7 +20,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; @@ -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 731b519eda58e..667dd0b8aadc7 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::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 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 @@ 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) } @@ -155,9 +155,9 @@ enforced_mitigations! { /// 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) From 3600f4cd2c07f632a83e8473c4ed98e475c4cfbe Mon Sep 17 00:00:00 2001 From: Ariel Ben-Yehuda Date: Wed, 10 Dec 2025 18:37:48 +0000 Subject: [PATCH 05/11] EnforcableMitigation => DeniedPartialMitigation --- compiler/rustc_metadata/src/creader.rs | 12 +-- compiler/rustc_metadata/src/rmeta/decoder.rs | 14 ++-- 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 | 2 +- .../src/options/enforcable_mitigations.rs | 84 +++++++++---------- 7 files changed, 65 insertions(+), 65 deletions(-) diff --git a/compiler/rustc_metadata/src/creader.rs b/compiler/rustc_metadata/src/creader.rs index 972c1e2df9323..cee7a41a1182c 100644 --- a/compiler/rustc_metadata/src/creader.rs +++ b/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::enforcable_mitigations::EnforcableMitigationLevel; +use rustc_session::config::enforcable_mitigations::DeniedPartialMitigationLevel; use rustc_session::config::{ CrateType, ExtendedTargetModifierInfo, ExternLocation, Externs, OptionsTargetModifiers, TargetModifier, @@ -468,7 +468,7 @@ impl CStore { pub fn report_session_incompatibilities(&self, tcx: TyCtxt<'_>, krate: &Crate) { self.report_incompatible_target_modifiers(tcx, krate); - self.report_incompatible_enforcable_mitigations(tcx, krate); + self.report_incompatible_denied_partial_mitigations(tcx, krate); self.report_incompatible_async_drop_feature(tcx, krate); } @@ -493,8 +493,8 @@ impl CStore { } } - pub fn report_incompatible_enforcable_mitigations(&self, tcx: TyCtxt<'_>, krate: &Crate) { - let my_mitigations = tcx.sess.gather_enabled_enforcable_mitigations(); + pub fn report_incompatible_denied_partial_mitigations(&self, tcx: TyCtxt<'_>, krate: &Crate) { + let my_mitigations = tcx.sess.gather_enabled_denied_partial_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 @@ impl CStore { if data.is_proc_macro_crate() { continue; } - let their_mitigations = data.enabled_enforcable_mitigations(); + let their_mitigations = data.enabled_denied_partial_mitigations(); for my_mitigation in my_mitigations.values() { let their_mitigation = their_mitigations .iter() .find(|mitigation| mitigation.kind == my_mitigation.kind) - .map_or(EnforcableMitigationLevel::Enabled(false), |m| m.level); + .map_or(DeniedPartialMitigationLevel::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 7344be2cb3178..00ca24c6b7501 100644 --- a/compiler/rustc_metadata/src/rmeta/decoder.rs +++ b/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::enforcable_mitigations::EnforcableMitigation; +use rustc_session::config::enforcable_mitigations::DeniedPartialMitigation; use rustc_session::cstore::{CrateSource, ExternCrate}; use rustc_span::hygiene::HygieneDecodeContext; use rustc_span::{ @@ -83,7 +83,7 @@ pub(crate) type CrateNumMap = IndexVec; pub(crate) type TargetModifiers = Vec; /// The set of enforcable mitigations (RFC 3855) that are currently enabled for this crate -pub(crate) type EnforcableMitigations = Vec; +pub(crate) type DeniedPartialMitigations = Vec; pub(crate) struct CrateMetadata { /// The primary crate data - binary metadata blob. @@ -964,11 +964,11 @@ impl CrateRoot { self.target_modifiers.decode(metadata) } - pub(crate) fn decode_enforcable_mitigations<'a>( + pub(crate) fn decode_denied_partial_mitigations<'a>( &self, metadata: &'a MetadataBlob, - ) -> impl ExactSizeIterator { - self.enforcable_mitigations.decode(metadata) + ) -> impl ExactSizeIterator { + self.denied_partial_mitigations.decode(metadata) } } @@ -1952,8 +1952,8 @@ impl CrateMetadata { self.root.decode_target_modifiers(&self.blob).collect() } - pub(crate) fn enabled_enforcable_mitigations(&self) -> EnforcableMitigations { - self.root.decode_enforcable_mitigations(&self.blob).collect() + pub(crate) fn enabled_denied_partial_mitigations(&self) -> DeniedPartialMitigations { + self.root.decode_denied_partial_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 712c5aa0e2b83..ef5416ac427d5 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::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::enforcable_mitigations::EnforcableMitigation; +use rustc_session::config::enforcable_mitigations::DeniedPartialMitigation; 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 enforcable_mitigations = - stat!("enforced-mitigations", || self.encode_enabled_enforcable_mitigations()); + let denied_partial_mitigations = + stat!("enforced-mitigations", || self.encode_enabled_denied_partial_mitigations()); let root = stat!("final", || { let attrs = tcx.hir_krate_attrs(); @@ -761,7 +761,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { foreign_modules, source_map, target_modifiers, - enforcable_mitigations, + denied_partial_mitigations, traits, impls, incoherent_impls, @@ -2108,10 +2108,10 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { self.lazy_array(tcx.sess.opts.gather_target_modifiers()) } - fn encode_enabled_enforcable_mitigations(&mut self) -> LazyArray { + fn encode_enabled_denied_partial_mitigations(&mut self) -> LazyArray { empty_proc_macro!(self); let tcx = self.tcx; - self.lazy_array(tcx.sess.gather_enabled_enforcable_mitigations()) + self.lazy_array(tcx.sess.gather_enabled_denied_partial_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 6d9627b9528d9..bcc0aa1f3be8c 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::fast_reject::SimplifiedType; use rustc_middle::ty::{self, Ty, TyCtxt}; use rustc_middle::util::Providers; use rustc_serialize::opaque::FileEncoder; -use rustc_session::config::enforcable_mitigations::EnforcableMitigation; +use rustc_session::config::enforcable_mitigations::DeniedPartialMitigation; 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, - enforcable_mitigations: LazyArray, + denied_partial_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 b993932eb70dc..35ea06b384536 100644 --- a/compiler/rustc_metadata/src/rmeta/parameterized.rs +++ b/compiler/rustc_metadata/src/rmeta/parameterized.rs @@ -120,7 +120,7 @@ trivially_parameterized_over_tcx! { rustc_middle::ty::adjustment::CoerceUnsizedInfo, rustc_middle::ty::fast_reject::SimplifiedType, rustc_session::config::TargetModifier, - rustc_session::config::enforcable_mitigations::EnforcableMitigation, + rustc_session::config::enforcable_mitigations::DeniedPartialMitigation, 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 4bf92c3304f89..c84c9318fcf2a 100644 --- a/compiler/rustc_session/src/options.rs +++ b/compiler/rustc_session/src/options.rs @@ -893,7 +893,7 @@ mod desc { pub(crate) const parse_align: &str = "a number that is a power of 2 between 1 and 2^29"; pub(crate) const parse_assert_incr_state: &str = "one of: `loaded`, `not-loaded`"; pub(crate) const parse_allow_partial_mitigations: &str = - super::enforcable_mitigations::EnforcableMitigationKind::KINDS; + super::enforcable_mitigations::DeniedPartialMitigationKind::KINDS; } pub mod parse { diff --git a/compiler/rustc_session/src/options/enforcable_mitigations.rs b/compiler/rustc_session/src/options/enforcable_mitigations.rs index 667dd0b8aadc7..851659f416e85 100644 --- a/compiler/rustc_session/src/options/enforcable_mitigations.rs +++ b/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 EnforcableMitigationLevel { +pub enum DeniedPartialMitigationLevel { // Enabled(false) should be the bottom of the Ord hierarchy Enabled(bool), StackProtector(StackProtector), } -impl EnforcableMitigationLevel { +impl DeniedPartialMitigationLevel { pub fn level_str(&self) -> &'static str { match self { - EnforcableMitigationLevel::StackProtector(StackProtector::All) => "=all", - EnforcableMitigationLevel::StackProtector(StackProtector::Basic) => "=basic", - EnforcableMitigationLevel::StackProtector(StackProtector::Strong) => "=strong", + DeniedPartialMitigationLevel::StackProtector(StackProtector::All) => "=all", + DeniedPartialMitigationLevel::StackProtector(StackProtector::Basic) => "=basic", + DeniedPartialMitigationLevel::StackProtector(StackProtector::Strong) => "=strong", // currently `=disabled` should not appear - EnforcableMitigationLevel::Enabled(false) => "=disabled", - EnforcableMitigationLevel::StackProtector(StackProtector::None) - | EnforcableMitigationLevel::Enabled(true) => "", + DeniedPartialMitigationLevel::Enabled(false) => "=disabled", + DeniedPartialMitigationLevel::StackProtector(StackProtector::None) + | DeniedPartialMitigationLevel::Enabled(true) => "", } } } -impl std::fmt::Display for EnforcableMitigationLevel { +impl std::fmt::Display for DeniedPartialMitigationLevel { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { - EnforcableMitigationLevel::StackProtector(StackProtector::All) => { + DeniedPartialMitigationLevel::StackProtector(StackProtector::All) => { write!(f, "all") } - EnforcableMitigationLevel::StackProtector(StackProtector::Basic) => { + DeniedPartialMitigationLevel::StackProtector(StackProtector::Basic) => { write!(f, "basic") } - EnforcableMitigationLevel::StackProtector(StackProtector::Strong) => { + DeniedPartialMitigationLevel::StackProtector(StackProtector::Strong) => { write!(f, "strong") } - EnforcableMitigationLevel::Enabled(true) => { + DeniedPartialMitigationLevel::Enabled(true) => { write!(f, "enabled") } - EnforcableMitigationLevel::StackProtector(StackProtector::None) - | EnforcableMitigationLevel::Enabled(false) => { + DeniedPartialMitigationLevel::StackProtector(StackProtector::None) + | DeniedPartialMitigationLevel::Enabled(false) => { write!(f, "disabled") } } } } -impl From for EnforcableMitigationLevel { +impl From for DeniedPartialMitigationLevel { fn from(value: bool) -> Self { - EnforcableMitigationLevel::Enabled(value) + DeniedPartialMitigationLevel::Enabled(value) } } -impl From for EnforcableMitigationLevel { +impl From for DeniedPartialMitigationLevel { fn from(value: StackProtector) -> Self { - EnforcableMitigationLevel::StackProtector(value) + DeniedPartialMitigationLevel::StackProtector(value) } } -pub struct EnforcableMitigationKindParseError; +pub struct DeniedPartialMitigationKindParseError; #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Encodable, BlobDecodable)] pub struct MitigationEnablement { - pub kind: EnforcableMitigationKind, + pub kind: DeniedPartialMitigationKind, 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 EnforcableMitigationKind { + pub enum DeniedPartialMitigationKind { $($name),* } - impl std::fmt::Display for EnforcableMitigationKind { + impl std::fmt::Display for DeniedPartialMitigationKind { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { - $(EnforcableMitigationKind::$name => write!(f, $text)),* + $(DeniedPartialMitigationKind::$name => write!(f, $text)),* } } } - impl EnforcableMitigationKind { + impl DeniedPartialMitigationKind { pub(crate) const KINDS: &'static str = concat!("comma-separated list of mitigation kinds (available: ", intersperse!(", ", ($(concat!("`", $text, "`")),*)), ")"); } - impl FromStr for EnforcableMitigationKind { - type Err = EnforcableMitigationKindParseError; + impl FromStr for DeniedPartialMitigationKind { + type Err = DeniedPartialMitigationKindParseError; - fn from_str(v: &str) -> Result { + fn from_str(v: &str) -> Result { match v { - $($text => Ok(EnforcableMitigationKind::$name)),* + $($text => Ok(DeniedPartialMitigationKind::$name)),* , - _ => Err(EnforcableMitigationKindParseError), + _ => Err(DeniedPartialMitigationKindParseError), } } } #[allow(unused)] - impl EnforcableMitigationKind { + impl DeniedPartialMitigationKind { 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. - $(EnforcableMitigationKind::$name => Edition::$since),* + $(DeniedPartialMitigationKind::$name => Edition::$since),* } } } impl Options { - pub fn all_enforced_mitigations(&self) -> impl Iterator { - [$(EnforcableMitigationKind::$name),*].into_iter() + pub fn all_enforced_mitigations(&self) -> impl Iterator { + [$(DeniedPartialMitigationKind::$name),*].into_iter() } } impl Session { - pub fn gather_enabled_enforcable_mitigations(&$self) -> Vec { + pub fn gather_enabled_denied_partial_mitigations(&$self) -> Vec { let mut mitigations = [ $( - EnforcableMitigation { - kind: EnforcableMitigationKind::$name, + DeniedPartialMitigation { + kind: DeniedPartialMitigationKind::$name, level: From::from($code), } ),* @@ -147,7 +147,7 @@ macro_rules! enforced_mitigations { enforced_mitigations! { [self] - enum EnforcableMitigationKind { + enum DeniedPartialMitigationKind { (StackProtector, "stack-protector", EditionFuture, self.stack_protector()), (ControlFlowGuard, "control-flow-guard", EditionFuture, self.opts.cg.control_flow_guard == CFGuard::Checks) } @@ -155,9 +155,9 @@ enforced_mitigations! { /// 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 EnforcableMitigation { - pub kind: EnforcableMitigationKind, - pub level: EnforcableMitigationLevel, +pub struct DeniedPartialMitigation { + pub kind: DeniedPartialMitigationKind, + pub level: DeniedPartialMitigationLevel, } 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) From cc2d560ebf8273f9f193e95935e45d590ea0fcb2 Mon Sep 17 00:00:00 2001 From: Ariel Ben-Yehuda Date: Wed, 10 Dec 2025 18:46:39 +0000 Subject: [PATCH 06/11] use -Z deny-partial-mitigations instead of -Z allow-partial-mitigations=! --- compiler/rustc_session/src/options.rs | 26 +++++- ...low-partial-mitigations-current-edition.rs | 2 +- .../err-allow-partial-mitigations.both.stderr | 20 ++-- ...r-allow-partial-mitigations.disable.stderr | 10 +- ...-partial-mitigations.enable-disable.stderr | 10 +- ....enable-separately-disable-together.stderr | 92 +++++++++++++++++++ .../err-allow-partial-mitigations.rs | 17 +++- .../err-allow-partial-mitigations.sp.stderr | 10 +- ...ow-partial-mitigations.wrong-enable.stderr | 10 +- .../ok-allow-partial-mitigations-minicore.rs | 2 +- .../ok-allow-partial-mitigations.rs | 2 +- 11 files changed, 162 insertions(+), 39 deletions(-) create mode 100644 tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.enable-separately-disable-together.stderr diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs index c84c9318fcf2a..ac1e400ce88e5 100644 --- a/compiler/rustc_session/src/options.rs +++ b/compiler/rustc_session/src/options.rs @@ -694,6 +694,9 @@ impl CodegenOptions { // Sometimes different options need to build a common structure. // That structure can be kept in one of the options' fields, the others become dummy. macro_rules! redirect_field { + ($cg:ident.deny_partial_mitigations) => { + $cg.allow_partial_mitigations + }; ($cg:ident.link_arg) => { $cg.link_args }; @@ -894,6 +897,8 @@ mod desc { pub(crate) const parse_assert_incr_state: &str = "one of: `loaded`, `not-loaded`"; pub(crate) const parse_allow_partial_mitigations: &str = super::enforcable_mitigations::DeniedPartialMitigationKind::KINDS; + pub(crate) const parse_deny_partial_mitigations: &str = + super::enforcable_mitigations::DeniedPartialMitigationKind::KINDS; } pub mod parse { @@ -2080,15 +2085,14 @@ pub mod parse { true } - pub(crate) fn parse_allow_partial_mitigations( + fn parse_partial_mitigations( slot: &mut Vec, v: Option<&str>, + enabled: bool, ) -> bool { match v { Some(s) => { for sub in s.split(',') { - let (sub, enabled) = - if sub.starts_with('!') { (&sub[1..], false) } else { (sub, true) }; match sub.parse() { Ok(kind) => slot.push(MitigationEnablement { kind, enabled }), Err(_) => return false, @@ -2099,6 +2103,20 @@ pub mod parse { None => false, } } + + pub(crate) fn parse_allow_partial_mitigations( + slot: &mut Vec, + v: Option<&str>, + ) -> bool { + parse_partial_mitigations(slot, v, true) + } + + pub(crate) fn parse_deny_partial_mitigations( + slot: &mut Vec, + v: Option<&str>, + ) -> bool { + parse_partial_mitigations(slot, v, false) + } } options! { @@ -2332,6 +2350,8 @@ options! { "deduplicate identical diagnostics (default: yes)"), default_visibility: Option = (None, parse_opt_symbol_visibility, [TRACKED], "overrides the `default_visibility` setting of the target"), + deny_partial_mitigations: Vec = (Vec::new(), parse_deny_partial_mitigations, [UNTRACKED], + "Deny mitigations not enabled for all dependency crates (comma separated list)"), dep_info_omit_d_target: bool = (false, parse_bool, [TRACKED], "in dep-info output, omit targets for tracking dependencies of the dep-info files \ themselves (default: no)"), diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.rs b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.rs index 1299e5e003cac..d32c579a8cae1 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.rs +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.rs @@ -3,7 +3,7 @@ //@ ignore-nvptx64 stack protector is not supported //@ ignore-wasm32-unknown-unknown stack protector is not supported //@ edition: 2024 -//@ compile-flags: -Z allow-partial-mitigations=!control-flow-guard -C control-flow-guard=on +//@ compile-flags: -Z deny-partial-mitigations=control-flow-guard -C control-flow-guard=on // check that in edition 2024, it is still possible to explicitly // disallow partial mitigations (in edition=future, they are diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.both.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.both.stderr index 35801653495ef..50febbee060f2 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.both.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.both.stderr @@ -1,5 +1,5 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ @@ -8,7 +8,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `std`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ @@ -17,7 +17,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ @@ -26,7 +26,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ @@ -35,7 +35,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ @@ -44,7 +44,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ @@ -53,7 +53,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ @@ -62,7 +62,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ @@ -71,7 +71,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ @@ -80,7 +80,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `libc`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.disable.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.disable.stderr index f0e48e02347b3..b8ca779ed3b6d 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.disable.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.disable.stderr @@ -1,5 +1,5 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ @@ -8,7 +8,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ @@ -17,7 +17,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ @@ -26,7 +26,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ @@ -35,7 +35,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.enable-disable.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.enable-disable.stderr index f0e48e02347b3..b8ca779ed3b6d 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.enable-disable.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.enable-disable.stderr @@ -1,5 +1,5 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ @@ -8,7 +8,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ @@ -17,7 +17,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ @@ -26,7 +26,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ @@ -35,7 +35,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.enable-separately-disable-together.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.enable-separately-disable-together.stderr new file mode 100644 index 0000000000000..50febbee060f2 --- /dev/null +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.enable-separately-disable-together.stderr @@ -0,0 +1,92 @@ +error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:14:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `std`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations.rs:14:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `std` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` + +error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:14:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `core`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations.rs:14:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `core` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` + +error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:14:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `alloc`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations.rs:14:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `alloc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` + +error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:14:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `compiler_builtins`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations.rs:14:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `compiler_builtins` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` + +error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations.rs:14:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `libc`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations.rs:14:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `libc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` + +error: aborting due to 10 previous errors + diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.rs b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.rs index 0aa1c5933ea53..8ba8873053e05 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.rs +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.rs @@ -1,14 +1,15 @@ // ignore-tidy-linelength -//@ revisions: sp both disable enable-disable wrong-enable +//@ revisions: sp both disable enable-disable wrong-enable enable-separately-disable-together //@ check-fail //@ ignore-nvptx64 stack protector is not supported //@ ignore-wasm32-unknown-unknown stack protector is not supported //@ edition:future //@ [both] compile-flags: -Z unstable-options -C control-flow-guard=on -Z stack-protector=all //@ [sp] compile-flags: -Z unstable-options -Z stack-protector=all -//@ [disable] compile-flags: -Z unstable-options -Z allow-partial-mitigations=!stack-protector -Z stack-protector=all -//@ [enable-disable] compile-flags: -Z unstable-options -Z allow-partial-mitigations=stack-protector -Z allow-partial-mitigations=!stack-protector -Z stack-protector=all +//@ [disable] compile-flags: -Z unstable-options -Z deny-partial-mitigations=stack-protector -Z stack-protector=all +//@ [enable-disable] compile-flags: -Z unstable-options -Z allow-partial-mitigations=stack-protector -Z deny-partial-mitigations=stack-protector -Z stack-protector=all //@ [wrong-enable] compile-flags: -Z unstable-options -Z allow-partial-mitigations=control-flow-guard -Z stack-protector=all +//@ [enable-separately-disable-together] compile-flags: -Z unstable-options -Z allow-partial-mitigations=stack-protector -Z allow-partial-mitigations=control-flow-guard -Z deny-partial-mitigations=control-flow-guard,stack-protector -C control-flow-guard=on -Z stack-protector=all fn main() {} //[both]~^ ERROR that is not compiled with @@ -41,3 +42,13 @@ fn main() {} //[wrong-enable]~| ERROR that is not compiled with //[wrong-enable]~| ERROR that is not compiled with //[wrong-enable]~| ERROR that is not compiled with +//[enable-separately-disable-together]~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ERROR that is not compiled with +//[enable-separately-disable-together]~| ERROR that is not compiled with +//[enable-separately-disable-together]~| ERROR that is not compiled with +//[enable-separately-disable-together]~| ERROR that is not compiled with +//[enable-separately-disable-together]~| ERROR that is not compiled with +//[enable-separately-disable-together]~| ERROR that is not compiled with +//[enable-separately-disable-together]~| ERROR that is not compiled with +//[enable-separately-disable-together]~| ERROR that is not compiled with +//[enable-separately-disable-together]~| ERROR that is not compiled with +//[enable-separately-disable-together]~| ERROR that is not compiled with diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.sp.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.sp.stderr index f0e48e02347b3..b8ca779ed3b6d 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.sp.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.sp.stderr @@ -1,5 +1,5 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ @@ -8,7 +8,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ @@ -17,7 +17,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ @@ -26,7 +26,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ @@ -35,7 +35,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.wrong-enable.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.wrong-enable.stderr index f0e48e02347b3..b8ca779ed3b6d 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.wrong-enable.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.wrong-enable.stderr @@ -1,5 +1,5 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ @@ -8,7 +8,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ @@ -17,7 +17,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ @@ -26,7 +26,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ @@ -35,7 +35,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:13:1 + --> $DIR/err-allow-partial-mitigations.rs:14:1 | LL | fn main() {} | ^ diff --git a/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations-minicore.rs b/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations-minicore.rs index 16eecd455dbe0..bc8aaa3cb2e61 100644 --- a/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations-minicore.rs +++ b/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations-minicore.rs @@ -4,7 +4,7 @@ //@ edition:future //@ revisions: default deny //@[default] compile-flags: -Z unstable-options -Z stack-protector=all -//@[deny] compile-flags: -Z allow-partial-mitigations=!stack-protector -Z unstable-options -Z stack-protector=all +//@[deny] compile-flags: -Z deny-partial-mitigations=stack-protector -Z unstable-options -Z stack-protector=all // ^ enables stack-protector for both minicore and this crate diff --git a/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations.rs b/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations.rs index c0ec555305841..c0bc09276568f 100644 --- a/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations.rs +++ b/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations.rs @@ -6,6 +6,6 @@ //@ ignore-wasm32-unknown-unknown stack protector is not supported //@ [both] compile-flags: -Z unstable-options -Z allow-partial-mitigations=stack-protector,control-flow-guard -C control-flow-guard=on -Z stack-protector=all //@ [sp] compile-flags: -Z unstable-options -Z allow-partial-mitigations=stack-protector -Z stack-protector=all -//@ [disable-enable] compile-flags: -Z unstable-options -Z allow-partial-mitigations=!stack-protector -Z allow-partial-mitigations=stack-protector -Z stack-protector=all +//@ [disable-enable] compile-flags: -Z unstable-options -Z deny-partial-mitigations=stack-protector -Z allow-partial-mitigations=stack-protector -Z stack-protector=all fn main() {} From c55bfc66a6bf47c06309bc971656c7d57c377a77 Mon Sep 17 00:00:00 2001 From: Ariel Ben-Yehuda Date: Wed, 10 Dec 2025 20:24:03 +0000 Subject: [PATCH 07/11] enforcable -> enforceable --- compiler/rustc_metadata/src/creader.rs | 2 +- compiler/rustc_metadata/src/rmeta/decoder.rs | 4 ++-- compiler/rustc_metadata/src/rmeta/encoder.rs | 2 +- compiler/rustc_metadata/src/rmeta/mod.rs | 2 +- compiler/rustc_metadata/src/rmeta/parameterized.rs | 2 +- compiler/rustc_session/src/options.rs | 10 +++++----- ...cable_mitigations.rs => enforceable_mitigations.rs} | 0 7 files changed, 11 insertions(+), 11 deletions(-) rename compiler/rustc_session/src/options/{enforcable_mitigations.rs => enforceable_mitigations.rs} (100%) diff --git a/compiler/rustc_metadata/src/creader.rs b/compiler/rustc_metadata/src/creader.rs index cee7a41a1182c..e155e7b0580df 100644 --- a/compiler/rustc_metadata/src/creader.rs +++ b/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::enforcable_mitigations::DeniedPartialMitigationLevel; +use rustc_session::config::enforceable_mitigations::DeniedPartialMitigationLevel; use rustc_session::config::{ CrateType, ExtendedTargetModifierInfo, ExternLocation, Externs, OptionsTargetModifiers, TargetModifier, diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs index 00ca24c6b7501..06d764f772b23 100644 --- a/compiler/rustc_metadata/src/rmeta/decoder.rs +++ b/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::enforcable_mitigations::DeniedPartialMitigation; +use rustc_session::config::enforceable_mitigations::DeniedPartialMitigation; use rustc_session::cstore::{CrateSource, ExternCrate}; use rustc_span::hygiene::HygieneDecodeContext; use rustc_span::{ @@ -82,7 +82,7 @@ pub(crate) type CrateNumMap = IndexVec; /// Target modifiers - abi or exploit mitigations flags that cause unsoundness when mixed pub(crate) type TargetModifiers = Vec; -/// The set of enforcable mitigations (RFC 3855) that are currently enabled for this crate +/// The set of enforceable mitigations (RFC 3855) that are currently enabled for this crate pub(crate) type DeniedPartialMitigations = Vec; pub(crate) struct CrateMetadata { diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs index ef5416ac427d5..933ba5b67cc11 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::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::enforcable_mitigations::DeniedPartialMitigation; +use rustc_session::config::enforceable_mitigations::DeniedPartialMitigation; use rustc_session::config::{CrateType, OptLevel, TargetModifier}; use rustc_span::hygiene::HygieneEncodeContext; use rustc_span::{ diff --git a/compiler/rustc_metadata/src/rmeta/mod.rs b/compiler/rustc_metadata/src/rmeta/mod.rs index bcc0aa1f3be8c..c9bb988ba82d0 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::fast_reject::SimplifiedType; use rustc_middle::ty::{self, Ty, TyCtxt}; use rustc_middle::util::Providers; use rustc_serialize::opaque::FileEncoder; -use rustc_session::config::enforcable_mitigations::DeniedPartialMitigation; +use rustc_session::config::enforceable_mitigations::DeniedPartialMitigation; use rustc_session::config::{SymbolManglingVersion, TargetModifier}; use rustc_session::cstore::{CrateDepKind, ForeignModule, LinkagePreference, NativeLib}; use rustc_span::edition::Edition; diff --git a/compiler/rustc_metadata/src/rmeta/parameterized.rs b/compiler/rustc_metadata/src/rmeta/parameterized.rs index 35ea06b384536..39686aeb22ffd 100644 --- a/compiler/rustc_metadata/src/rmeta/parameterized.rs +++ b/compiler/rustc_metadata/src/rmeta/parameterized.rs @@ -120,7 +120,7 @@ trivially_parameterized_over_tcx! { rustc_middle::ty::adjustment::CoerceUnsizedInfo, rustc_middle::ty::fast_reject::SimplifiedType, rustc_session::config::TargetModifier, - rustc_session::config::enforcable_mitigations::DeniedPartialMitigation, + rustc_session::config::enforceable_mitigations::DeniedPartialMitigation, 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 ac1e400ce88e5..967ff79396eba 100644 --- a/compiler/rustc_session/src/options.rs +++ b/compiler/rustc_session/src/options.rs @@ -20,7 +20,7 @@ use rustc_target::spec::{ TargetTuple, TlsModel, }; -use crate::config::enforcable_mitigations::MitigationEnablement; +use crate::config::enforceable_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 enforcable_mitigations; +pub mod enforceable_mitigations; mod target_modifier_consistency_check { use super::*; @@ -896,16 +896,16 @@ mod desc { pub(crate) const parse_align: &str = "a number that is a power of 2 between 1 and 2^29"; pub(crate) const parse_assert_incr_state: &str = "one of: `loaded`, `not-loaded`"; pub(crate) const parse_allow_partial_mitigations: &str = - super::enforcable_mitigations::DeniedPartialMitigationKind::KINDS; + super::enforceable_mitigations::DeniedPartialMitigationKind::KINDS; pub(crate) const parse_deny_partial_mitigations: &str = - super::enforcable_mitigations::DeniedPartialMitigationKind::KINDS; + super::enforceable_mitigations::DeniedPartialMitigationKind::KINDS; } pub mod parse { use std::str::FromStr; pub(crate) use super::*; - use crate::config::enforcable_mitigations::MitigationEnablement; + use crate::config::enforceable_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/enforcable_mitigations.rs b/compiler/rustc_session/src/options/enforceable_mitigations.rs similarity index 100% rename from compiler/rustc_session/src/options/enforcable_mitigations.rs rename to compiler/rustc_session/src/options/enforceable_mitigations.rs From b4bfd7fa43217be6fe8ec215928dc7a91782a4f3 Mon Sep 17 00:00:00 2001 From: Ariel Ben-Yehuda Date: Tue, 16 Dec 2025 23:55:35 +0000 Subject: [PATCH 08/11] address review comments --- compiler/rustc_metadata/src/creader.rs | 7 +++--- compiler/rustc_metadata/src/rmeta/decoder.rs | 2 +- compiler/rustc_metadata/src/rmeta/encoder.rs | 2 +- compiler/rustc_metadata/src/rmeta/mod.rs | 2 +- .../rustc_metadata/src/rmeta/parameterized.rs | 2 +- compiler/rustc_session/src/options.rs | 22 +++++++++---------- ..._mitigations.rs => mitigation_coverage.rs} | 12 +++++----- 7 files changed, 24 insertions(+), 25 deletions(-) rename compiler/rustc_session/src/options/{enforceable_mitigations.rs => mitigation_coverage.rs} (94%) diff --git a/compiler/rustc_metadata/src/creader.rs b/compiler/rustc_metadata/src/creader.rs index e155e7b0580df..7be7e3517fe8f 100644 --- a/compiler/rustc_metadata/src/creader.rs +++ b/compiler/rustc_metadata/src/creader.rs @@ -24,8 +24,7 @@ use rustc_middle::bug; 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::enforceable_mitigations::DeniedPartialMitigationLevel; +use rustc_session::config::mitigation_coverage::DeniedPartialMitigationLevel; use rustc_session::config::{ CrateType, ExtendedTargetModifierInfo, ExternLocation, Externs, OptionsTargetModifiers, TargetModifier, @@ -468,7 +467,7 @@ impl CStore { pub fn report_session_incompatibilities(&self, tcx: TyCtxt<'_>, krate: &Crate) { self.report_incompatible_target_modifiers(tcx, krate); - self.report_incompatible_denied_partial_mitigations(tcx, krate); + self.report_incompatible_partial_mitigations(tcx, krate); self.report_incompatible_async_drop_feature(tcx, krate); } @@ -493,7 +492,7 @@ impl CStore { } } - pub fn report_incompatible_denied_partial_mitigations(&self, tcx: TyCtxt<'_>, krate: &Crate) { + pub fn report_incompatible_partial_mitigations(&self, tcx: TyCtxt<'_>, krate: &Crate) { let my_mitigations = tcx.sess.gather_enabled_denied_partial_mitigations(); let mut my_mitigations: BTreeMap<_, _> = my_mitigations.iter().map(|mitigation| (mitigation.kind, mitigation)).collect(); diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs index 06d764f772b23..2993eb340cfe4 100644 --- a/compiler/rustc_metadata/src/rmeta/decoder.rs +++ b/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::enforceable_mitigations::DeniedPartialMitigation; +use rustc_session::config::mitigation_coverage::DeniedPartialMitigation; use rustc_session::cstore::{CrateSource, ExternCrate}; use rustc_span::hygiene::HygieneDecodeContext; use rustc_span::{ diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs index 933ba5b67cc11..2a0eeef442a33 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::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::enforceable_mitigations::DeniedPartialMitigation; +use rustc_session::config::mitigation_coverage::DeniedPartialMitigation; use rustc_session::config::{CrateType, OptLevel, TargetModifier}; use rustc_span::hygiene::HygieneEncodeContext; use rustc_span::{ diff --git a/compiler/rustc_metadata/src/rmeta/mod.rs b/compiler/rustc_metadata/src/rmeta/mod.rs index c9bb988ba82d0..781d3c6d18372 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::fast_reject::SimplifiedType; use rustc_middle::ty::{self, Ty, TyCtxt}; use rustc_middle::util::Providers; use rustc_serialize::opaque::FileEncoder; -use rustc_session::config::enforceable_mitigations::DeniedPartialMitigation; +use rustc_session::config::mitigation_coverage::DeniedPartialMitigation; use rustc_session::config::{SymbolManglingVersion, TargetModifier}; use rustc_session::cstore::{CrateDepKind, ForeignModule, LinkagePreference, NativeLib}; use rustc_span::edition::Edition; diff --git a/compiler/rustc_metadata/src/rmeta/parameterized.rs b/compiler/rustc_metadata/src/rmeta/parameterized.rs index 39686aeb22ffd..1531584e99788 100644 --- a/compiler/rustc_metadata/src/rmeta/parameterized.rs +++ b/compiler/rustc_metadata/src/rmeta/parameterized.rs @@ -120,7 +120,7 @@ trivially_parameterized_over_tcx! { rustc_middle::ty::adjustment::CoerceUnsizedInfo, rustc_middle::ty::fast_reject::SimplifiedType, rustc_session::config::TargetModifier, - rustc_session::config::enforceable_mitigations::DeniedPartialMitigation, + rustc_session::config::mitigation_coverage::DeniedPartialMitigation, 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 967ff79396eba..cdc9be1567ecd 100644 --- a/compiler/rustc_session/src/options.rs +++ b/compiler/rustc_session/src/options.rs @@ -20,7 +20,7 @@ use rustc_target::spec::{ TargetTuple, TlsModel, }; -use crate::config::enforceable_mitigations::MitigationEnablement; +use crate::config::mitigation_coverage::MitigationCoverage; 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 enforceable_mitigations; +pub mod mitigation_coverage; mod target_modifier_consistency_check { use super::*; @@ -896,16 +896,16 @@ mod desc { pub(crate) const parse_align: &str = "a number that is a power of 2 between 1 and 2^29"; pub(crate) const parse_assert_incr_state: &str = "one of: `loaded`, `not-loaded`"; pub(crate) const parse_allow_partial_mitigations: &str = - super::enforceable_mitigations::DeniedPartialMitigationKind::KINDS; + super::mitigation_coverage::DeniedPartialMitigationKind::KINDS; pub(crate) const parse_deny_partial_mitigations: &str = - super::enforceable_mitigations::DeniedPartialMitigationKind::KINDS; + super::mitigation_coverage::DeniedPartialMitigationKind::KINDS; } pub mod parse { use std::str::FromStr; pub(crate) use super::*; - use crate::config::enforceable_mitigations::MitigationEnablement; + use crate::config::mitigation_coverage::MitigationCoverage; pub(crate) const MAX_THREADS_CAP: usize = 256; /// Ignore the value. Used for removed options where we don't actually want to store @@ -2086,7 +2086,7 @@ pub mod parse { } fn parse_partial_mitigations( - slot: &mut Vec, + slot: &mut Vec, v: Option<&str>, enabled: bool, ) -> bool { @@ -2094,7 +2094,7 @@ pub mod parse { Some(s) => { for sub in s.split(',') { match sub.parse() { - Ok(kind) => slot.push(MitigationEnablement { kind, enabled }), + Ok(kind) => slot.push(MitigationCoverage { kind, enabled }), Err(_) => return false, } } @@ -2105,14 +2105,14 @@ pub mod parse { } pub(crate) fn parse_allow_partial_mitigations( - slot: &mut Vec, + slot: &mut Vec, v: Option<&str>, ) -> bool { parse_partial_mitigations(slot, v, true) } pub(crate) fn parse_deny_partial_mitigations( - slot: &mut Vec, + slot: &mut Vec, v: Option<&str>, ) -> bool { parse_partial_mitigations(slot, v, false) @@ -2281,7 +2281,7 @@ options! { // tidy-alphabetical-start allow_features: Option> = (None, parse_opt_comma_list, [TRACKED], "only allow the listed language features to be enabled in code (comma separated)"), - allow_partial_mitigations: Vec = (Vec::new(), parse_allow_partial_mitigations, [UNTRACKED], + allow_partial_mitigations: Vec = (Vec::new(), parse_allow_partial_mitigations, [UNTRACKED], "Allow mitigations not enabled for all dependency crates (comma separated list)"), always_encode_mir: bool = (false, parse_bool, [TRACKED], "encode MIR of all functions into the crate metadata (default: no)"), @@ -2350,7 +2350,7 @@ options! { "deduplicate identical diagnostics (default: yes)"), default_visibility: Option = (None, parse_opt_symbol_visibility, [TRACKED], "overrides the `default_visibility` setting of the target"), - deny_partial_mitigations: Vec = (Vec::new(), parse_deny_partial_mitigations, [UNTRACKED], + deny_partial_mitigations: Vec = (Vec::new(), parse_deny_partial_mitigations, [UNTRACKED], "Deny mitigations not enabled for all dependency crates (comma separated list)"), dep_info_omit_d_target: bool = (false, parse_bool, [TRACKED], "in dep-info output, omit targets for tracking dependencies of the dep-info files \ diff --git a/compiler/rustc_session/src/options/enforceable_mitigations.rs b/compiler/rustc_session/src/options/mitigation_coverage.rs similarity index 94% rename from compiler/rustc_session/src/options/enforceable_mitigations.rs rename to compiler/rustc_session/src/options/mitigation_coverage.rs index 851659f416e85..d851fac1ea1e8 100644 --- a/compiler/rustc_session/src/options/enforceable_mitigations.rs +++ b/compiler/rustc_session/src/options/mitigation_coverage.rs @@ -68,7 +68,7 @@ impl From for DeniedPartialMitigationLevel { pub struct DeniedPartialMitigationKindParseError; #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Encodable, BlobDecodable)] -pub struct MitigationEnablement { +pub struct MitigationCoverage { pub kind: DeniedPartialMitigationKind, pub enabled: bool, } @@ -79,7 +79,7 @@ macro_rules! intersperse { }; } -macro_rules! enforced_mitigations { +macro_rules! denied_partial_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 DeniedPartialMitigationKind { @@ -123,7 +123,7 @@ macro_rules! enforced_mitigations { } impl Options { - pub fn all_enforced_mitigations(&self) -> impl Iterator { + pub fn all_denied_partial_mitigations(&self) -> impl Iterator { [$(DeniedPartialMitigationKind::$name),*].into_iter() } } @@ -145,7 +145,7 @@ macro_rules! enforced_mitigations { } } -enforced_mitigations! { +denied_partial_mitigations! { [self] enum DeniedPartialMitigationKind { (StackProtector, "stack-protector", EditionFuture, self.stack_protector()), @@ -153,7 +153,7 @@ enforced_mitigations! { } } -/// Enforced mitigations, see [RFC 3855](https://github.com/rust-lang/rfcs/pull/3855) +/// Denied-partial mitigations, see [RFC 3855](https://github.com/rust-lang/rfcs/pull/3855) #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Encodable, BlobDecodable)] pub struct DeniedPartialMitigation { pub kind: DeniedPartialMitigationKind, @@ -167,7 +167,7 @@ impl Options { edition: Edition, ) -> impl Iterator { let mut result: BTreeSet<_> = self - .all_enforced_mitigations() + .all_denied_partial_mitigations() .filter(|mitigation| mitigation.enforced_since() > edition) .collect(); for mitigation in &self.unstable_opts.allow_partial_mitigations { From a0ff19d8ec8be0b8c15416c7038c4d589c5adc34 Mon Sep 17 00:00:00 2001 From: Ariel Ben-Yehuda Date: Fri, 20 Feb 2026 01:38:38 +0200 Subject: [PATCH 09/11] reset mitigation status on a mitigation option as per the RFC --- compiler/rustc_session/src/config.rs | 12 +- compiler/rustc_session/src/options.rs | 147 ++++++++++-------- .../src/options/mitigation_coverage.rs | 94 +++++++++-- src/librustdoc/config.rs | 8 +- ...mitigations-1-error.cfg-allow-first.stderr | 47 ++++++ ...tions-1-error.disable-enable-reset.stderr} | 10 +- ...artial-mitigations-1-error.disable.stderr} | 10 +- ...mitigations-1-error.enable-disable.stderr} | 10 +- .../err-allow-partial-mitigations-1-error.rs | 20 +++ ...mitigations-1-error.sp-allow-first.stderr} | 10 +- ...llow-partial-mitigations-1-error.sp.stderr | 47 ++++++ ...al-mitigations-1-error.wrong-enable.stderr | 47 ++++++ ...-partial-mitigations-2-errors.both.stderr} | 20 +-- ...enable-separately-disable-together.stderr} | 20 +-- .../err-allow-partial-mitigations-2-errors.rs | 20 +++ .../err-allow-partial-mitigations-bad-cli.rs | 12 ++ ...r-allow-partial-mitigations-bad-cli.stderr | 2 + ...low-partial-mitigations-current-edition.rs | 2 +- .../err-allow-partial-mitigations.rs | 54 ------- ...low-partial-mitigations-current-edition.rs | 13 ++ .../ok-allow-partial-mitigations.rs | 6 +- 21 files changed, 423 insertions(+), 188 deletions(-) create mode 100644 tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.cfg-allow-first.stderr rename tests/ui/allow-partial-mitigations/{err-allow-partial-mitigations.sp.stderr => err-allow-partial-mitigations-1-error.disable-enable-reset.stderr} (89%) rename tests/ui/allow-partial-mitigations/{err-allow-partial-mitigations.disable.stderr => err-allow-partial-mitigations-1-error.disable.stderr} (89%) rename tests/ui/allow-partial-mitigations/{err-allow-partial-mitigations.enable-disable.stderr => err-allow-partial-mitigations-1-error.enable-disable.stderr} (89%) create mode 100644 tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.rs rename tests/ui/allow-partial-mitigations/{err-allow-partial-mitigations.wrong-enable.stderr => err-allow-partial-mitigations-1-error.sp-allow-first.stderr} (89%) create mode 100644 tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.sp.stderr create mode 100644 tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.wrong-enable.stderr rename tests/ui/allow-partial-mitigations/{err-allow-partial-mitigations.both.stderr => err-allow-partial-mitigations-2-errors.both.stderr} (89%) rename tests/ui/allow-partial-mitigations/{err-allow-partial-mitigations.enable-separately-disable-together.stderr => err-allow-partial-mitigations-2-errors.enable-separately-disable-together.stderr} (89%) create mode 100644 tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.rs create mode 100644 tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-bad-cli.rs create mode 100644 tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-bad-cli.stderr delete mode 100644 tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.rs create mode 100644 tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations-current-edition.rs diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs index e4ef1d40d72d5..7f0391384d3a5 100644 --- a/compiler/rustc_session/src/config.rs +++ b/compiler/rustc_session/src/config.rs @@ -1449,6 +1449,7 @@ impl Default for Options { logical_env: FxIndexMap::default(), verbose: false, target_modifiers: BTreeMap::default(), + mitigation_coverage_map: Default::default(), } } } @@ -2456,9 +2457,9 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M let crate_types = parse_crate_types_from_list(unparsed_crate_types) .unwrap_or_else(|e| early_dcx.early_fatal(e)); - let mut target_modifiers = BTreeMap::::new(); + let mut collected_options = Default::default(); - let mut unstable_opts = UnstableOptions::build(early_dcx, matches, &mut target_modifiers); + let mut unstable_opts = UnstableOptions::build(early_dcx, matches, &mut collected_options); let (lint_opts, describe_lints, lint_cap) = get_cmd_lint_options(early_dcx, matches); if !unstable_opts.unstable_options && json_timings { @@ -2474,7 +2475,7 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M let output_types = parse_output_types(early_dcx, &unstable_opts, matches); - let mut cg = CodegenOptions::build(early_dcx, matches, &mut target_modifiers); + let mut cg = CodegenOptions::build(early_dcx, matches, &mut collected_options); let (disable_local_thinlto, codegen_units) = should_override_cgus_and_disable_thinlto( early_dcx, &output_types, @@ -2625,7 +2626,7 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M // -Zretpoline-external-thunk also requires -Zretpoline if unstable_opts.retpoline_external_thunk { unstable_opts.retpoline = true; - target_modifiers.insert( + collected_options.target_modifiers.insert( OptionsTargetModifiers::UnstableOptions(UnstableOptionsTargetModifiers::retpoline), "true".to_string(), ); @@ -2785,7 +2786,8 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M color, logical_env, verbose, - target_modifiers, + target_modifiers: collected_options.target_modifiers, + mitigation_coverage_map: collected_options.mitigations, } } diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs index cdc9be1567ecd..9fc6036b98b34 100644 --- a/compiler/rustc_session/src/options.rs +++ b/compiler/rustc_session/src/options.rs @@ -20,7 +20,6 @@ use rustc_target::spec::{ TargetTuple, TlsModel, }; -use crate::config::mitigation_coverage::MitigationCoverage; use crate::config::*; use crate::search_paths::SearchPath; use crate::utils::NativeLib; @@ -201,15 +200,15 @@ macro_rules! gather_tmods { tmod_push!($struct_name, $tmod_enum_name, $opt_name, $opt_expr, $init, $mods, $tmod_vals) }; ($struct_name:ident, $tmod_enum_name:ident, $opt_name:ident, $opt_expr:expr, $init:expr, $mods:expr, $tmod_vals:expr, - [SUBSTRUCT], []) => { + [SUBSTRUCT], [$(MITIGATION)?]) => { $opt_expr.gather_target_modifiers($mods, $tmod_vals); }; ($struct_name:ident, $tmod_enum_name:ident, $opt_name:ident, $opt_expr:expr, $init:expr, $mods:expr, $tmod_vals:expr, - [UNTRACKED], []) => {{}}; + [UNTRACKED], [$(MITIGATION)?]) => {{}}; ($struct_name:ident, $tmod_enum_name:ident, $opt_name:ident, $opt_expr:expr, $init:expr, $mods:expr, $tmod_vals:expr, - [TRACKED], []) => {{}}; + [TRACKED], [$(MITIGATION)?]) => {{}}; ($struct_name:ident, $tmod_enum_name:ident, $opt_name:ident, $opt_expr:expr, $init:expr, $mods:expr, $tmod_vals:expr, - [TRACKED_NO_CRATE_HASH], []) => {{}}; + [TRACKED_NO_CRATE_HASH], [$(MITIGATION)?]) => {{}}; } macro_rules! gather_tmods_top_level { @@ -219,7 +218,7 @@ macro_rules! gather_tmods_top_level { ($opt_name:ident, $opt_expr:expr, $mods:expr, $tmod_vals:expr, [$non_substruct:ident TARGET_MODIFIER]) => { compile_error!("Top level option can't be target modifier"); }; - ($opt_name:ident, $opt_expr:expr, $mods:expr, $tmod_vals:expr, [$non_substruct:ident]) => {}; + ($opt_name:ident, $opt_expr:expr, $mods:expr, $tmod_vals:expr, [$non_substruct:ident $(MITIGATION)?]) => {}; } /// Macro for generating OptionsTargetsModifiers top-level enum with impl. @@ -324,6 +323,7 @@ macro_rules! top_level_options { pub $opt: $t ),*, pub target_modifiers: BTreeMap, + pub mitigation_coverage_map: mitigation_coverage::MitigationCoverageMap, } impl Options { @@ -506,11 +506,20 @@ top_level_options!( } ); +macro_rules! mitigation_enum_opt { + ($opt:ident, MITIGATION) => { + Some(mitigation_coverage::DeniedPartialMitigationKind::$opt) + }; + ($opt:ident, $(TARGET_MODIFIER)?) => { + None + }; +} + macro_rules! tmod_enum_opt { - ($struct_name:ident, $tmod_enum_name:ident, $opt:ident, $v:ident) => { + ($struct_name:ident, $tmod_enum_name:ident, $opt:ident, TARGET_MODIFIER) => { Some(OptionsTargetModifiers::$struct_name($tmod_enum_name::$opt)) }; - ($struct_name:ident, $tmod_enum_name:ident, $opt:ident, ) => { + ($struct_name:ident, $tmod_enum_name:ident, $opt:ident, $(MITIGATION)?) => { None }; } @@ -582,7 +591,7 @@ macro_rules! tmod_enum { ( $tmod_enum_name:ident, $prefix:expr, @parse {$($eout:tt)*}, ($puser_value:ident){$($pout:tt)*}; - $opt:ident, $parse:ident, $t:ty, [] | + $opt:ident, $parse:ident, $t:ty, [$(MITIGATION)?] | $($tail:tt)* ) => { tmod_enum! { @@ -599,6 +608,47 @@ macro_rules! tmod_enum { }; } +#[derive(Default)] +pub struct CollectedOptions { + pub target_modifiers: BTreeMap, + pub mitigations: mitigation_coverage::MitigationCoverageMap, +} + +macro_rules! setter_for { + // the allow/deny-mitigations options use collected/index instead of the cg, since they + // work across option groups + (allow_partial_mitigations, $struct_name:ident, $parse:ident) => { + pub(super) fn allow_partial_mitigations( + _cg: &mut super::$struct_name, + collected: &mut super::CollectedOptions, + v: Option<&str>, + index: usize, + ) -> bool { + collected.mitigations.handle_allowdeny_mitigation_option(v, index, true) + } + }; + (deny_partial_mitigations, $struct_name:ident, $parse:ident) => { + pub(super) fn deny_partial_mitigations( + _cg: &mut super::$struct_name, + collected: &mut super::CollectedOptions, + v: Option<&str>, + index: usize, + ) -> bool { + collected.mitigations.handle_allowdeny_mitigation_option(v, index, false) + } + }; + ($opt:ident, $struct_name:ident, $parse:ident) => { + pub(super) fn $opt( + cg: &mut super::$struct_name, + _collected: &mut super::CollectedOptions, + v: Option<&str>, + _index: usize, + ) -> bool { + super::parse::$parse(&mut redirect_field!(cg.$opt), v) + } + }; +} + /// Defines all `CodegenOptions`/`DebuggingOptions` fields and parsers all at once. The goal of this /// macro is to define an interface that can be programmatically used by the option parser /// to initialize the struct without hardcoding field names all over the place. @@ -612,7 +662,7 @@ macro_rules! options { $($( #[$attr:meta] )* $opt:ident : $t:ty = ( $init:expr, $parse:ident, - [$dep_tracking_marker:ident $( $tmod:ident )?], + [$dep_tracking_marker:ident $( $modifier_kind:ident )?], $desc:expr $(, removed: $removed:ident )?) ),* ,) => @@ -621,7 +671,7 @@ macro_rules! options { #[rustc_lint_opt_ty] pub struct $struct_name { $( $( #[$attr] )* pub $opt: $t),* } - tmod_enum!( $tmod_enum_name, $prefix, {$($opt, $parse, $t, [$($tmod),*])|*} ); + tmod_enum!( $tmod_enum_name, $prefix, {$($opt, $parse, $t, [$($modifier_kind),*])|*} ); impl Default for $struct_name { fn default() -> $struct_name { @@ -633,7 +683,7 @@ macro_rules! options { pub fn build( early_dcx: &EarlyDiagCtxt, matches: &getopts::Matches, - target_modifiers: &mut BTreeMap, + target_modifiers: &mut CollectedOptions, ) -> $struct_name { build_options(early_dcx, matches, target_modifiers, $stat, $prefix, $outputname) } @@ -663,7 +713,7 @@ macro_rules! options { ) { $({ gather_tmods!($struct_name, $tmod_enum_name, $opt, &self.$opt, $init, _mods, _tmod_vals, - [$dep_tracking_marker], [$($tmod),*]); + [$dep_tracking_marker], [$($modifier_kind),*]); })* } } @@ -671,13 +721,13 @@ macro_rules! options { pub const $stat: OptionDescrs<$struct_name> = &[ $( OptionDesc{ name: stringify!($opt), setter: $optmod::$opt, type_desc: desc::$parse, desc: $desc, removed: None $( .or(Some(RemovedOption::$removed)) )?, - tmod: tmod_enum_opt!($struct_name, $tmod_enum_name, $opt, $($tmod),*) } ),* ]; + tmod: tmod_enum_opt!($struct_name, $tmod_enum_name, $opt, $($modifier_kind),*), + mitigation: mitigation_enum_opt!($opt, $($modifier_kind),*), + } ),* ]; mod $optmod { $( - pub(super) fn $opt(cg: &mut super::$struct_name, v: Option<&str>) -> bool { - super::parse::$parse(&mut redirect_field!(cg.$opt), v) - } + setter_for!($opt, $struct_name, $parse); )* } @@ -694,9 +744,6 @@ impl CodegenOptions { // Sometimes different options need to build a common structure. // That structure can be kept in one of the options' fields, the others become dummy. macro_rules! redirect_field { - ($cg:ident.deny_partial_mitigations) => { - $cg.allow_partial_mitigations - }; ($cg:ident.link_arg) => { $cg.link_args }; @@ -708,7 +755,7 @@ macro_rules! redirect_field { }; } -type OptionSetter = fn(&mut O, v: Option<&str>) -> bool; +type OptionSetter = fn(&mut O, &mut CollectedOptions, v: Option<&str>, pos: usize) -> bool; type OptionDescrs = &'static [OptionDesc]; /// Indicates whether a removed option should warn or error. @@ -726,6 +773,7 @@ pub struct OptionDesc { desc: &'static str, removed: Option, tmod: Option, + mitigation: Option, } impl OptionDesc { @@ -741,13 +789,13 @@ impl OptionDesc { fn build_options( early_dcx: &EarlyDiagCtxt, matches: &getopts::Matches, - target_modifiers: &mut BTreeMap, + collected_options: &mut CollectedOptions, descrs: OptionDescrs, prefix: &str, outputname: &str, ) -> O { let mut op = O::default(); - for option in matches.opt_strs(prefix) { + for (index, option) in matches.opt_strs_pos(prefix) { let (key, value) = match option.split_once('=') { None => (option, None), Some((k, v)) => (k.to_string(), Some(v)), @@ -755,7 +803,7 @@ fn build_options( let option_to_lookup = key.replace('-', "_"); match descrs.iter().find(|opt_desc| opt_desc.name == option_to_lookup) { - Some(OptionDesc { name: _, setter, type_desc, desc, removed, tmod }) => { + Some(OptionDesc { name: _, setter, type_desc, desc, removed, tmod, mitigation }) => { if let Some(removed) = removed { // deprecation works for prefixed options only assert!(!prefix.is_empty()); @@ -768,7 +816,7 @@ fn build_options( } } } - if !setter(&mut op, value) { + if !setter(&mut op, collected_options, value, index) { match value { None => early_dcx.early_fatal( format!( @@ -784,7 +832,10 @@ fn build_options( } if let Some(tmod) = *tmod { let v = value.map_or(String::new(), ToOwned::to_owned); - target_modifiers.insert(tmod, v); + collected_options.target_modifiers.insert(tmod, v); + } + if let Some(mitigation) = mitigation { + collected_options.mitigations.reset_mitigation(*mitigation, index); } } None => early_dcx.early_fatal(format!("unknown {outputname} option: `{key}`")), @@ -905,7 +956,6 @@ pub mod parse { use std::str::FromStr; pub(crate) use super::*; - use crate::config::mitigation_coverage::MitigationCoverage; pub(crate) const MAX_THREADS_CAP: usize = 256; /// Ignore the value. Used for removed options where we don't actually want to store @@ -2084,39 +2134,6 @@ pub mod parse { }; true } - - fn parse_partial_mitigations( - slot: &mut Vec, - v: Option<&str>, - enabled: bool, - ) -> bool { - match v { - Some(s) => { - for sub in s.split(',') { - match sub.parse() { - Ok(kind) => slot.push(MitigationCoverage { kind, enabled }), - Err(_) => return false, - } - } - true - } - None => false, - } - } - - pub(crate) fn parse_allow_partial_mitigations( - slot: &mut Vec, - v: Option<&str>, - ) -> bool { - parse_partial_mitigations(slot, v, true) - } - - pub(crate) fn parse_deny_partial_mitigations( - slot: &mut Vec, - v: Option<&str>, - ) -> bool { - parse_partial_mitigations(slot, v, false) - } } options! { @@ -2139,7 +2156,7 @@ options! { collapse_macro_debuginfo: CollapseMacroDebuginfo = (CollapseMacroDebuginfo::Unspecified, parse_collapse_macro_debuginfo, [TRACKED], "set option to collapse debuginfo for macros"), - control_flow_guard: CFGuard = (CFGuard::Disabled, parse_cfguard, [TRACKED], + control_flow_guard: CFGuard = (CFGuard::Disabled, parse_cfguard, [TRACKED MITIGATION], "use Windows Control Flow Guard (default: no)"), debug_assertions: Option = (None, parse_opt_bool, [TRACKED], "explicitly enable the `cfg(debug_assertions)` directive"), @@ -2281,7 +2298,9 @@ options! { // tidy-alphabetical-start allow_features: Option> = (None, parse_opt_comma_list, [TRACKED], "only allow the listed language features to be enabled in code (comma separated)"), - allow_partial_mitigations: Vec = (Vec::new(), parse_allow_partial_mitigations, [UNTRACKED], + // the real parser is at the `setter_for` macro, to allow `-Z` and `-C` options to + // work together. + allow_partial_mitigations: () = ((), parse_allow_partial_mitigations, [UNTRACKED], "Allow mitigations not enabled for all dependency crates (comma separated list)"), always_encode_mir: bool = (false, parse_bool, [TRACKED], "encode MIR of all functions into the crate metadata (default: no)"), @@ -2350,7 +2369,7 @@ options! { "deduplicate identical diagnostics (default: yes)"), default_visibility: Option = (None, parse_opt_symbol_visibility, [TRACKED], "overrides the `default_visibility` setting of the target"), - deny_partial_mitigations: Vec = (Vec::new(), parse_deny_partial_mitigations, [UNTRACKED], + deny_partial_mitigations: () = ((), parse_deny_partial_mitigations, [UNTRACKED], "Deny mitigations not enabled for all dependency crates (comma separated list)"), dep_info_omit_d_target: bool = (false, parse_bool, [TRACKED], "in dep-info output, omit targets for tracking dependencies of the dep-info files \ @@ -2741,7 +2760,7 @@ written to standard error output)"), src_hash_algorithm: Option = (None, parse_src_file_hash, [TRACKED], "hash algorithm of source files in debug info (`md5`, `sha1`, or `sha256`)"), #[rustc_lint_opt_deny_field_access("use `Session::stack_protector` instead of this field")] - stack_protector: StackProtector = (StackProtector::None, parse_stack_protector, [TRACKED], + stack_protector: StackProtector = (StackProtector::None, parse_stack_protector, [TRACKED MITIGATION], "control stack smash protection strategy (`rustc --print stack-protector-strategies` for details)"), staticlib_allow_rdylib_deps: bool = (false, parse_bool, [TRACKED], "allow staticlibs to have rust dylib dependencies"), diff --git a/compiler/rustc_session/src/options/mitigation_coverage.rs b/compiler/rustc_session/src/options/mitigation_coverage.rs index d851fac1ea1e8..cf839706fe787 100644 --- a/compiler/rustc_session/src/options/mitigation_coverage.rs +++ b/compiler/rustc_session/src/options/mitigation_coverage.rs @@ -1,4 +1,4 @@ -use std::collections::BTreeSet; +use std::collections::{BTreeMap, BTreeSet}; use std::str::FromStr; use rustc_macros::{BlobDecodable, Encodable}; @@ -65,14 +65,66 @@ impl From for DeniedPartialMitigationLevel { } } -pub struct DeniedPartialMitigationKindParseError; +#[derive(Copy, Clone)] +struct MitigationStatus { + // This is the index of the option in the command line. This is needed because + // re-enabling a mitigation resets the partial mitigation status if it's later in the command + // line, and this works across `-C` and `-Z` args. + // + // e.g. `-Z stack-protector=strong` resets `-C allow-partial-mitigations=stack-protector`. + index: usize, + allowed: Option, +} -#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Encodable, BlobDecodable)] -pub struct MitigationCoverage { - pub kind: DeniedPartialMitigationKind, - pub enabled: bool, +#[derive(Clone, Default)] +pub struct MitigationCoverageMap { + map: BTreeMap, } +impl MitigationCoverageMap { + fn apply_mitigation( + &mut self, + kind: DeniedPartialMitigationKind, + index: usize, + allowed: Option, + ) { + self.map + .entry(kind) + .and_modify(|e| { + if index >= e.index { + *e = MitigationStatus { index, allowed } + } + }) + .or_insert(MitigationStatus { index, allowed }); + } + + pub(crate) fn handle_allowdeny_mitigation_option( + &mut self, + v: Option<&str>, + index: usize, + allowed: bool, + ) -> bool { + match v { + Some(s) => { + for sub in s.split(',') { + match sub.parse() { + Ok(kind) => self.apply_mitigation(kind, index, Some(allowed)), + Err(_) => return false, + } + } + true + } + None => false, + } + } + + pub(crate) fn reset_mitigation(&mut self, kind: DeniedPartialMitigationKind, index: usize) { + self.apply_mitigation(kind, index, None); + } +} + +pub struct DeniedPartialMitigationKindParseError; + macro_rules! intersperse { ($sep:expr, ($first:expr $(, $rest:expr)* $(,)?)) => { concat!($first $(, $sep, $rest)*) @@ -81,6 +133,7 @@ macro_rules! intersperse { macro_rules! denied_partial_mitigations { ([$self:ident] enum $kind:ident {$(($name:ident, $text:expr, $since:ident, $code:expr)),*}) => { + #[allow(non_camel_case_types)] #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Encodable, BlobDecodable)] pub enum DeniedPartialMitigationKind { $($name),* @@ -113,12 +166,13 @@ macro_rules! denied_partial_mitigations { #[allow(unused)] impl DeniedPartialMitigationKind { - pub fn enforced_since(&self) -> Edition { - match self { + pub fn allowed_by_default_at(&self, edition: Edition) -> bool { + let enforced_since = match self { // Should change the enforced-since edition of StackProtector to 2015 // (all editions) when `-C stack-protector` is stabilized. $(DeniedPartialMitigationKind::$name => Edition::$since),* - } + }; + edition < enforced_since } } @@ -148,8 +202,10 @@ macro_rules! denied_partial_mitigations { denied_partial_mitigations! { [self] enum DeniedPartialMitigationKind { - (StackProtector, "stack-protector", EditionFuture, self.stack_protector()), - (ControlFlowGuard, "control-flow-guard", EditionFuture, self.opts.cg.control_flow_guard == CFGuard::Checks) + // The mitigation name should match the option name in rustc_session::options, + // to allow for resetting the mitigation + (stack_protector, "stack-protector", EditionFuture, self.stack_protector()), + (control_flow_guard, "control-flow-guard", EditionFuture, self.opts.cg.control_flow_guard == CFGuard::Checks) } } @@ -168,13 +224,17 @@ impl Options { ) -> impl Iterator { let mut result: BTreeSet<_> = self .all_denied_partial_mitigations() - .filter(|mitigation| mitigation.enforced_since() > edition) + .filter(|mitigation| mitigation.allowed_by_default_at(edition)) .collect(); - for mitigation in &self.unstable_opts.allow_partial_mitigations { - if mitigation.enabled { - result.insert(mitigation.kind); - } else { - result.remove(&mitigation.kind); + for (kind, MitigationStatus { index: _, allowed }) in &self.mitigation_coverage_map.map { + match allowed { + Some(true) => { + result.insert(*kind); + } + Some(false) => { + result.remove(kind); + } + None => {} } } result.into_iter() diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs index 3caff6edd504a..4a2b3847d839c 100644 --- a/src/librustdoc/config.rs +++ b/src/librustdoc/config.rs @@ -413,9 +413,9 @@ impl Options { config::parse_error_format(early_dcx, matches, color, json_color, json_rendered); let diagnostic_width = matches.opt_get("diagnostic-width").unwrap_or_default(); - let mut target_modifiers = BTreeMap::::new(); - let codegen_options = CodegenOptions::build(early_dcx, matches, &mut target_modifiers); - let unstable_opts = UnstableOptions::build(early_dcx, matches, &mut target_modifiers); + let mut collected_options = Default::default(); + let codegen_options = CodegenOptions::build(early_dcx, matches, &mut collected_options); + let unstable_opts = UnstableOptions::build(early_dcx, matches, &mut collected_options); let remap_path_prefix = match parse_remap_path_prefix(matches) { Ok(prefix_mappings) => prefix_mappings, @@ -894,7 +894,7 @@ impl Options { scrape_examples_options, unstable_features, doctest_build_args, - target_modifiers, + target_modifiers: collected_options.target_modifiers, }; let render_options = RenderOptions { output, diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.cfg-allow-first.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.cfg-allow-first.stderr new file mode 100644 index 0000000000000..24bcf83a9be6f --- /dev/null +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.cfg-allow-first.stderr @@ -0,0 +1,47 @@ +error: your program uses the crate `std`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `std` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` + +error: your program uses the crate `core`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `core` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` + +error: your program uses the crate `alloc`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `alloc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` + +error: your program uses the crate `compiler_builtins`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `compiler_builtins` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` + +error: your program uses the crate `libc`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `libc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` + +error: aborting due to 5 previous errors + diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.sp.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.disable-enable-reset.stderr similarity index 89% rename from tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.sp.stderr rename to tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.disable-enable-reset.stderr index b8ca779ed3b6d..f039dc7acbd09 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.sp.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.disable-enable-reset.stderr @@ -1,5 +1,5 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 | LL | fn main() {} | ^ @@ -8,7 +8,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 | LL | fn main() {} | ^ @@ -17,7 +17,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 | LL | fn main() {} | ^ @@ -26,7 +26,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 | LL | fn main() {} | ^ @@ -35,7 +35,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 | LL | fn main() {} | ^ diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.disable.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.disable.stderr similarity index 89% rename from tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.disable.stderr rename to tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.disable.stderr index b8ca779ed3b6d..f039dc7acbd09 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.disable.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.disable.stderr @@ -1,5 +1,5 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 | LL | fn main() {} | ^ @@ -8,7 +8,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 | LL | fn main() {} | ^ @@ -17,7 +17,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 | LL | fn main() {} | ^ @@ -26,7 +26,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 | LL | fn main() {} | ^ @@ -35,7 +35,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 | LL | fn main() {} | ^ diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.enable-disable.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.enable-disable.stderr similarity index 89% rename from tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.enable-disable.stderr rename to tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.enable-disable.stderr index b8ca779ed3b6d..f039dc7acbd09 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.enable-disable.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.enable-disable.stderr @@ -1,5 +1,5 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 | LL | fn main() {} | ^ @@ -8,7 +8,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 | LL | fn main() {} | ^ @@ -17,7 +17,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 | LL | fn main() {} | ^ @@ -26,7 +26,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 | LL | fn main() {} | ^ @@ -35,7 +35,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 | LL | fn main() {} | ^ diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.rs b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.rs new file mode 100644 index 0000000000000..4b419e8212c10 --- /dev/null +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.rs @@ -0,0 +1,20 @@ +// ignore-tidy-linelength +//@ revisions: sp disable enable-disable wrong-enable disable-enable-reset cfg-allow-first sp-allow-first +//@ check-fail +//@ ignore-nvptx64 stack protector is not supported +//@ ignore-wasm32-unknown-unknown stack protector is not supported +//@ edition:future +//@ [sp] compile-flags: -Z unstable-options -Z stack-protector=all +//@ [disable] compile-flags: -Z unstable-options -Z deny-partial-mitigations=stack-protector -Z stack-protector=all +//@ [enable-disable] compile-flags: -Z unstable-options -Z allow-partial-mitigations=stack-protector -Z deny-partial-mitigations=stack-protector -Z stack-protector=all +//@ [wrong-enable] compile-flags: -Z unstable-options -Z allow-partial-mitigations=control-flow-guard -Z stack-protector=all +//@ [cfg-allow-first] compile-flags: -Z unstable-options -Z allow-partial-mitigations=stack-protector -C control-flow-guard=on +//@ [sp-allow-first] compile-flags: -Z unstable-options -Z allow-partial-mitigations=stack-protector -Z stack-protector=all +//@ [disable-enable-reset] compile-flags: -Z unstable-options -Z deny-partial-mitigations=stack-protector -Z allow-partial-mitigations=stack-protector -Z stack-protector=all + +fn main() {} +//~^ ERROR that is not compiled with +//~| ERROR that is not compiled with +//~| ERROR that is not compiled with +//~| ERROR that is not compiled with +//~| ERROR that is not compiled with diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.wrong-enable.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.sp-allow-first.stderr similarity index 89% rename from tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.wrong-enable.stderr rename to tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.sp-allow-first.stderr index b8ca779ed3b6d..f039dc7acbd09 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.wrong-enable.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.sp-allow-first.stderr @@ -1,5 +1,5 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 | LL | fn main() {} | ^ @@ -8,7 +8,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 | LL | fn main() {} | ^ @@ -17,7 +17,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 | LL | fn main() {} | ^ @@ -26,7 +26,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 | LL | fn main() {} | ^ @@ -35,7 +35,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 | LL | fn main() {} | ^ diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.sp.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.sp.stderr new file mode 100644 index 0000000000000..f039dc7acbd09 --- /dev/null +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.sp.stderr @@ -0,0 +1,47 @@ +error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: aborting due to 5 previous errors + diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.wrong-enable.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.wrong-enable.stderr new file mode 100644 index 0000000000000..f039dc7acbd09 --- /dev/null +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.wrong-enable.stderr @@ -0,0 +1,47 @@ +error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: aborting due to 5 previous errors + diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.both.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.both.stderr similarity index 89% rename from tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.both.stderr rename to tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.both.stderr index 50febbee060f2..cbbe300365303 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.both.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.both.stderr @@ -1,5 +1,5 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 | LL | fn main() {} | ^ @@ -8,7 +8,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `std`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 | LL | fn main() {} | ^ @@ -17,7 +17,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 | LL | fn main() {} | ^ @@ -26,7 +26,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 | LL | fn main() {} | ^ @@ -35,7 +35,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 | LL | fn main() {} | ^ @@ -44,7 +44,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 | LL | fn main() {} | ^ @@ -53,7 +53,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 | LL | fn main() {} | ^ @@ -62,7 +62,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 | LL | fn main() {} | ^ @@ -71,7 +71,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 | LL | fn main() {} | ^ @@ -80,7 +80,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `libc`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 | LL | fn main() {} | ^ diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.enable-separately-disable-together.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.enable-separately-disable-together.stderr similarity index 89% rename from tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.enable-separately-disable-together.stderr rename to tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.enable-separately-disable-together.stderr index 50febbee060f2..cbbe300365303 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.enable-separately-disable-together.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.enable-separately-disable-together.stderr @@ -1,5 +1,5 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 | LL | fn main() {} | ^ @@ -8,7 +8,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `std`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 | LL | fn main() {} | ^ @@ -17,7 +17,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 | LL | fn main() {} | ^ @@ -26,7 +26,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 | LL | fn main() {} | ^ @@ -35,7 +35,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 | LL | fn main() {} | ^ @@ -44,7 +44,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 | LL | fn main() {} | ^ @@ -53,7 +53,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 | LL | fn main() {} | ^ @@ -62,7 +62,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 | LL | fn main() {} | ^ @@ -71,7 +71,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 | LL | fn main() {} | ^ @@ -80,7 +80,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `libc`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations.rs:14:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 | LL | fn main() {} | ^ diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.rs b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.rs new file mode 100644 index 0000000000000..2ce4172023aad --- /dev/null +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.rs @@ -0,0 +1,20 @@ +// ignore-tidy-linelength +//@ revisions: both enable-separately-disable-together +//@ check-fail +//@ ignore-nvptx64 stack protector is not supported +//@ ignore-wasm32-unknown-unknown stack protector is not supported +//@ edition:future +//@ [both] compile-flags: -Z unstable-options -C control-flow-guard=on -Z stack-protector=all +//@ [enable-separately-disable-together] compile-flags: -Z unstable-options -Z allow-partial-mitigations=stack-protector -Z allow-partial-mitigations=control-flow-guard -Z deny-partial-mitigations=control-flow-guard,stack-protector -C control-flow-guard=on -Z stack-protector=all + +fn main() {} +//~^ ERROR that is not compiled with +//~| ERROR that is not compiled with +//~| ERROR that is not compiled with +//~| ERROR that is not compiled with +//~| ERROR that is not compiled with +//~| ERROR that is not compiled with +//~| ERROR that is not compiled with +//~| ERROR that is not compiled with +//~| ERROR that is not compiled with +//~| ERROR that is not compiled with diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-bad-cli.rs b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-bad-cli.rs new file mode 100644 index 0000000000000..0f45830b9b64f --- /dev/null +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-bad-cli.rs @@ -0,0 +1,12 @@ +// ignore-tidy-linelength +//@ check-fail +//@ ignore-nvptx64 stack protector is not supported +//@ ignore-wasm32-unknown-unknown stack protector is not supported +//@ edition:future +//@ compile-flags: -Z unstable-options -Z deny-partial-mitigations=garbage + +// have a test that the list of mitigations is generated correctly + +//~? ERROR incorrect value `garbage` for unstable option `deny-partial-mitigations` - comma-separated list of mitigation kinds (available: + +fn main() {} diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-bad-cli.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-bad-cli.stderr new file mode 100644 index 0000000000000..9af53a1689aec --- /dev/null +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-bad-cli.stderr @@ -0,0 +1,2 @@ +error: incorrect value `garbage` for unstable option `deny-partial-mitigations` - comma-separated list of mitigation kinds (available: `stack-protector`, `control-flow-guard`) was expected + diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.rs b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.rs index d32c579a8cae1..5ed5edf63ece2 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.rs +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.rs @@ -3,7 +3,7 @@ //@ ignore-nvptx64 stack protector is not supported //@ ignore-wasm32-unknown-unknown stack protector is not supported //@ edition: 2024 -//@ compile-flags: -Z deny-partial-mitigations=control-flow-guard -C control-flow-guard=on +//@ compile-flags: -C control-flow-guard=on -Z deny-partial-mitigations=control-flow-guard // check that in edition 2024, it is still possible to explicitly // disallow partial mitigations (in edition=future, they are diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.rs b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.rs deleted file mode 100644 index 8ba8873053e05..0000000000000 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations.rs +++ /dev/null @@ -1,54 +0,0 @@ -// ignore-tidy-linelength -//@ revisions: sp both disable enable-disable wrong-enable enable-separately-disable-together -//@ check-fail -//@ ignore-nvptx64 stack protector is not supported -//@ ignore-wasm32-unknown-unknown stack protector is not supported -//@ edition:future -//@ [both] compile-flags: -Z unstable-options -C control-flow-guard=on -Z stack-protector=all -//@ [sp] compile-flags: -Z unstable-options -Z stack-protector=all -//@ [disable] compile-flags: -Z unstable-options -Z deny-partial-mitigations=stack-protector -Z stack-protector=all -//@ [enable-disable] compile-flags: -Z unstable-options -Z allow-partial-mitigations=stack-protector -Z deny-partial-mitigations=stack-protector -Z stack-protector=all -//@ [wrong-enable] compile-flags: -Z unstable-options -Z allow-partial-mitigations=control-flow-guard -Z stack-protector=all -//@ [enable-separately-disable-together] compile-flags: -Z unstable-options -Z allow-partial-mitigations=stack-protector -Z allow-partial-mitigations=control-flow-guard -Z deny-partial-mitigations=control-flow-guard,stack-protector -C control-flow-guard=on -Z stack-protector=all - -fn main() {} -//[both]~^ ERROR that is not compiled with -//[both]~| ERROR that is not compiled with -//[both]~| ERROR that is not compiled with -//[both]~| ERROR that is not compiled with -//[both]~| ERROR that is not compiled with -//[both]~| ERROR that is not compiled with -//[both]~| ERROR that is not compiled with -//[both]~| ERROR that is not compiled with -//[both]~| ERROR that is not compiled with -//[both]~| ERROR that is not compiled with -//[sp]~^^^^^^^^^^^ ERROR that is not compiled with -//[sp]~| ERROR that is not compiled with -//[sp]~| ERROR that is not compiled with -//[sp]~| ERROR that is not compiled with -//[sp]~| ERROR that is not compiled with -//[disable]~^^^^^^^^^^^^^^^^ ERROR that is not compiled with -//[disable]~| ERROR that is not compiled with -//[disable]~| ERROR that is not compiled with -//[disable]~| ERROR that is not compiled with -//[disable]~| ERROR that is not compiled with -//[enable-disable]~^^^^^^^^^^^^^^^^^^^^^ ERROR that is not compiled with -//[enable-disable]~| ERROR that is not compiled with -//[enable-disable]~| ERROR that is not compiled with -//[enable-disable]~| ERROR that is not compiled with -//[enable-disable]~| ERROR that is not compiled with -//[wrong-enable]~^^^^^^^^^^^^^^^^^^^^^^^^^^ ERROR that is not compiled with -//[wrong-enable]~| ERROR that is not compiled with -//[wrong-enable]~| ERROR that is not compiled with -//[wrong-enable]~| ERROR that is not compiled with -//[wrong-enable]~| ERROR that is not compiled with -//[enable-separately-disable-together]~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ERROR that is not compiled with -//[enable-separately-disable-together]~| ERROR that is not compiled with -//[enable-separately-disable-together]~| ERROR that is not compiled with -//[enable-separately-disable-together]~| ERROR that is not compiled with -//[enable-separately-disable-together]~| ERROR that is not compiled with -//[enable-separately-disable-together]~| ERROR that is not compiled with -//[enable-separately-disable-together]~| ERROR that is not compiled with -//[enable-separately-disable-together]~| ERROR that is not compiled with -//[enable-separately-disable-together]~| ERROR that is not compiled with -//[enable-separately-disable-together]~| ERROR that is not compiled with diff --git a/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations-current-edition.rs b/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations-current-edition.rs new file mode 100644 index 0000000000000..6a9c297698b63 --- /dev/null +++ b/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations-current-edition.rs @@ -0,0 +1,13 @@ +// ignore-tidy-linelength +//@ revisions: no-deny deny-first +//@ check-pass +//@ ignore-nvptx64 stack protector is not supported +//@ ignore-wasm32-unknown-unknown stack protector is not supported +//@ edition: 2024 +//@ [deny-first] compile-flags: -Z deny-partial-mitigations=control-flow-guard -C control-flow-guard=on +//@ [no-deny] compile-flags: -C control-flow-guard=on + +// check that the `-C control-flow-guard=on` overrides the `-Z deny-partial-mitigations=control-flow-guard`, +// which in edition 2024 leads to partial mitigations being allowed + +fn main() {} diff --git a/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations.rs b/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations.rs index c0bc09276568f..804873f397516 100644 --- a/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations.rs +++ b/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations.rs @@ -4,8 +4,8 @@ //@ edition:future //@ ignore-nvptx64 stack protector is not supported //@ ignore-wasm32-unknown-unknown stack protector is not supported -//@ [both] compile-flags: -Z unstable-options -Z allow-partial-mitigations=stack-protector,control-flow-guard -C control-flow-guard=on -Z stack-protector=all -//@ [sp] compile-flags: -Z unstable-options -Z allow-partial-mitigations=stack-protector -Z stack-protector=all -//@ [disable-enable] compile-flags: -Z unstable-options -Z deny-partial-mitigations=stack-protector -Z allow-partial-mitigations=stack-protector -Z stack-protector=all +//@ [both] compile-flags: -Z unstable-options -Z stack-protector=all -C control-flow-guard=on -Z allow-partial-mitigations=stack-protector,control-flow-guard +//@ [sp] compile-flags: -Z unstable-options -Z stack-protector=all -Z allow-partial-mitigations=stack-protector +//@ [disable-enable] compile-flags: -Z unstable-options -Z deny-partial-mitigations=stack-protector -Z stack-protector=all -Z allow-partial-mitigations=stack-protector fn main() {} From 1b96797c0855dbe0bad2c7f98a21202aec718aae Mon Sep 17 00:00:00 2001 From: Ariel Ben-Yehuda Date: Tue, 7 Apr 2026 00:32:29 +0300 Subject: [PATCH 10/11] address review comments --- compiler/rustc_metadata/src/errors.rs | 2 +- compiler/rustc_metadata/src/rmeta/decoder.rs | 7 +- compiler/rustc_metadata/src/rmeta/encoder.rs | 4 +- .../src/options/mitigation_coverage.rs | 10 +- tests/ui/README.md | 4 +- ...d-future-allow-reset-by-mitigation.stderr} | 20 ++-- .../err-allow-partial-mitigations-1-error.rs | 35 +++++-- ...llow-partial-mitigations-1-error.sp.stderr | 47 ---------- ...or.stack-protector-allow-then-deny.stderr} | 20 ++-- ...ector-but-allow-control-flow-guard.stderr} | 20 ++-- ...r-future-allow-reset-by-mitigation.stderr} | 20 ++-- ...ure-deny-allow-reset-by-mitigation.stderr} | 20 ++-- ...tor-future-deny-reset-by-mitigation.stderr | 47 ++++++++++ ...tack-protector-future-explicit-deny.stderr | 47 ++++++++++ ...ions-1-error.stack-protector-future.stderr | 47 ++++++++++ ...al-mitigations-1-error.wrong-enable.stderr | 47 ---------- ...w-partial-mitigations-2-errors.both.stderr | 40 ++++---- ....enable-separately-disable-together.stderr | 40 ++++---- ....enable-together-disable-separately.stderr | 92 +++++++++++++++++++ .../err-allow-partial-mitigations-2-errors.rs | 12 ++- .../err-allow-partial-mitigations-bad-cli.rs | 2 +- ...on.control-flow-2024-explicit-deny.stderr} | 20 ++-- ...low-partial-mitigations-current-edition.rs | 3 +- ...low-partial-mitigations-current-edition.rs | 20 +++- .../ok-allow-partial-mitigations.rs | 15 ++- 25 files changed, 416 insertions(+), 225 deletions(-) rename tests/ui/allow-partial-mitigations/{err-allow-partial-mitigations-1-error.cfg-allow-first.stderr => err-allow-partial-mitigations-1-error.control-flow-guard-future-allow-reset-by-mitigation.stderr} (76%) delete mode 100644 tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.sp.stderr rename tests/ui/allow-partial-mitigations/{err-allow-partial-mitigations-1-error.sp-allow-first.stderr => err-allow-partial-mitigations-1-error.stack-protector-allow-then-deny.stderr} (76%) rename tests/ui/allow-partial-mitigations/{err-allow-partial-mitigations-1-error.disable-enable-reset.stderr => err-allow-partial-mitigations-1-error.stack-protector-but-allow-control-flow-guard.stderr} (76%) rename tests/ui/allow-partial-mitigations/{err-allow-partial-mitigations-1-error.disable.stderr => err-allow-partial-mitigations-1-error.stack-protector-future-allow-reset-by-mitigation.stderr} (76%) rename tests/ui/allow-partial-mitigations/{err-allow-partial-mitigations-1-error.enable-disable.stderr => err-allow-partial-mitigations-1-error.stack-protector-future-deny-allow-reset-by-mitigation.stderr} (76%) create mode 100644 tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-deny-reset-by-mitigation.stderr create mode 100644 tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-explicit-deny.stderr create mode 100644 tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future.stderr delete mode 100644 tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.wrong-enable.stderr create mode 100644 tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.enable-together-disable-separately.stderr rename tests/ui/allow-partial-mitigations/{err-allow-partial-mitigations-current-edition.stderr => err-allow-partial-mitigations-current-edition.control-flow-2024-explicit-deny.stderr} (75%) diff --git a/compiler/rustc_metadata/src/errors.rs b/compiler/rustc_metadata/src/errors.rs index 79568dcec81ec..a6f35a179d703 100644 --- a/compiler/rustc_metadata/src/errors.rs +++ b/compiler/rustc_metadata/src/errors.rs @@ -702,7 +702,7 @@ pub(crate) struct UnusedCrateDependency { "your program uses the crate `{$extern_crate}`, that is not compiled with `{$mitigation_name}{$mitigation_level}` enabled" )] #[note( - "recompile `{$extern_crate}` with `{$mitigation_name}{$mitigation_level}` enabled, or use `-Z allow-partial-mitigations={$mitigation_name}` to allow creating an artifact that has the mitigation only partially enabled " + "recompile `{$extern_crate}` with `{$mitigation_name}{$mitigation_level}` enabled, or use `-Z allow-partial-mitigations={$mitigation_name}` to allow creating an artifact that has the mitigation partially enabled " )] #[help( "it is possible to disable `-Z allow-partial-mitigations={$mitigation_name}` via `-Z deny-partial-mitigations={$mitigation_name}`" diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs index 2993eb340cfe4..280b3b12e5c85 100644 --- a/compiler/rustc_metadata/src/rmeta/decoder.rs +++ b/compiler/rustc_metadata/src/rmeta/decoder.rs @@ -79,10 +79,13 @@ impl MetadataBlob { /// own crate numbers. pub(crate) type CrateNumMap = IndexVec; -/// Target modifiers - abi or exploit mitigations flags that cause unsoundness when mixed +/// Target modifiers - abi or exploit mitigations options that may cause unsoundness when mixed or +/// partially enabled. pub(crate) type TargetModifiers = Vec; -/// The set of enforceable mitigations (RFC 3855) that are currently enabled for this crate +/// The set of mitigations that cannot be partially enabled (see +/// [RFC 3855](https://github.com/rust-lang/rfcs/pull/3855)), but are currently enabled for this +/// crate. pub(crate) type DeniedPartialMitigations = Vec; pub(crate) struct CrateMetadata { diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs index 2a0eeef442a33..17dc3564c6ac9 100644 --- a/compiler/rustc_metadata/src/rmeta/encoder.rs +++ b/compiler/rustc_metadata/src/rmeta/encoder.rs @@ -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 denied_partial_mitigations = - stat!("enforced-mitigations", || self.encode_enabled_denied_partial_mitigations()); + let denied_partial_mitigations = stat!("denied-partial-mitigations", || self + .encode_enabled_denied_partial_mitigations()); let root = stat!("final", || { let attrs = tcx.hir_krate_attrs(); diff --git a/compiler/rustc_session/src/options/mitigation_coverage.rs b/compiler/rustc_session/src/options/mitigation_coverage.rs index cf839706fe787..f396392cd2638 100644 --- a/compiler/rustc_session/src/options/mitigation_coverage.rs +++ b/compiler/rustc_session/src/options/mitigation_coverage.rs @@ -167,12 +167,12 @@ macro_rules! denied_partial_mitigations { #[allow(unused)] impl DeniedPartialMitigationKind { pub fn allowed_by_default_at(&self, edition: Edition) -> bool { - let enforced_since = match self { - // Should change the enforced-since edition of StackProtector to 2015 + let denied_since = match self { + // Should change the denied-since edition of StackProtector to 2015 // (all editions) when `-C stack-protector` is stabilized. $(DeniedPartialMitigationKind::$name => Edition::$since),* }; - edition < enforced_since + edition < denied_since } } @@ -209,7 +209,9 @@ denied_partial_mitigations! { } } -/// Denied-partial mitigations, see [RFC 3855](https://github.com/rust-lang/rfcs/pull/3855) +/// A mitigation that cannot be partially enabled (see +/// [RFC 3855](https://github.com/rust-lang/rfcs/pull/3855)), but are currently enabled for this +/// crate. #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Encodable, BlobDecodable)] pub struct DeniedPartialMitigation { pub kind: DeniedPartialMitigationKind, diff --git a/tests/ui/README.md b/tests/ui/README.md index ab9b58aa4981f..4527105dd32ad 100644 --- a/tests/ui/README.md +++ b/tests/ui/README.md @@ -24,9 +24,9 @@ See [Allocator traits and `std::heap` #32838](https://github.com/rust-lang/rust/ ## `tests/ui/allow-partial-mitigations` -These tests exercise the check against partial mitigation enforcement. +These tests exercise the support for mitigation coverage and the `allow-partial-mitigations` and `deny-partial-mitigations` options. -See [the mitigation enforcement RFC](https://github.com/rust-lang/rfcs/pull/3855). +See [RFC 3855](https://github.com/rust-lang/rfcs/pull/3855). ## `tests/ui/annotate-moves` diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.cfg-allow-first.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.control-flow-guard-future-allow-reset-by-mitigation.stderr similarity index 76% rename from tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.cfg-allow-first.stderr rename to tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.control-flow-guard-future-allow-reset-by-mitigation.stderr index 24bcf83a9be6f..fa4b9a8c99f8c 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.cfg-allow-first.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.control-flow-guard-future-allow-reset-by-mitigation.stderr @@ -1,46 +1,46 @@ error: your program uses the crate `std`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 | LL | fn main() {} | ^ | - = note: recompile `std` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `std` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `core`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 | LL | fn main() {} | ^ | - = note: recompile `core` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `core` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `alloc`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 | LL | fn main() {} | ^ | - = note: recompile `alloc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `alloc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `compiler_builtins`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 | LL | fn main() {} | ^ | - = note: recompile `compiler_builtins` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `compiler_builtins` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `libc`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 | LL | fn main() {} | ^ | - = note: recompile `libc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `libc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: aborting due to 5 previous errors diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.rs b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.rs index 4b419e8212c10..f87d40196d6e5 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.rs +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.rs @@ -1,16 +1,35 @@ // ignore-tidy-linelength -//@ revisions: sp disable enable-disable wrong-enable disable-enable-reset cfg-allow-first sp-allow-first +//@ revisions: stack-protector-future stack-protector-future-explicit-deny stack-protector-future-deny-reset-by-mitigation stack-protector-allow-then-deny stack-protector-but-allow-control-flow-guard control-flow-guard-future-allow-reset-by-mitigation stack-protector-future-allow-reset-by-mitigation stack-protector-future-deny-allow-reset-by-mitigation //@ check-fail //@ ignore-nvptx64 stack protector is not supported //@ ignore-wasm32-unknown-unknown stack protector is not supported //@ edition:future -//@ [sp] compile-flags: -Z unstable-options -Z stack-protector=all -//@ [disable] compile-flags: -Z unstable-options -Z deny-partial-mitigations=stack-protector -Z stack-protector=all -//@ [enable-disable] compile-flags: -Z unstable-options -Z allow-partial-mitigations=stack-protector -Z deny-partial-mitigations=stack-protector -Z stack-protector=all -//@ [wrong-enable] compile-flags: -Z unstable-options -Z allow-partial-mitigations=control-flow-guard -Z stack-protector=all -//@ [cfg-allow-first] compile-flags: -Z unstable-options -Z allow-partial-mitigations=stack-protector -C control-flow-guard=on -//@ [sp-allow-first] compile-flags: -Z unstable-options -Z allow-partial-mitigations=stack-protector -Z stack-protector=all -//@ [disable-enable-reset] compile-flags: -Z unstable-options -Z deny-partial-mitigations=stack-protector -Z allow-partial-mitigations=stack-protector -Z stack-protector=all + +// test that stack-protector is denied-partial in edition=future +//@ [stack-protector-future] compile-flags: -Z unstable-options -Z stack-protector=all + +// same, but with explicit deny +//@ [stack-protector-future-explicit-deny] compile-flags: -Z unstable-options -Z stack-protector=all -Z deny-partial-mitigations=stack-protector + +// same, but with explicit deny before the enable. The `-Z stack-protector=all` resets the mitigation status +// to default which is deny at edition=future. +// at edition=2024, this would be allowed, see ok-allow-partial-mitigations-current-edition scenario stack-protector-future-deny-reset-by-mitigation +//@ [stack-protector-future-deny-reset-by-mitigation] compile-flags: -Z unstable-options -Z deny-partial-mitigations=stack-protector -Z stack-protector=all + +// same, but with explicit allow followed by explicit deny +//@ [stack-protector-allow-then-deny] compile-flags: -Z unstable-options -Z stack-protector=all -Z allow-partial-mitigations=stack-protector -Z deny-partial-mitigations=stack-protector + +// check that allowing an unrelated mitigation (control-flow-guard) does not allow a different mitigation (stack-protector) +//@ [stack-protector-but-allow-control-flow-guard] compile-flags: -Z unstable-options -Z stack-protector=all -Z allow-partial-mitigations=control-flow-guard + +// check that `-C control-flow-guard` overrides the `-Z allow-partial-mitigations=control-flow-guard` (to the default, which is deny at edition=future) +//@ [control-flow-guard-future-allow-reset-by-mitigation] compile-flags: -Z unstable-options -Z allow-partial-mitigations=control-flow-guard -C control-flow-guard=on + +// check that `-Z stack-protector` overrides the `-Z allow-partial-mitigations=stack-protector` (to the default, which is deny at edition=future) +//@ [stack-protector-future-allow-reset-by-mitigation] compile-flags: -Z unstable-options -Z allow-partial-mitigations=stack-protector -Z stack-protector=all + +// check that this is the case even if there was a "deny" before the "allow" +//@ [stack-protector-future-deny-allow-reset-by-mitigation] compile-flags: -Z unstable-options -Z deny-partial-mitigations=stack-protector -Z allow-partial-mitigations=stack-protector -Z stack-protector=all fn main() {} //~^ ERROR that is not compiled with diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.sp.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.sp.stderr deleted file mode 100644 index f039dc7acbd09..0000000000000 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.sp.stderr +++ /dev/null @@ -1,47 +0,0 @@ -error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 - | -LL | fn main() {} - | ^ - | - = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled - = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` - -error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 - | -LL | fn main() {} - | ^ - | - = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled - = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` - -error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 - | -LL | fn main() {} - | ^ - | - = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled - = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` - -error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 - | -LL | fn main() {} - | ^ - | - = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled - = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` - -error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 - | -LL | fn main() {} - | ^ - | - = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled - = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` - -error: aborting due to 5 previous errors - diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.sp-allow-first.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-allow-then-deny.stderr similarity index 76% rename from tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.sp-allow-first.stderr rename to tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-allow-then-deny.stderr index f039dc7acbd09..3565173435b53 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.sp-allow-first.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-allow-then-deny.stderr @@ -1,46 +1,46 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 | LL | fn main() {} | ^ | - = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 | LL | fn main() {} | ^ | - = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 | LL | fn main() {} | ^ | - = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 | LL | fn main() {} | ^ | - = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 | LL | fn main() {} | ^ | - = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: aborting due to 5 previous errors diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.disable-enable-reset.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-but-allow-control-flow-guard.stderr similarity index 76% rename from tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.disable-enable-reset.stderr rename to tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-but-allow-control-flow-guard.stderr index f039dc7acbd09..3565173435b53 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.disable-enable-reset.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-but-allow-control-flow-guard.stderr @@ -1,46 +1,46 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 | LL | fn main() {} | ^ | - = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 | LL | fn main() {} | ^ | - = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 | LL | fn main() {} | ^ | - = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 | LL | fn main() {} | ^ | - = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 | LL | fn main() {} | ^ | - = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: aborting due to 5 previous errors diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.disable.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-allow-reset-by-mitigation.stderr similarity index 76% rename from tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.disable.stderr rename to tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-allow-reset-by-mitigation.stderr index f039dc7acbd09..3565173435b53 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.disable.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-allow-reset-by-mitigation.stderr @@ -1,46 +1,46 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 | LL | fn main() {} | ^ | - = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 | LL | fn main() {} | ^ | - = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 | LL | fn main() {} | ^ | - = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 | LL | fn main() {} | ^ | - = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 | LL | fn main() {} | ^ | - = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: aborting due to 5 previous errors diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.enable-disable.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-deny-allow-reset-by-mitigation.stderr similarity index 76% rename from tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.enable-disable.stderr rename to tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-deny-allow-reset-by-mitigation.stderr index f039dc7acbd09..3565173435b53 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.enable-disable.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-deny-allow-reset-by-mitigation.stderr @@ -1,46 +1,46 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 | LL | fn main() {} | ^ | - = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 | LL | fn main() {} | ^ | - = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 | LL | fn main() {} | ^ | - = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 | LL | fn main() {} | ^ | - = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 | LL | fn main() {} | ^ | - = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: aborting due to 5 previous errors diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-deny-reset-by-mitigation.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-deny-reset-by-mitigation.stderr new file mode 100644 index 0000000000000..3565173435b53 --- /dev/null +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-deny-reset-by-mitigation.stderr @@ -0,0 +1,47 @@ +error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: aborting due to 5 previous errors + diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-explicit-deny.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-explicit-deny.stderr new file mode 100644 index 0000000000000..3565173435b53 --- /dev/null +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-explicit-deny.stderr @@ -0,0 +1,47 @@ +error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: aborting due to 5 previous errors + diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future.stderr new file mode 100644 index 0000000000000..3565173435b53 --- /dev/null +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future.stderr @@ -0,0 +1,47 @@ +error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: aborting due to 5 previous errors + diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.wrong-enable.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.wrong-enable.stderr deleted file mode 100644 index f039dc7acbd09..0000000000000 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.wrong-enable.stderr +++ /dev/null @@ -1,47 +0,0 @@ -error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 - | -LL | fn main() {} - | ^ - | - = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled - = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` - -error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 - | -LL | fn main() {} - | ^ - | - = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled - = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` - -error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 - | -LL | fn main() {} - | ^ - | - = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled - = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` - -error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 - | -LL | fn main() {} - | ^ - | - = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled - = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` - -error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:15:1 - | -LL | fn main() {} - | ^ - | - = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled - = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` - -error: aborting due to 5 previous errors - diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.both.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.both.stderr index cbbe300365303..98029972ea19c 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.both.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.both.stderr @@ -1,91 +1,91 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 | LL | fn main() {} | ^ | - = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `std`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 | LL | fn main() {} | ^ | - = note: recompile `std` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `std` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 | LL | fn main() {} | ^ | - = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 | LL | fn main() {} | ^ | - = note: recompile `core` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `core` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 | LL | fn main() {} | ^ | - = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 | LL | fn main() {} | ^ | - = note: recompile `alloc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `alloc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 | LL | fn main() {} | ^ | - = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 | LL | fn main() {} | ^ | - = note: recompile `compiler_builtins` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `compiler_builtins` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 | LL | fn main() {} | ^ | - = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `libc`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 | LL | fn main() {} | ^ | - = note: recompile `libc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `libc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: aborting due to 10 previous errors diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.enable-separately-disable-together.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.enable-separately-disable-together.stderr index cbbe300365303..98029972ea19c 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.enable-separately-disable-together.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.enable-separately-disable-together.stderr @@ -1,91 +1,91 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 | LL | fn main() {} | ^ | - = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `std`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 | LL | fn main() {} | ^ | - = note: recompile `std` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `std` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 | LL | fn main() {} | ^ | - = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 | LL | fn main() {} | ^ | - = note: recompile `core` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `core` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 | LL | fn main() {} | ^ | - = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 | LL | fn main() {} | ^ | - = note: recompile `alloc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `alloc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 | LL | fn main() {} | ^ | - = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 | LL | fn main() {} | ^ | - = note: recompile `compiler_builtins` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `compiler_builtins` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 | LL | fn main() {} | ^ | - = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `libc`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:10:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 | LL | fn main() {} | ^ | - = note: recompile `libc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `libc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: aborting due to 10 previous errors diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.enable-together-disable-separately.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.enable-together-disable-separately.stderr new file mode 100644 index 0000000000000..98029972ea19c --- /dev/null +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.enable-together-disable-separately.stderr @@ -0,0 +1,92 @@ +error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `std`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `std` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` + +error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `core` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `core`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `core` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` + +error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `alloc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `alloc`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `alloc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` + +error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `compiler_builtins`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `compiler_builtins` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` + +error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` + +error: your program uses the crate `libc`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + | +LL | fn main() {} + | ^ + | + = note: recompile `libc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled + = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` + +error: aborting due to 10 previous errors + diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.rs b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.rs index 2ce4172023aad..88809892c8af4 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.rs +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.rs @@ -1,11 +1,19 @@ // ignore-tidy-linelength -//@ revisions: both enable-separately-disable-together +//@ revisions: both enable-separately-disable-together enable-together-disable-separately //@ check-fail //@ ignore-nvptx64 stack protector is not supported //@ ignore-wasm32-unknown-unknown stack protector is not supported //@ edition:future + +// just use 2 partial mitigations, without any allow/deny flag. Should be denied at edition=future. //@ [both] compile-flags: -Z unstable-options -C control-flow-guard=on -Z stack-protector=all -//@ [enable-separately-disable-together] compile-flags: -Z unstable-options -Z allow-partial-mitigations=stack-protector -Z allow-partial-mitigations=control-flow-guard -Z deny-partial-mitigations=control-flow-guard,stack-protector -C control-flow-guard=on -Z stack-protector=all + +// check that mitigations are denied if they are enabled separately and then disabled in a single command, +// to test the "foo,bar" syntax +//@ [enable-separately-disable-together] compile-flags: -Z unstable-options -C control-flow-guard=on -Z stack-protector=all -Z allow-partial-mitigations=stack-protector -Z allow-partial-mitigations=control-flow-guard -Z deny-partial-mitigations=control-flow-guard,stack-protector + +// same, but for allow +//@ [enable-together-disable-separately] compile-flags: -Z unstable-options -C control-flow-guard=on -Z stack-protector=all -Z allow-partial-mitigations=stack-protector,control-flow-guard -Z deny-partial-mitigations=control-flow-guard -Z deny-partial-mitigations=stack-protector fn main() {} //~^ ERROR that is not compiled with diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-bad-cli.rs b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-bad-cli.rs index 0f45830b9b64f..c5fe5b0e1158c 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-bad-cli.rs +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-bad-cli.rs @@ -5,7 +5,7 @@ //@ edition:future //@ compile-flags: -Z unstable-options -Z deny-partial-mitigations=garbage -// have a test that the list of mitigations is generated correctly +// test that the list of mitigations in the error message is generated correctly //~? ERROR incorrect value `garbage` for unstable option `deny-partial-mitigations` - comma-separated list of mitigation kinds (available: diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.control-flow-2024-explicit-deny.stderr similarity index 75% rename from tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.stderr rename to tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.control-flow-2024-explicit-deny.stderr index 02e9154986791..7940f3f907d3b 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.control-flow-2024-explicit-deny.stderr @@ -1,46 +1,46 @@ error: your program uses the crate `std`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-current-edition.rs:12:1 + --> $DIR/err-allow-partial-mitigations-current-edition.rs:13:1 | LL | fn main() {} | ^ | - = note: recompile `std` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `std` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `core`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-current-edition.rs:12:1 + --> $DIR/err-allow-partial-mitigations-current-edition.rs:13:1 | LL | fn main() {} | ^ | - = note: recompile `core` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `core` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `alloc`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-current-edition.rs:12:1 + --> $DIR/err-allow-partial-mitigations-current-edition.rs:13:1 | LL | fn main() {} | ^ | - = note: recompile `alloc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `alloc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `compiler_builtins`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-current-edition.rs:12:1 + --> $DIR/err-allow-partial-mitigations-current-edition.rs:13:1 | LL | fn main() {} | ^ | - = note: recompile `compiler_builtins` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `compiler_builtins` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `libc`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-current-edition.rs:12:1 + --> $DIR/err-allow-partial-mitigations-current-edition.rs:13:1 | LL | fn main() {} | ^ | - = note: recompile `libc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation only partially enabled + = note: recompile `libc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: aborting due to 5 previous errors diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.rs b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.rs index 5ed5edf63ece2..4f5acb0280d0b 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.rs +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.rs @@ -1,9 +1,10 @@ // ignore-tidy-linelength +//@ revisions: control-flow-2024-explicit-deny //@ check-fail //@ ignore-nvptx64 stack protector is not supported //@ ignore-wasm32-unknown-unknown stack protector is not supported //@ edition: 2024 -//@ compile-flags: -C control-flow-guard=on -Z deny-partial-mitigations=control-flow-guard +//@ [control-flow-2024-explicit-deny] compile-flags: -C control-flow-guard=on -Z deny-partial-mitigations=control-flow-guard // check that in edition 2024, it is still possible to explicitly // disallow partial mitigations (in edition=future, they are diff --git a/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations-current-edition.rs b/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations-current-edition.rs index 6a9c297698b63..dddad265aff4a 100644 --- a/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations-current-edition.rs +++ b/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations-current-edition.rs @@ -1,13 +1,25 @@ // ignore-tidy-linelength -//@ revisions: no-deny deny-first +//@ revisions: control-flow-guard-2024-default control-flow-guard-2024-deny-reset-by-mitigation stack-protector-2024-deny-reset-by-mitigation stack-protector-2024-allow-deny-reset-by-mitigation //@ check-pass //@ ignore-nvptx64 stack protector is not supported //@ ignore-wasm32-unknown-unknown stack protector is not supported //@ edition: 2024 -//@ [deny-first] compile-flags: -Z deny-partial-mitigations=control-flow-guard -C control-flow-guard=on -//@ [no-deny] compile-flags: -C control-flow-guard=on // check that the `-C control-flow-guard=on` overrides the `-Z deny-partial-mitigations=control-flow-guard`, -// which in edition 2024 leads to partial mitigations being allowed +// which in edition 2024 leads to partial mitigations being allowed. Test with both an explicit +// deny and without one. + +// just test control-flow-guard at edition 2024. allowed-partial due to backwards compatibility. +//@ [control-flow-guard-2024-default] compile-flags: -C control-flow-guard=on + +// test that -C control-flow-guard=on resets -Z deny-partial-mitigations=control-flow-guard +//@ [control-flow-guard-2024-deny-reset-by-mitigation] compile-flags: -Z deny-partial-mitigations=control-flow-guard -C control-flow-guard=on + +// same but for stack-protector, to match the stack-protector-future-deny-reset-by-mitigation test in +// err-allow-partial-mitigations-1-error (which has the same args but on edition=future). +//@ [stack-protector-2024-deny-reset-by-mitigation] compile-flags: -Z deny-partial-mitigations=stack-protector -Z stack-protector=all + +// check that this is the case even if there was an "allow" then a "deny" +//@ [stack-protector-2024-allow-deny-reset-by-mitigation] compile-flags: -Z unstable-options -Z allow-partial-mitigations=stack-protector -Z deny-partial-mitigations=stack-protector -Z stack-protector=all fn main() {} diff --git a/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations.rs b/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations.rs index 804873f397516..f9f013e44cc62 100644 --- a/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations.rs +++ b/tests/ui/allow-partial-mitigations/ok-allow-partial-mitigations.rs @@ -1,11 +1,18 @@ // ignore-tidy-linelength -//@ revisions: sp both disable-enable +//@ revisions: stack-protector-explicit-allow stack-protector-and-control-flow-guard-explicit-allow stack-protector-deny-then-allow //@ check-pass //@ edition:future //@ ignore-nvptx64 stack protector is not supported //@ ignore-wasm32-unknown-unknown stack protector is not supported -//@ [both] compile-flags: -Z unstable-options -Z stack-protector=all -C control-flow-guard=on -Z allow-partial-mitigations=stack-protector,control-flow-guard -//@ [sp] compile-flags: -Z unstable-options -Z stack-protector=all -Z allow-partial-mitigations=stack-protector -//@ [disable-enable] compile-flags: -Z unstable-options -Z deny-partial-mitigations=stack-protector -Z stack-protector=all -Z allow-partial-mitigations=stack-protector + +// requesting both stack-protector and control-flow-guard and then allow-partial-mitigations it +//@ [stack-protector-and-control-flow-guard-explicit-allow] compile-flags: -Z unstable-options -Z stack-protector=all -C control-flow-guard=on -Z allow-partial-mitigations=stack-protector,control-flow-guard + +// requesting stack-protector and then allow-partial-mitigations it +//@ [stack-protector-explicit-allow] compile-flags: -Z unstable-options -Z stack-protector=all -Z allow-partial-mitigations=stack-protector + +// testing that the later allow-partial-mitigations overrides the earlier deny-partial-mitigations +// see also the stack-protector-allow-then-deny test (in the error tests) for the other order +//@ [stack-protector-deny-then-allow] compile-flags: -Z unstable-options -Z stack-protector=all -Z deny-partial-mitigations=stack-protector -Z allow-partial-mitigations=stack-protector fn main() {} From 8864a6635b7fbb61347c417cc1f009043a8cc9a2 Mon Sep 17 00:00:00 2001 From: Ariel Ben-Yehuda Date: Sat, 11 Apr 2026 14:15:15 +0300 Subject: [PATCH 11/11] try to fix msvc --- ...rd-future-allow-reset-by-mitigation.stderr | 14 +++++----- .../err-allow-partial-mitigations-1-error.rs | 3 ++ ...ror.stack-protector-allow-then-deny.stderr | 14 +++++----- ...tector-but-allow-control-flow-guard.stderr | 14 +++++----- ...or-future-allow-reset-by-mitigation.stderr | 14 +++++----- ...ture-deny-allow-reset-by-mitigation.stderr | 14 +++++----- ...tor-future-deny-reset-by-mitigation.stderr | 14 +++++----- ...tack-protector-future-explicit-deny.stderr | 14 +++++----- ...ions-1-error.stack-protector-future.stderr | 14 +++++----- ...w-partial-mitigations-2-errors.both.stderr | 28 +++++++++---------- ....enable-separately-disable-together.stderr | 28 +++++++++---------- ....enable-together-disable-separately.stderr | 28 +++++++++---------- .../err-allow-partial-mitigations-2-errors.rs | 3 ++ ...ion.control-flow-2024-explicit-deny.stderr | 14 +++++----- ...low-partial-mitigations-current-edition.rs | 7 ++++- 15 files changed, 117 insertions(+), 106 deletions(-) diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.control-flow-guard-future-allow-reset-by-mitigation.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.control-flow-guard-future-allow-reset-by-mitigation.stderr index fa4b9a8c99f8c..1103e17a17f59 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.control-flow-guard-future-allow-reset-by-mitigation.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.control-flow-guard-future-allow-reset-by-mitigation.stderr @@ -1,5 +1,5 @@ error: your program uses the crate `std`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -8,7 +8,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `core`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -17,7 +17,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `alloc`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -26,7 +26,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `compiler_builtins`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -34,13 +34,13 @@ LL | fn main() {} = note: recompile `compiler_builtins` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` -error: your program uses the crate `libc`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 +error: your program uses the crate `unwind/libc`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ | - = note: recompile `libc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled + = note: recompile `unwind/libc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: aborting due to 5 previous errors diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.rs b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.rs index f87d40196d6e5..f4c5e56da53cb 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.rs +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.rs @@ -5,6 +5,9 @@ //@ ignore-wasm32-unknown-unknown stack protector is not supported //@ edition:future +// msvc has an extra unwind dependency of std, normalize it in the error messages +//@ normalize-stderr: "\b(unwind|libc)\b" -> "unwind/libc" + // test that stack-protector is denied-partial in edition=future //@ [stack-protector-future] compile-flags: -Z unstable-options -Z stack-protector=all diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-allow-then-deny.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-allow-then-deny.stderr index 3565173435b53..3fde64abb2f36 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-allow-then-deny.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-allow-then-deny.stderr @@ -1,5 +1,5 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -8,7 +8,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -17,7 +17,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -26,7 +26,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -34,13 +34,13 @@ LL | fn main() {} = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` -error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 +error: your program uses the crate `unwind/libc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ | - = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = note: recompile `unwind/libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: aborting due to 5 previous errors diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-but-allow-control-flow-guard.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-but-allow-control-flow-guard.stderr index 3565173435b53..3fde64abb2f36 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-but-allow-control-flow-guard.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-but-allow-control-flow-guard.stderr @@ -1,5 +1,5 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -8,7 +8,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -17,7 +17,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -26,7 +26,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -34,13 +34,13 @@ LL | fn main() {} = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` -error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 +error: your program uses the crate `unwind/libc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ | - = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = note: recompile `unwind/libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: aborting due to 5 previous errors diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-allow-reset-by-mitigation.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-allow-reset-by-mitigation.stderr index 3565173435b53..3fde64abb2f36 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-allow-reset-by-mitigation.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-allow-reset-by-mitigation.stderr @@ -1,5 +1,5 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -8,7 +8,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -17,7 +17,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -26,7 +26,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -34,13 +34,13 @@ LL | fn main() {} = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` -error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 +error: your program uses the crate `unwind/libc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ | - = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = note: recompile `unwind/libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: aborting due to 5 previous errors diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-deny-allow-reset-by-mitigation.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-deny-allow-reset-by-mitigation.stderr index 3565173435b53..3fde64abb2f36 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-deny-allow-reset-by-mitigation.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-deny-allow-reset-by-mitigation.stderr @@ -1,5 +1,5 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -8,7 +8,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -17,7 +17,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -26,7 +26,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -34,13 +34,13 @@ LL | fn main() {} = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` -error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 +error: your program uses the crate `unwind/libc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ | - = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = note: recompile `unwind/libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: aborting due to 5 previous errors diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-deny-reset-by-mitigation.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-deny-reset-by-mitigation.stderr index 3565173435b53..3fde64abb2f36 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-deny-reset-by-mitigation.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-deny-reset-by-mitigation.stderr @@ -1,5 +1,5 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -8,7 +8,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -17,7 +17,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -26,7 +26,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -34,13 +34,13 @@ LL | fn main() {} = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` -error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 +error: your program uses the crate `unwind/libc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ | - = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = note: recompile `unwind/libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: aborting due to 5 previous errors diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-explicit-deny.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-explicit-deny.stderr index 3565173435b53..3fde64abb2f36 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-explicit-deny.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future-explicit-deny.stderr @@ -1,5 +1,5 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -8,7 +8,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -17,7 +17,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -26,7 +26,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -34,13 +34,13 @@ LL | fn main() {} = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` -error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 +error: your program uses the crate `unwind/libc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ | - = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = note: recompile `unwind/libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: aborting due to 5 previous errors diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future.stderr index 3565173435b53..3fde64abb2f36 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-1-error.stack-protector-future.stderr @@ -1,5 +1,5 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -8,7 +8,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -17,7 +17,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -26,7 +26,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ @@ -34,13 +34,13 @@ LL | fn main() {} = note: recompile `compiler_builtins` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` -error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-1-error.rs:34:1 +error: your program uses the crate `unwind/libc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-1-error.rs:37:1 | LL | fn main() {} | ^ | - = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = note: recompile `unwind/libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: aborting due to 5 previous errors diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.both.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.both.stderr index 98029972ea19c..acc9dd234c693 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.both.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.both.stderr @@ -1,5 +1,5 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ @@ -8,7 +8,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `std`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ @@ -17,7 +17,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ @@ -26,7 +26,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ @@ -35,7 +35,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ @@ -44,7 +44,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ @@ -53,7 +53,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ @@ -62,7 +62,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ @@ -70,22 +70,22 @@ LL | fn main() {} = note: recompile `compiler_builtins` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` -error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 +error: your program uses the crate `unwind/libc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ | - = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = note: recompile `unwind/libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` -error: your program uses the crate `libc`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 +error: your program uses the crate `unwind/libc`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ | - = note: recompile `libc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled + = note: recompile `unwind/libc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: aborting due to 10 previous errors diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.enable-separately-disable-together.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.enable-separately-disable-together.stderr index 98029972ea19c..acc9dd234c693 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.enable-separately-disable-together.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.enable-separately-disable-together.stderr @@ -1,5 +1,5 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ @@ -8,7 +8,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `std`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ @@ -17,7 +17,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ @@ -26,7 +26,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ @@ -35,7 +35,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ @@ -44,7 +44,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ @@ -53,7 +53,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ @@ -62,7 +62,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ @@ -70,22 +70,22 @@ LL | fn main() {} = note: recompile `compiler_builtins` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` -error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 +error: your program uses the crate `unwind/libc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ | - = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = note: recompile `unwind/libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` -error: your program uses the crate `libc`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 +error: your program uses the crate `unwind/libc`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ | - = note: recompile `libc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled + = note: recompile `unwind/libc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: aborting due to 10 previous errors diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.enable-together-disable-separately.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.enable-together-disable-separately.stderr index 98029972ea19c..acc9dd234c693 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.enable-together-disable-separately.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.enable-together-disable-separately.stderr @@ -1,5 +1,5 @@ error: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ @@ -8,7 +8,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `std`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ @@ -17,7 +17,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `core`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ @@ -26,7 +26,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `core`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ @@ -35,7 +35,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `alloc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ @@ -44,7 +44,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `alloc`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ @@ -53,7 +53,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `compiler_builtins`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ @@ -62,7 +62,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` error: your program uses the crate `compiler_builtins`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ @@ -70,22 +70,22 @@ LL | fn main() {} = note: recompile `compiler_builtins` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` -error: your program uses the crate `libc`, that is not compiled with `stack-protector=all` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 +error: your program uses the crate `unwind/libc`, that is not compiled with `stack-protector=all` enabled + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ | - = note: recompile `libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled + = note: recompile `unwind/libc` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector` -error: your program uses the crate `libc`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-2-errors.rs:18:1 +error: your program uses the crate `unwind/libc`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations-2-errors.rs:21:1 | LL | fn main() {} | ^ | - = note: recompile `libc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled + = note: recompile `unwind/libc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: aborting due to 10 previous errors diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.rs b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.rs index 88809892c8af4..a1c7eba08ebec 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.rs +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-2-errors.rs @@ -5,6 +5,9 @@ //@ ignore-wasm32-unknown-unknown stack protector is not supported //@ edition:future +// msvc has an extra unwind dependency of std, normalize it in the error messages +//@ normalize-stderr: "\b(unwind|libc)\b" -> "unwind/libc" + // just use 2 partial mitigations, without any allow/deny flag. Should be denied at edition=future. //@ [both] compile-flags: -Z unstable-options -C control-flow-guard=on -Z stack-protector=all diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.control-flow-2024-explicit-deny.stderr b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.control-flow-2024-explicit-deny.stderr index 7940f3f907d3b..8f19f30d76569 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.control-flow-2024-explicit-deny.stderr +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.control-flow-2024-explicit-deny.stderr @@ -1,5 +1,5 @@ error: your program uses the crate `std`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-current-edition.rs:13:1 + --> $DIR/err-allow-partial-mitigations-current-edition.rs:18:1 | LL | fn main() {} | ^ @@ -8,7 +8,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `core`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-current-edition.rs:13:1 + --> $DIR/err-allow-partial-mitigations-current-edition.rs:18:1 | LL | fn main() {} | ^ @@ -17,7 +17,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `alloc`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-current-edition.rs:13:1 + --> $DIR/err-allow-partial-mitigations-current-edition.rs:18:1 | LL | fn main() {} | ^ @@ -26,7 +26,7 @@ LL | fn main() {} = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: your program uses the crate `compiler_builtins`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-current-edition.rs:13:1 + --> $DIR/err-allow-partial-mitigations-current-edition.rs:18:1 | LL | fn main() {} | ^ @@ -34,13 +34,13 @@ LL | fn main() {} = note: recompile `compiler_builtins` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` -error: your program uses the crate `libc`, that is not compiled with `control-flow-guard` enabled - --> $DIR/err-allow-partial-mitigations-current-edition.rs:13:1 +error: your program uses the crate `unwind/libc`, that is not compiled with `control-flow-guard` enabled + --> $DIR/err-allow-partial-mitigations-current-edition.rs:18:1 | LL | fn main() {} | ^ | - = note: recompile `libc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled + = note: recompile `unwind/libc` with `control-flow-guard` enabled, or use `-Z allow-partial-mitigations=control-flow-guard` to allow creating an artifact that has the mitigation partially enabled = help: it is possible to disable `-Z allow-partial-mitigations=control-flow-guard` via `-Z deny-partial-mitigations=control-flow-guard` error: aborting due to 5 previous errors diff --git a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.rs b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.rs index 4f5acb0280d0b..fd3ff94923539 100644 --- a/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.rs +++ b/tests/ui/allow-partial-mitigations/err-allow-partial-mitigations-current-edition.rs @@ -4,12 +4,17 @@ //@ ignore-nvptx64 stack protector is not supported //@ ignore-wasm32-unknown-unknown stack protector is not supported //@ edition: 2024 -//@ [control-flow-2024-explicit-deny] compile-flags: -C control-flow-guard=on -Z deny-partial-mitigations=control-flow-guard + +// msvc has an extra unwind dependency of std, normalize it in the error messages +//@ normalize-stderr: "\b(unwind|libc)\b" -> "unwind/libc" // check that in edition 2024, it is still possible to explicitly // disallow partial mitigations (in edition=future, they are // disallowed by default) +//@ [control-flow-2024-explicit-deny] compile-flags: -C control-flow-guard=on -Z deny-partial-mitigations=control-flow-guard + + fn main() {} //~^ ERROR that is not compiled with //~| ERROR that is not compiled with