@@ -467,6 +467,7 @@ pub(crate) fn default_optimisation_attrs<'ll>(
     sess: &Session,
 ) -> SmallVec<[&'ll Attribute; 2]> {
     let mut attrs = SmallVec::new();
+    // `s` and `z` request different attributes, which the objective cannot distinguish.
     match sess.opts.optimize {
         OptLevel::Size => {
             attrs.push(llvm::AttributeKind::OptimizeForSize.create_attr(cx.llcx));
 
@@ -121,6 +121,8 @@ pub(crate) fn create_target_machine(tcx: TyCtxt<'_>, mod_name: &str) -> OwnedTar
     target_machine_factory(tcx.sess, tcx.backend_optimization_level(()))(tcx.dcx(), config)
 }
 
+// LLVM expresses "optimize for size" as a sub-setting of a numeric level, and `s` and `z` differ
+// there, so this keeps matching `OptLevel`.
 fn to_llvm_opt_settings(cfg: config::OptLevel) -> (llvm::CodeGenOptLevel, llvm::CodeGenOptSize) {
     use self::config::OptLevel::*;
     match cfg {
@@ -592,8 +594,7 @@ pub(crate) unsafe fn llvm_optimize<'ll>(
         vectorize_slp = false;
         vectorize_loop = false;
     } else {
-        unroll_loops =
-            opt_level != config::OptLevel::Size && opt_level != config::OptLevel::SizeMin;
+        unroll_loops = opt_level.objective() != config::OptimizationObjective::Size;
         merge_functions = config.merge_functions;
         vectorize_slp = config.vectorize_slp;
         vectorize_loop = config.vectorize_loop;
 
@@ -407,6 +407,7 @@ impl<'a> GccLinker<'a> {
             self.link_arg(&arg);
         }
 
+        // This knob has no size setting: `s` and `z` both land on `O2`, as `More` does.
         let opt_level = match self.sess.opts.optimize {
             config::OptLevel::No => "O0",
             config::OptLevel::Less => "O1",
@@ -698,9 +699,7 @@ impl<'a> Linker for GccLinker<'a> {
 
         // GNU-style linkers support optimization with -O. GNU ld doesn't
         // need a numeric argument, but other linkers do.
-        if self.sess.opts.optimize == config::OptLevel::More
-            || self.sess.opts.optimize == config::OptLevel::Aggressive
-        {
+        if self.sess.optimization_objective() == config::OptimizationObjective::Speed {
             self.link_arg("-O1");
         }
     }
@@ -1021,7 +1020,7 @@ impl<'a> Linker for MsvcLinker<'a> {
         // MSVC's ICF (Identical COMDAT Folding) link optimization is
         // slow for Rust and thus we disable it by default when not in
         // optimization build.
-        if self.sess.opts.optimize != config::OptLevel::No {
+        if self.sess.optimization_objective() != config::OptimizationObjective::None {
             self.link_arg("/OPT:REF,ICF");
         } else {
             // It is necessary to specify NOICF here, because /OPT:REF
@@ -1249,7 +1248,7 @@ impl<'a> Linker for EmLinker<'a> {
     }
 
     fn optimize(&mut self) {
-        // Emscripten performs own optimizations
+        // Emscripten performs own optimizations.
         self.cc_arg(match self.sess.opts.optimize {
             OptLevel::No => "-O0",
             OptLevel::Less => "-O1",
 
@@ -23,7 +23,8 @@ use rustc_metadata::fs::copy_to_stdout;
 use rustc_middle::dep_graph::{WorkProduct, WorkProductMap};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::config::{
-    self, Lto, OptLevel, OutFileName, OutputFilenames, OutputType, Passes, SwitchWithOptPath,
+    self, Lto, OptLevel, OptimizationObjective, OutFileName, OutputFilenames, OutputType, Passes,
+    SwitchWithOptPath,
 };
 use rustc_session::{IncrCompSession, Session};
 use rustc_span::source_map::SourceMap;
@@ -228,10 +229,10 @@ impl ModuleConfig {
             no_builtins: no_builtins || sess.target.no_builtins,
 
             // Copy what clang does by turning on loop vectorization at O2 and
-            // slp vectorization at O3.
+            // slp vectorization at O3. SLP is not an objective question: only the
+            // highest level enables it.
             vectorize_loop: !sess.opts.cg.no_vectorize_loops
-                && (sess.opts.optimize == config::OptLevel::More
-                    || sess.opts.optimize == config::OptLevel::Aggressive),
+                && sess.optimization_objective() == OptimizationObjective::Speed,
             vectorize_slp: !sess.opts.cg.no_vectorize_slp
                 && sess.opts.optimize == config::OptLevel::Aggressive,
 
@@ -246,13 +247,10 @@ impl ModuleConfig {
             // O2 and O3) since it can be useful for reducing code size.
             merge_functions: match sess.merge_functions() {
                 MergeFunctions::Disabled => false,
-                MergeFunctions::Trampolines | MergeFunctions::Aliases => {
-                    use config::OptLevel::*;
-                    match sess.opts.optimize {
-                        Aggressive | More | SizeMin | Size => true,
-                        Less | No => false,
-                    }
-                }
+                MergeFunctions::Trampolines | MergeFunctions::Aliases => matches!(
+                    sess.optimization_objective(),
+                    OptimizationObjective::Speed | OptimizationObjective::Size
+                ),
             },
 
             emit_lifetime_markers: sess.emit_lifetime_markers(),
 
@@ -1219,23 +1219,19 @@ impl CrateInfo {
 
 pub(crate) fn provide(providers: &mut Providers) {
     providers.backend_optimization_level = |tcx, cratenum| {
-        let for_speed = match tcx.sess.opts.optimize {
-            // If globally no optimisation is done, #[optimize] has no effect.
-            //
-            // This is done because if we ended up "upgrading" to `-O2` here, we’d populate the
-            // pass manager and it is likely that some module-wide passes (such as inliner or
-            // cross-function constant propagation) would ignore the `optnone` annotation we put
-            // on the functions, thus necessarily involving these functions into optimisations.
-            config::OptLevel::No => return config::OptLevel::No,
-            // If globally optimise-speed is already specified, just use that level.
-            config::OptLevel::Less => return config::OptLevel::Less,
-            config::OptLevel::More => return config::OptLevel::More,
-            config::OptLevel::Aggressive => return config::OptLevel::Aggressive,
-            // If globally optimize-for-size has been requested, use -O2 instead (if optimize(size)
-            // are present).
-            config::OptLevel::Size => config::OptLevel::More,
-            config::OptLevel::SizeMin => config::OptLevel::More,
-        };
+        let global = tcx.sess.opts.optimize;
+
+        // The global level is the answer, except when a body asks for speed inside a size build.
+        // If globally no optimization is done, `#[optimize]` has no effect: upgrading to `-O2`
+        // here would populate the pass manager, and module-wide passes (such as inliner or
+        // cross-function constant propagation) would then ignore the `optnone` annotation we put
+        // on the functions.
+        if global.objective() != config::OptimizationObjective::Size {
+            return global;
+        }
+
+        // There is no "size level, but faster", so `-O2` is the lowest level fulfilling it.
+        let for_speed = config::OptLevel::More;
 
         let defids = tcx.collect_and_partition_mono_items(cratenum).all_mono_items;
 
@@ -1244,11 +1240,7 @@ pub(crate) fn provide(providers: &mut Providers) {
             matches!(optimize, OptimizeAttr::Speed)
         });
 
-        if any_for_speed {
-            return for_speed;
-        }
-
-        tcx.sess.opts.optimize
+        if any_for_speed { for_speed } else { global }
     };
 }
 
 
@@ -16,7 +16,7 @@ use rustc_middle::mir::*;
 use rustc_middle::ty::{
     self, Instance, InstanceKind, ShimKind, Ty, TyCtxt, TypeFlags, TypeVisitableExt, Unnormalized,
 };
-use rustc_session::config::{DebugInfo, OptLevel};
+use rustc_session::config::{DebugInfo, OptimizationObjective};
 use rustc_span::{Spanned, bug};
 use tracing::{debug, instrument, trace, trace_span};
 
@@ -44,20 +44,26 @@ pub struct Inline;
 
 impl<'tcx> crate::MirPass<'tcx> for Inline {
     fn policy(&self, ctx: &crate::PassCtx<'_>) -> PassPolicy {
-        match ctx.opts.unstable_opts.inline_mir {
-            Some(enabled) => PassPolicy::optional(enabled),
-            None => PassPolicy::optional(match ctx.mir_opt_level() {
-                0 | 1 => false,
-                // Only inline for `-Copt-level >= 2`, and don't inline
-                // in incremental mode to increase incremental effectiveness.
-                // FIXME: This should be cleaned up to not rely on inspecting the global opt level.
-                2 => {
-                    (ctx.opts.optimize == OptLevel::More
-                        || ctx.opts.optimize == OptLevel::Aggressive)
-                        && ctx.opts.incremental.is_none()
+        if let Some(o) = ctx.opts.unstable_opts.inline_mir {
+            return PassPolicy::optional(o);
+        }
+        // `#[optimize]` on a body may lower the pass but not raise it, hence the `min`.
+        match ctx.mir_opt_level().min(ctx.session_mir_opt_level()) {
+            0 | 1 => PassPolicy::optional(false),
+            // Don't inline in incremental mode: it hurts incremental effectiveness.
+            2 => {
+                if ctx.opts.incremental.is_some() {
+                    return PassPolicy::optional(false);
                 }
-                _ => true,
-            }),
+                match ctx.optimization_objective() {
+                    OptimizationObjective::Size => PassPolicy::size_only(),
+                    OptimizationObjective::Speed => PassPolicy::optional(true),
+                    OptimizationObjective::None | OptimizationObjective::Balanced => {
+                        PassPolicy::optional(false)
+                    }
+                }
+            }
+            _ => PassPolicy::optional(true),
         }
     }
 
 
@@ -8,7 +8,7 @@ use rustc_hir::def_id::DefId;
 use rustc_middle::mir::{Body, MirDumper, MirPhase, RuntimePhase};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
-use rustc_session::config::OptLevel;
+use rustc_session::config::{OptLevel, OptimizationObjective};
 use rustc_span::bug;
 use tracing::trace;
 
@@ -96,13 +96,31 @@ pub(crate) enum PassPolicy {
         /// Whether this pass should be enabled in the absence of an explicit
         /// `-Zmir-enable-passes` override.
         enabled_by_default: bool,
+        /// Whether this pass trades runtime speed for binary size, and so is enabled only when the
+        /// objective is size.
+        size_only: bool,
     },
 }
 
 impl PassPolicy {
     /// Create a [`PassPolicy::Optional`] enabled by default under the given condition.
     pub(crate) fn optional(enabled_by_default: bool) -> Self {
-        Self::Optional { enabled_by_default }
+        Self::Optional { enabled_by_default, size_only: false }
+    }
+
+    /// Create a [`PassPolicy::Optional`] that is enabled only when size is the objective.
+    pub(crate) fn size_only() -> Self {
+        Self::Optional { enabled_by_default: false, size_only: true }
+    }
+
+    fn runs_by_default(self, ctx: &PassCtx<'_>) -> bool {
+        match self {
+            PassPolicy::Required => true,
+            PassPolicy::Optional { enabled_by_default, size_only } => {
+                enabled_by_default
+                    || (size_only && ctx.optimization_objective() == OptimizationObjective::Size)
+            }
+        }
     }
 }
 
@@ -151,10 +169,18 @@ impl<'sess> PassCtx<'sess> {
         Self { session: tcx.sess, body_mir_opt_level }
     }
 
-    /// The effective MIR optimization level for this body, including `#[optimize]` overrides.
+    /// The MIR optimization level for this body, possibly overridden by `#[optimize]`.
+    ///
+    /// A pass deciding whether the compilation wants it should ask
+    /// [`session_mir_opt_level`](Self::session_mir_opt_level) instead.
     pub(super) fn mir_opt_level(&self) -> usize {
         self.body_mir_opt_level
     }
+
+    /// The compilation's MIR optimization level, ignoring this body's `#[optimize]` override.
+    pub(super) fn session_mir_opt_level(&self) -> usize {
+        self.session.mir_opt_level()
+    }
 }
 
 impl std::ops::Deref for PassCtx<'_> {
@@ -218,8 +244,9 @@ where
         let policy = self.1.policy(ctx);
         match policy {
             PassPolicy::Required => bug!("required pass cannot be gated by an opt level"),
-            PassPolicy::Optional { enabled_by_default } => PassPolicy::Optional {
+            PassPolicy::Optional { enabled_by_default, size_only } => PassPolicy::Optional {
                 enabled_by_default: enabled_by_default && ctx.mir_opt_level() >= self.0,
+                size_only,
             },
         }
     }
@@ -260,21 +287,26 @@ where
             .find_map(|(name_, polarity)| if name == name_ { Some(*polarity) } else { None })
     };
 
-    match pass.policy(ctx) {
-        PassPolicy::Required => true,
-        PassPolicy::Optional { enabled_by_default } => {
-            if let Some(o) = pass_override() {
-                trace!(
-                    pass = %name,
-                    "{} as requested by flag",
-                    if o { "Running" } else { "Not running" }
-                );
-                o
-            } else {
-                enabled_by_default
-            }
-        }
+    let policy = pass.policy(ctx);
+
+    // Only `Optional` passes consult `-Zmir-enable-passes`; `Required` ones implement MIR semantics
+    // and cannot be turned off.
+    if let PassPolicy::Optional { .. } = policy
+        && let Some(o) = pass_override()
+    {
+        trace!(
+            pass = %name,
+            "{} as requested by flag",
+            if o { "Running" } else { "Not running" }
+        );
+        return o;
+    }
+
+    let runs = policy.runs_by_default(ctx);
+    if !runs {
+        trace!(pass = %name, "Not running: not enabled by default for this body");
     }
+    runs
 }
 
 fn run_passes_inner<'tcx>(
 
@@ -126,6 +126,38 @@ impl OptLevel {
             _ => 2,
         }
     }
+
+    /// Maps a general opt-level onto the objective it is trying to achieve.
+    pub fn objective(&self) -> OptimizationObjective {
+        match self {
+            OptLevel::No => OptimizationObjective::None,
+            OptLevel::Less => OptimizationObjective::Balanced,
+            OptLevel::More | OptLevel::Aggressive => OptimizationObjective::Speed,
+            OptLevel::Size | OptLevel::SizeMin => OptimizationObjective::Size,
+        }
+    }
+}
+
+/// What a compilation, or a single item, is being asked to optimize *for*.
+///
+/// An [`OptLevel`] answers two questions at once: how much work to do, and what that work should
+/// achieve. `-Copt-level=s`/`z` are not below the numbered levels, they are a different objective
+/// that happens to be expressible as a level, so there is no order between [`Speed`] and [`Size`].
+/// Sites that map a level onto an LLVM or linker flag, where `s` and `z` produce *different* flags,
+/// still match on [`OptLevel`].
+///
+/// [`Speed`]: OptimizationObjective::Speed
+/// [`Size`]: OptimizationObjective::Size
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, StableHash)]
+pub enum OptimizationObjective {
+    /// Nothing is optimized, so there is no objective (`-Copt-level=0`).
+    None,
+    /// Optimize, without a strong preference for speed over size (`-Copt-level=1`).
+    Balanced,
+    /// Favor runtime speed over binary size (`-Copt-level=2`/`3`, `#[optimize(speed)]`).
+    Speed,
+    /// Favor binary size over runtime speed (`-Copt-level=s`/`z`, `#[optimize(size)]`).
+    Size,
 }
 
 /// This is what the `LtoCli` values get mapped to after resolving defaults and
@@ -1568,10 +1600,9 @@ impl Options {
     pub fn share_generics(&self) -> bool {
         match self.unstable_opts.share_generics {
             Some(setting) => setting,
-            None => match self.optimize {
-                OptLevel::No | OptLevel::Less | OptLevel::Size | OptLevel::SizeMin => true,
-                OptLevel::More | OptLevel::Aggressive => false,
-            },
+            // Sharing instantiations means fewer copies, at the cost of leaving them opaque to
+            // speed optimizations. That is a good trade unless speed is what is asked for.
+            None => self.optimize.objective() != OptimizationObjective::Speed,
         }
     }
 
 
@@ -983,6 +983,15 @@ impl Session {
         self.opts.unstable_opts.mir_opt_level.unwrap_or_else(|| self.opts.optimize.mir_opt_level())
     }
 
+    /// The objective this compilation is optimizing for. See
+    /// [`config::OptimizationObjective`].
+    ///
+    /// There is no `-Z` override for this, unlike [`Session::mir_opt_level`]: how much MIR
+    /// optimization is done is orthogonal to what it is optimizing for.
+    pub fn optimization_objective(&self) -> config::OptimizationObjective {
+        self.opts.optimize.objective()
+    }
+
     /// Calculates the flavor of LTO to use for this compilation.
     pub fn lto(&self) -> config::Lto {
         // If our target has codegen requirements ignore the command line