Mirrors/rust
1
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2026-04-27 18:57:42 +03:00
Code Issues Packages Projects Releases Wiki Activity

enforced => enforcable mitigation

Browse Source
This commit is contained in:
Ariel Ben-Yehuda
2025-12-07 12:14:23 +00:00
parent 51b2b93239
commit eb89ca9b77
7 changed files with 69 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/rustc_metadata/src/creader.rs
+6 -6
View File
@@ -25,7 +25,7 @@
use rustc_middle::ty::{TyCtxt, TyCtxtFeed};
use rustc_proc_macro::bridge::client::ProcMacro;
use rustc_session::Session;
use rustc_session::config::enforced_mitigations::EnforcedMitigationLevel;
use rustc_session::config::enforcable_mitigations::EnforcableMitigationLevel;
use rustc_session::config::{
CrateType, ExtendedTargetModifierInfo, ExternLocation, Externs, OptionsTargetModifiers,
TargetModifier,
@@ -468,7 +468,7 @@ fn report_target_modifiers_extended(
pub fn report_session_incompatibilities(&self, tcx: TyCtxt<'_>, krate: &Crate) {
self.report_incompatible_target_modifiers(tcx, krate);
self.report_incompatible_enforced_mitigations(tcx, krate);
self.report_incompatible_enforcable_mitigations(tcx, krate);
self.report_incompatible_async_drop_feature(tcx, krate);
}
@@ -493,8 +493,8 @@ pub fn report_incompatible_target_modifiers(&self, tcx: TyCtxt<'_>, krate: &Crat
}
}
pub fn report_incompatible_enforced_mitigations(&self, tcx: TyCtxt<'_>, krate: &Crate) {
let my_mitigations = tcx.sess.gather_enabled_enforced_mitigations();
pub fn report_incompatible_enforcable_mitigations(&self, tcx: TyCtxt<'_>, krate: &Crate) {
let my_mitigations = tcx.sess.gather_enabled_enforcable_mitigations();
let mut my_mitigations: BTreeMap<_, _> =
my_mitigations.iter().map(|mitigation| (mitigation.kind, mitigation)).collect();
for skipped_mitigation in tcx.sess.opts.allowed_partial_mitigations(tcx.sess.edition()) {
@@ -506,12 +506,12 @@ pub fn report_incompatible_enforced_mitigations(&self, tcx: TyCtxt<'_>, krate: &
if data.is_proc_macro_crate() {
continue;
}
let their_mitigations = data.enforced_mitigations();
let their_mitigations = data.enabled_enforcable_mitigations();
for my_mitigation in my_mitigations.values() {
let their_mitigation = their_mitigations
.iter()
.find(|mitigation| mitigation.kind == my_mitigation.kind)
.map_or(EnforcedMitigationLevel::Enabled(false), |m| m.level);
.map_or(EnforcableMitigationLevel::Enabled(false), |m| m.level);
if their_mitigation < my_mitigation.level {
let errors = errors_per_mitigation.entry(my_mitigation.kind).or_insert(0);
if *errors >= MAX_ERRORS_PER_MITIGATION {
compiler/rustc_metadata/src/rmeta/decoder.rs
+8 -8
View File
@@ -30,7 +30,7 @@
use rustc_serialize::opaque::MemDecoder;
use rustc_serialize::{Decodable, Decoder};
use rustc_session::config::TargetModifier;
use rustc_session::config::enforced_mitigations::EnforcedMitigation;
use rustc_session::config::enforcable_mitigations::EnforcableMitigation;
use rustc_session::cstore::{CrateSource, ExternCrate};
use rustc_span::hygiene::HygieneDecodeContext;
use rustc_span::{
@@ -82,8 +82,8 @@ pub(crate) fn bytes(&self) -> &OwnedSlice {
/// Target modifiers - abi or exploit mitigations flags that cause unsoundness when mixed
pub(crate) type TargetModifiers = Vec<TargetModifier>;
/// Enforced Mitigations
pub(crate) type EnforcedMitigations = Vec<EnforcedMitigation>;
/// The set of enforcable mitigations (RFC 3855) that are currently enabled for this crate
pub(crate) type EnforcableMitigations = Vec<EnforcableMitigation>;
pub(crate) struct CrateMetadata {
/// The primary crate data - binary metadata blob.
@@ -964,11 +964,11 @@ pub(crate) fn decode_target_modifiers<'a>(
self.target_modifiers.decode(metadata)
}
pub(crate) fn decode_enforced_mitigations<'a>(
pub(crate) fn decode_enforcable_mitigations<'a>(
&self,
metadata: &'a MetadataBlob,
) -> impl ExactSizeIterator<Item = EnforcedMitigation> {
self.enforced_mitigations.decode(metadata)
) -> impl ExactSizeIterator<Item = EnforcableMitigation> {
self.enforcable_mitigations.decode(metadata)
}
}
@@ -1952,8 +1952,8 @@ pub(crate) fn target_modifiers(&self) -> TargetModifiers {
self.root.decode_target_modifiers(&self.blob).collect()
}
pub(crate) fn enforced_mitigations(&self) -> EnforcedMitigations {
self.root.decode_enforced_mitigations(&self.blob).collect()
pub(crate) fn enabled_enforcable_mitigations(&self) -> EnforcableMitigations {
self.root.decode_enforcable_mitigations(&self.blob).collect()
}
/// Keep `new_extern_crate` if it looks better in diagnostics
compiler/rustc_metadata/src/rmeta/encoder.rs
+6 -6
View File
@@ -27,7 +27,7 @@
use rustc_middle::ty::fast_reject::{self, TreatParams};
use rustc_middle::{bug, span_bug};
use rustc_serialize::{Decodable, Decoder, Encodable, Encoder, opaque};
use rustc_session::config::enforced_mitigations::EnforcedMitigation;
use rustc_session::config::enforcable_mitigations::EnforcableMitigation;
use rustc_session::config::{CrateType, OptLevel, TargetModifier};
use rustc_span::hygiene::HygieneEncodeContext;
use rustc_span::{
@@ -716,8 +716,8 @@ macro_rules! stat {
// `SourceFiles` we actually need to encode.
let source_map = stat!("source-map", || self.encode_source_map());
let target_modifiers = stat!("target-modifiers", || self.encode_target_modifiers());
let enforced_mitigations =
stat!("enforced-mitigations", || self.encode_enforced_mitigations());
let enforcable_mitigations =
stat!("enforced-mitigations", || self.encode_enabled_enforcable_mitigations());
let root = stat!("final", || {
let attrs = tcx.hir_krate_attrs();
@@ -761,7 +761,7 @@ macro_rules! stat {
foreign_modules,
source_map,
target_modifiers,
enforced_mitigations,
enforcable_mitigations,
traits,
impls,
incoherent_impls,
@@ -2108,10 +2108,10 @@ fn encode_target_modifiers(&mut self) -> LazyArray<TargetModifier> {
self.lazy_array(tcx.sess.opts.gather_target_modifiers())
}
fn encode_enforced_mitigations(&mut self) -> LazyArray<EnforcedMitigation> {
fn encode_enabled_enforcable_mitigations(&mut self) -> LazyArray<EnforcableMitigation> {
empty_proc_macro!(self);
let tcx = self.tcx;
self.lazy_array(tcx.sess.gather_enabled_enforced_mitigations())
self.lazy_array(tcx.sess.gather_enabled_enforcable_mitigations())
}
fn encode_lib_features(&mut self) -> LazyArray<(Symbol, FeatureStability)> {
compiler/rustc_metadata/src/rmeta/mod.rs
+2 -2
View File
@@ -36,7 +36,7 @@
use rustc_middle::ty::{self, Ty, TyCtxt};
use rustc_middle::util::Providers;
use rustc_serialize::opaque::FileEncoder;
use rustc_session::config::enforced_mitigations::EnforcedMitigation;
use rustc_session::config::enforcable_mitigations::EnforcableMitigation;
use rustc_session::config::{SymbolManglingVersion, TargetModifier};
use rustc_session::cstore::{CrateDepKind, ForeignModule, LinkagePreference, NativeLib};
use rustc_span::edition::Edition;
@@ -287,7 +287,7 @@ pub(crate) struct CrateRoot {
source_map: LazyTable<u32, Option<LazyValue<rustc_span::SourceFile>>>,
target_modifiers: LazyArray<TargetModifier>,
enforced_mitigations: LazyArray<EnforcedMitigation>,
enforcable_mitigations: LazyArray<EnforcableMitigation>,
compiler_builtins: bool,
needs_allocator: bool,
compiler/rustc_metadata/src/rmeta/parameterized.rs
+1 -1
View File
@@ -120,7 +120,7 @@ impl ParameterizedOverTcx for $ty {
rustc_middle::ty::adjustment::CoerceUnsizedInfo,
rustc_middle::ty::fast_reject::SimplifiedType,
rustc_session::config::TargetModifier,
rustc_session::config::enforced_mitigations::EnforcedMitigation,
rustc_session::config::enforcable_mitigations::EnforcableMitigation,
rustc_session::cstore::ForeignModule,
rustc_session::cstore::LinkagePreference,
rustc_session::cstore::NativeLib,
compiler/rustc_session/src/options.rs
+4 -8
View File
@@ -20,7 +20,7 @@
TargetTuple, TlsModel,
};
use crate::config::enforced_mitigations::MitigationEnablement;
use crate::config::enforcable_mitigations::MitigationEnablement;
use crate::config::*;
use crate::search_paths::SearchPath;
use crate::utils::NativeLib;
@@ -85,7 +85,7 @@ pub struct TargetModifier {
pub value_name: String,
}
pub mod enforced_mitigations;
pub mod enforcable_mitigations;
mod target_modifier_consistency_check {
use super::*;
@@ -891,20 +891,16 @@ mod desc {
pub(crate) const parse_mir_include_spans: &str =
"either a boolean (`yes`, `no`, `on`, `off`, etc), or `nll` (default: `nll`)";
pub(crate) const parse_align: &str = "a number that is a power of 2 between 1 and 2^29";
<<<<<<< HEAD
pub(crate) const parse_assert_incr_state: &str = "one of: `loaded`, `not-loaded`";
pub(crate) const parse_allow_partial_mitigations: &str = super::EnforcedMitigationKind::KINDS;
=======
pub(crate) const parse_allow_partial_mitigations: &str =
super::enforced_mitigations::EnforcedMitigationKind::KINDS;
>>>>>>> be3a932517e (address review comments)
super::enforcable_mitigations::EnforcableMitigationKind::KINDS;
}
pub mod parse {
use std::str::FromStr;
pub(crate) use super::*;
use crate::config::enforced_mitigations::MitigationEnablement;
use crate::config::enforcable_mitigations::MitigationEnablement;
pub(crate) const MAX_THREADS_CAP: usize = 256;
/// Ignore the value. Used for removed options where we don't actually want to store
compiler/rustc_session/src/options/enforced_mitigations.rs → compiler/rustc_session/src/options/enforcable_mitigations.rs
+42 -42
View File
@@ -10,66 +10,66 @@
use crate::options::CFGuard;
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Encodable, BlobDecodable)]
pub enum EnforcedMitigationLevel {
pub enum EnforcableMitigationLevel {
// Enabled(false) should be the bottom of the Ord hierarchy
Enabled(bool),
StackProtector(StackProtector),
}
impl EnforcedMitigationLevel {
impl EnforcableMitigationLevel {
pub fn level_str(&self) -> &'static str {
match self {
EnforcedMitigationLevel::StackProtector(StackProtector::All) => "=all",
EnforcedMitigationLevel::StackProtector(StackProtector::Basic) => "=basic",
EnforcedMitigationLevel::StackProtector(StackProtector::Strong) => "=strong",
EnforcableMitigationLevel::StackProtector(StackProtector::All) => "=all",
EnforcableMitigationLevel::StackProtector(StackProtector::Basic) => "=basic",
EnforcableMitigationLevel::StackProtector(StackProtector::Strong) => "=strong",
// currently `=disabled` should not appear
EnforcedMitigationLevel::Enabled(false) => "=disabled",
EnforcedMitigationLevel::StackProtector(StackProtector::None)
| EnforcedMitigationLevel::Enabled(true) => "",
EnforcableMitigationLevel::Enabled(false) => "=disabled",
EnforcableMitigationLevel::StackProtector(StackProtector::None)
| EnforcableMitigationLevel::Enabled(true) => "",
}
}
}
impl std::fmt::Display for EnforcedMitigationLevel {
impl std::fmt::Display for EnforcableMitigationLevel {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
EnforcedMitigationLevel::StackProtector(StackProtector::All) => {
EnforcableMitigationLevel::StackProtector(StackProtector::All) => {
write!(f, "all")
}
EnforcedMitigationLevel::StackProtector(StackProtector::Basic) => {
EnforcableMitigationLevel::StackProtector(StackProtector::Basic) => {
write!(f, "basic")
}
EnforcedMitigationLevel::StackProtector(StackProtector::Strong) => {
EnforcableMitigationLevel::StackProtector(StackProtector::Strong) => {
write!(f, "strong")
}
EnforcedMitigationLevel::Enabled(true) => {
EnforcableMitigationLevel::Enabled(true) => {
write!(f, "enabled")
}
EnforcedMitigationLevel::StackProtector(StackProtector::None)
| EnforcedMitigationLevel::Enabled(false) => {
EnforcableMitigationLevel::StackProtector(StackProtector::None)
| EnforcableMitigationLevel::Enabled(false) => {
write!(f, "disabled")
}
}
}
}
impl From<bool> for EnforcedMitigationLevel {
impl From<bool> for EnforcableMitigationLevel {
fn from(value: bool) -> Self {
EnforcedMitigationLevel::Enabled(value)
EnforcableMitigationLevel::Enabled(value)
}
}
impl From<StackProtector> for EnforcedMitigationLevel {
impl From<StackProtector> for EnforcableMitigationLevel {
fn from(value: StackProtector) -> Self {
EnforcedMitigationLevel::StackProtector(value)
EnforcableMitigationLevel::StackProtector(value)
}
}
pub struct EnforcedMitigationKindParseError;
pub struct EnforcableMitigationKindParseError;
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Encodable, BlobDecodable)]
pub struct MitigationEnablement {
pub kind: EnforcedMitigationKind,
pub kind: EnforcableMitigationKind,
pub enabled: bool,
}
@@ -82,58 +82,58 @@ macro_rules! intersperse {
macro_rules! enforced_mitigations {
([$self:ident] enum $kind:ident {$(($name:ident, $text:expr, $since:ident, $code:expr)),*}) => {
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Encodable, BlobDecodable)]
pub enum EnforcedMitigationKind {
pub enum EnforcableMitigationKind {
$($name),*
}
impl std::fmt::Display for EnforcedMitigationKind {
impl std::fmt::Display for EnforcableMitigationKind {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
$(EnforcedMitigationKind::$name => write!(f, $text)),*
$(EnforcableMitigationKind::$name => write!(f, $text)),*
}
}
}
impl EnforcedMitigationKind {
impl EnforcableMitigationKind {
pub(crate) const KINDS: &'static str = concat!("comma-separated list of mitigation kinds (available: ",
intersperse!(", ", ($(concat!("`", $text, "`")),*)), ")");
}
impl FromStr for EnforcedMitigationKind {
type Err = EnforcedMitigationKindParseError;
impl FromStr for EnforcableMitigationKind {
type Err = EnforcableMitigationKindParseError;
fn from_str(v: &str) -> Result<EnforcedMitigationKind, EnforcedMitigationKindParseError> {
fn from_str(v: &str) -> Result<EnforcableMitigationKind, EnforcableMitigationKindParseError> {
match v {
$($text => Ok(EnforcedMitigationKind::$name)),*
$($text => Ok(EnforcableMitigationKind::$name)),*
,
_ => Err(EnforcedMitigationKindParseError),
_ => Err(EnforcableMitigationKindParseError),
}
}
}
#[allow(unused)]
impl EnforcedMitigationKind {
impl EnforcableMitigationKind {
pub fn enforced_since(&self) -> Edition {
match self {
// Should change the enforced-since edition of StackProtector to 2015
// (all editions) when `-C stack-protector` is stabilized.
$(EnforcedMitigationKind::$name => Edition::$since),*
$(EnforcableMitigationKind::$name => Edition::$since),*
}
}
}
impl Options {
pub fn all_enforced_mitigations(&self) -> impl Iterator<Item = EnforcedMitigationKind> {
[$(EnforcedMitigationKind::$name),*].into_iter()
pub fn all_enforced_mitigations(&self) -> impl Iterator<Item = EnforcableMitigationKind> {
[$(EnforcableMitigationKind::$name),*].into_iter()
}
}
impl Session {
pub fn gather_enabled_enforced_mitigations(&$self) -> Vec<EnforcedMitigation> {
pub fn gather_enabled_enforcable_mitigations(&$self) -> Vec<EnforcableMitigation> {
let mut mitigations = [
$(
EnforcedMitigation {
kind: EnforcedMitigationKind::$name,
EnforcableMitigation {
kind: EnforcableMitigationKind::$name,
level: From::from($code),
}
),*
@@ -147,7 +147,7 @@ pub fn gather_enabled_enforced_mitigations(&$self) -> Vec<EnforcedMitigation> {
enforced_mitigations! {
[self]
enum EnforcedMitigationKind {
enum EnforcableMitigationKind {
(StackProtector, "stack-protector", EditionFuture, self.stack_protector()),
(ControlFlowGuard, "control-flow-guard", EditionFuture, self.opts.cg.control_flow_guard == CFGuard::Checks)
}
@@ -155,9 +155,9 @@ enum EnforcedMitigationKind {
/// Enforced mitigations, see [RFC 3855](https://github.com/rust-lang/rfcs/pull/3855)
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Encodable, BlobDecodable)]
pub struct EnforcedMitigation {
pub kind: EnforcedMitigationKind,
pub level: EnforcedMitigationLevel,
pub struct EnforcableMitigation {
pub kind: EnforcableMitigationKind,
pub level: EnforcableMitigationLevel,
}
impl Options {
@@ -165,7 +165,7 @@ impl Options {
pub fn allowed_partial_mitigations(
&self,
edition: Edition,
) -> impl Iterator<Item = EnforcedMitigationKind> {
) -> impl Iterator<Item = EnforcableMitigationKind> {
let mut result: BTreeSet<_> = self
.all_enforced_mitigations()
.filter(|mitigation| mitigation.enforced_since() > edition)