Auto merge of rust-lang#128657 - clubby789:optimize-none, r=<try>

Add `#[optimize(none)]`

cc rust-lang#54882

This extends the `optimize` attribute to add `none`, which corresponds to the LLVM `OptimizeNone` attribute.

Not sure if an MCP is required for this, happy to file one if so.

Author: bors

compiler/rustc_attr/src/builtin.rs

@@ -53,13 +53,22 @@ pub enum InstructionSetAttr {
     ArmT32,
 }
 
-#[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
+#[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic, PartialEq, Eq)]
 pub enum OptimizeAttr {
+    /// `#[optimize(none)]`. This implies `#[inline(never)]`, required by LLVM
     None,
+    /// `#[optimize(speed)]`
     Speed,
+    /// `#[optimize(size)]`
     Size,
 }
 
+impl OptimizeAttr {
+    pub fn do_not_optimize(&self) -> bool {
+        matches!(*self, OptimizeAttr::None)
+    }
+}
+
 /// Represents the following attributes:
 ///
 /// - `#[stable]`

compiler/rustc_codegen_llvm/src/attributes.rs

@@ -337,22 +337,27 @@ pub fn llfn_attrs_from_instance<'ll, 'tcx>(
     let mut to_add = SmallVec::<[_; 16]>::new();
 
     match codegen_fn_attrs.optimize {
-        OptimizeAttr::None => {
+        None => {
             to_add.extend(default_optimisation_attrs(cx));
         }
-        OptimizeAttr::Size => {
+        Some(OptimizeAttr::None) => {
+            to_add.push(llvm::AttributeKind::OptimizeNone.create_attr(cx.llcx));
+        }
+        Some(OptimizeAttr::Size) => {
             to_add.push(llvm::AttributeKind::MinSize.create_attr(cx.llcx));
             to_add.push(llvm::AttributeKind::OptimizeForSize.create_attr(cx.llcx));
         }
-        OptimizeAttr::Speed => {}
+        Some(OptimizeAttr::Speed) => {}
     }
 
-    let inline =
-        if codegen_fn_attrs.inline == InlineAttr::None && instance.def.requires_inline(cx.tcx) {
-            InlineAttr::Hint
-        } else {
-            codegen_fn_attrs.inline
-        };
+    // `optnone` requires `noinline`
+    let inline = if codegen_fn_attrs.optimize == Some(OptimizeAttr::None) {
+        InlineAttr::Never
+    } else if codegen_fn_attrs.inline == InlineAttr::None && instance.def.requires_inline(cx.tcx) {
+        InlineAttr::Hint
+    } else {
+        codegen_fn_attrs.inline
+    };
     to_add.extend(inline_attr(cx, inline));
 
     // The `uwtable` attribute according to LLVM is:

compiler/rustc_codegen_ssa/src/base.rs

@@ -1024,8 +1024,8 @@ pub fn provide(providers: &mut Providers) {
         let any_for_speed = defids.items().any(|id| {
             let CodegenFnAttrs { optimize, .. } = tcx.codegen_fn_attrs(*id);
             match optimize {
-                attr::OptimizeAttr::None | attr::OptimizeAttr::Size => false,
-                attr::OptimizeAttr::Speed => true,
+                None | Some(attr::OptimizeAttr::None | attr::OptimizeAttr::Size) => false,
+                Some(attr::OptimizeAttr::Speed) => true,
             }
         });
 

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -559,7 +559,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
         }
     });
 
-    codegen_fn_attrs.optimize = attrs.iter().fold(OptimizeAttr::None, |ia, attr| {
+    codegen_fn_attrs.optimize = attrs.iter().fold(None, |ia, attr| {
         if !attr.has_name(sym::optimize) {
             return ia;
         }
@@ -573,14 +573,16 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                 inline_span = Some(attr.span);
                 if items.len() != 1 {
                     err(attr.span, "expected one argument");
-                    OptimizeAttr::None
+                    None
                 } else if list_contains_name(items, sym::size) {
-                    OptimizeAttr::Size
+                    Some(OptimizeAttr::Size)
                 } else if list_contains_name(items, sym::speed) {
-                    OptimizeAttr::Speed
+                    Some(OptimizeAttr::Speed)
+                } else if list_contains_name(items, sym::none) {
+                    Some(OptimizeAttr::None)
                 } else {
                     err(items[0].span(), "invalid argument");
-                    OptimizeAttr::None
+                    None
                 }
             }
             Some(MetaItemKind::NameValue(_)) => ia,

compiler/rustc_feature/src/builtin_attrs.rs

@@ -532,7 +532,7 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
     ),
     // RFC 2412
     gated!(
-        optimize, Normal, template!(List: "size|speed"), ErrorPreceding,
+        optimize, Normal, template!(List: "none|size|speed"), ErrorPreceding,
         EncodeCrossCrate::No, optimize_attribute, experimental!(optimize)
     ),
 

compiler/rustc_middle/src/middle/codegen_fn_attrs.rs

@@ -11,8 +11,8 @@ pub struct CodegenFnAttrs {
     pub flags: CodegenFnAttrFlags,
     /// Parsed representation of the `#[inline]` attribute
     pub inline: InlineAttr,
-    /// Parsed representation of the `#[optimize]` attribute
-    pub optimize: OptimizeAttr,
+    /// Parsed representation of the `#[optimize]` attribute if present
+    pub optimize: Option<OptimizeAttr>,
     /// The `#[export_name = "..."]` attribute, indicating a custom symbol a
     /// function should be exported under
     pub export_name: Option<Symbol>,
@@ -146,7 +146,7 @@ impl CodegenFnAttrs {
         CodegenFnAttrs {
             flags: CodegenFnAttrFlags::empty(),
             inline: InlineAttr::None,
-            optimize: OptimizeAttr::None,
+            optimize: None,
             export_name: None,
             link_name: None,
             link_ordinal: None,

compiler/rustc_middle/src/mir/mod.rs

@@ -153,6 +153,10 @@ pub trait MirPass<'tcx> {
         to_profiler_name(self.name())
     }
 
+    fn min_mir_opt_level(&self) -> usize {
+        0
+    }
+
     /// Returns `true` if this pass is enabled with the current combination of compiler flags.
     fn is_enabled(&self, _sess: &Session) -> bool {
         true
@@ -443,6 +447,8 @@ pub struct Body<'tcx> {
     /// If `-Cinstrument-coverage` is not active, or if an individual function
     /// is not eligible for coverage, then this should always be `None`.
     pub function_coverage_info: Option<Box<coverage::FunctionCoverageInfo>>,
+    // /// Whether optimization is disabled by `#[optimize(none)]`
+    // pub optimization_disabled: bool,
 }
 
 impl<'tcx> Body<'tcx> {

compiler/rustc_mir_transform/src/copy_prop.rs

@@ -19,6 +19,10 @@ use crate::ssa::SsaLocals;
 pub struct CopyProp;
 
 impl<'tcx> MirPass<'tcx> for CopyProp {
+    fn min_mir_opt_level(&self) -> usize {
+        1
+    }
+
     fn is_enabled(&self, sess: &rustc_session::Session) -> bool {
         sess.mir_opt_level() >= 1
     }

compiler/rustc_mir_transform/src/dataflow_const_prop.rs

@@ -28,6 +28,10 @@ const PLACE_LIMIT: usize = 100;
 pub struct DataflowConstProp;
 
 impl<'tcx> MirPass<'tcx> for DataflowConstProp {
+    fn min_mir_opt_level(&self) -> usize {
+        3
+    }
+
     fn is_enabled(&self, sess: &rustc_session::Session) -> bool {
         sess.mir_opt_level() >= 3
     }

compiler/rustc_mir_transform/src/dead_store_elimination.rs

@@ -140,6 +140,10 @@ impl<'tcx> MirPass<'tcx> for DeadStoreElimination {
         }
     }
 
+    fn min_mir_opt_level(&self) -> usize {
+        2
+    }
+
     fn is_enabled(&self, sess: &rustc_session::Session) -> bool {
         sess.mir_opt_level() >= 2
     }