Auto merge of #128118 - saethlin:closures-can-be-shared, r=<try>

Don't add inlinehint to big closures

In an unoptimized incremental build we want as many items as possible to be lowered as GloballyShared, but right now monomorphization makes whole classes of instances all LocalCopy without inspecting the instance's MIR or the session settings.

Right now I'm experimenting to see what kind of an impact this can have. I think there's a pretty core design flaw currently because we make monomorphization decisions about Instances, but `cross_crate_inlinable` takes a DefId.

r? `@ghost`

Author: bors

compiler/rustc_codegen_llvm/src/attributes.rs

@@ -348,12 +348,14 @@ pub fn from_fn_attrs<'ll, 'tcx>(
         OptimizeAttr::Speed => {}
     }
 
-    let inline =
-        if codegen_fn_attrs.inline == InlineAttr::None && instance.def.requires_inline(cx.tcx) {
-            InlineAttr::Hint
-        } else {
-            codegen_fn_attrs.inline
-        };
+    let inline = if codegen_fn_attrs.inline == InlineAttr::None
+        && (cx.tcx.cross_crate_inlinable(instance.def_id())
+            || matches!(instance.def, rustc_middle::ty::InstanceKind::CloneShim(..)))
+    {
+        InlineAttr::Hint
+    } else {
+        codegen_fn_attrs.inline
+    };
     to_add.extend(inline_attr(cx, inline));
 
     // The `uwtable` attribute according to LLVM is:

compiler/rustc_middle/src/ty/instance.rs

@@ -300,10 +300,7 @@ impl<'tcx> InstanceKind<'tcx> {
             ty::InstanceKind::ThreadLocalShim(_) => return false,
             _ => return true,
         };
-        matches!(
-            tcx.def_key(def_id).disambiguated_data.data,
-            DefPathData::Ctor | DefPathData::Closure
-        )
+        matches!(tcx.def_key(def_id).disambiguated_data.data, DefPathData::Ctor)
     }
 
     /// Returns `true` if the machine code for this instance is instantiated in

compiler/rustc_mir_transform/src/cross_crate_inline.rs

@@ -25,8 +25,8 @@ fn cross_crate_inlinable(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
 
     // This just reproduces the logic from Instance::requires_inline.
     match tcx.def_kind(def_id) {
-        DefKind::Ctor(..) | DefKind::Closure => return true,
-        DefKind::Fn | DefKind::AssocFn => {}
+        DefKind::Ctor(..) => return true,
+        DefKind::Fn | DefKind::AssocFn | DefKind::Closure => {}
         _ => return false,
     }
 

tests/coverage/closure.cov-map

@@ -31,18 +31,16 @@ Number of file 0 mappings: 24
     = (c0 - c1)
 - Code(Counter(0)) at (prev + 1, 5) to (start + 3, 2)
 
-Function name: closure::main::{closure#0}
-Raw bytes (26): 0x[01, 01, 01, 01, 05, 04, 01, 28, 05, 02, 14, 05, 02, 15, 02, 0a, 02, 02, 0a, 00, 0b, 01, 01, 09, 01, 06]
+Function name: closure::main::{closure#0} (unused)
+Raw bytes (24): 0x[01, 01, 00, 04, 00, 28, 05, 02, 14, 00, 02, 15, 02, 0a, 00, 02, 0a, 00, 0b, 00, 01, 09, 01, 06]
 Number of files: 1
 - file 0 => global file 1
-Number of expressions: 1
-- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
+Number of expressions: 0
 Number of file 0 mappings: 4
-- Code(Counter(0)) at (prev + 40, 5) to (start + 2, 20)
-- Code(Counter(1)) at (prev + 2, 21) to (start + 2, 10)
-- Code(Expression(0, Sub)) at (prev + 2, 10) to (start + 0, 11)
-    = (c0 - c1)
-- Code(Counter(0)) at (prev + 1, 9) to (start + 1, 6)
+- Code(Zero) at (prev + 40, 5) to (start + 2, 20)
+- Code(Zero) at (prev + 2, 21) to (start + 2, 10)
+- Code(Zero) at (prev + 2, 10) to (start + 0, 11)
+- Code(Zero) at (prev + 1, 9) to (start + 1, 6)
 
 Function name: closure::main::{closure#10} (unused)
 Raw bytes (10): 0x[01, 01, 00, 01, 00, 9b, 01, 07, 00, 21]