Cleanup CodegenFnAttrFlags

Noratrieb · Noratrieb · commit fa2bb599bcf3 · 2025-05-24T20:31:37.000+02:00
- Rename `USED` to `USED_COMPILER` to better reflect its behavior.
- Reorder some items to group the used and allocator flags together
- Renumber them without gaps
diff --git a/compiler/rustc_codegen_gcc/src/consts.rs b/compiler/rustc_codegen_gcc/src/consts.rs
@@ -154,7 +154,7 @@ impl<'gcc, 'tcx> StaticCodegenMethods for CodegenCx<'gcc, 'tcx> {
             // TODO(antoyo): set link section.
         }
 
-        if attrs.flags.contains(CodegenFnAttrFlags::USED)
+        if attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER)
             || attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER)
         {
             self.add_used_global(global.to_rvalue());
diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs
@@ -527,7 +527,7 @@ impl<'ll> CodegenCx<'ll, '_> {
 
             base::set_variable_sanitizer_attrs(g, attrs);
 
-            if attrs.flags.contains(CodegenFnAttrFlags::USED) {
+            if attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER) {
                 // `USED` and `USED_LINKER` can't be used together.
                 assert!(!attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER));
 
@@ -551,7 +551,7 @@ impl<'ll> CodegenCx<'ll, '_> {
             }
             if attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER) {
                 // `USED` and `USED_LINKER` can't be used together.
-                assert!(!attrs.flags.contains(CodegenFnAttrFlags::USED));
+                assert!(!attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER));
 
                 self.add_used_global(g);
             }
diff --git a/compiler/rustc_codegen_ssa/src/back/symbol_export.rs b/compiler/rustc_codegen_ssa/src/back/symbol_export.rs
@@ -128,7 +128,7 @@ fn reachable_non_generics_provider(tcx: TyCtxt<'_>, _: LocalCrate) -> DefIdMap<S
                 } else {
                     SymbolExportKind::Text
                 },
-                used: codegen_attrs.flags.contains(CodegenFnAttrFlags::USED)
+                used: codegen_attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER)
                     || codegen_attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER)
                     || used,
             };
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -189,7 +189,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                             )
                             .emit();
                         }
-                        codegen_fn_attrs.flags |= CodegenFnAttrFlags::USED;
+                        codegen_fn_attrs.flags |= CodegenFnAttrFlags::USED_COMPILER;
                     }
                     Some(_) => {
                         tcx.dcx().emit_err(errors::ExpectedUsedSymbol { span: attr.span() });
@@ -220,7 +220,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                             || tcx.sess.target.is_like_windows
                             || tcx.sess.target.is_like_wasm);
                         codegen_fn_attrs.flags |= if is_like_elf {
-                            CodegenFnAttrFlags::USED
+                            CodegenFnAttrFlags::USED_COMPILER
                         } else {
                             CodegenFnAttrFlags::USED_LINKER
                         };
diff --git a/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs b/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
@@ -96,49 +96,46 @@ bitflags::bitflags! {
         /// `#[cold]`: a hint to LLVM that this function, when called, is never on
         /// the hot path.
         const COLD                      = 1 << 0;
-        /// `#[rustc_allocator]`: a hint to LLVM that the pointer returned from this
-        /// function is never null and the function has no side effects other than allocating.
-        const ALLOCATOR                 = 1 << 1;
-        /// An indicator that function will never unwind. Will become obsolete
-        /// once C-unwind is fully stabilized.
-        const NEVER_UNWIND              = 1 << 3;
+        /// `#[rustc_nounwind]`: An indicator that function will never unwind.
+        const NEVER_UNWIND              = 1 << 1;
         /// `#[naked]`: an indicator to LLVM that no function prologue/epilogue
         /// should be generated.
-        const NAKED                     = 1 << 4;
+        const NAKED                     = 1 << 2;
         /// `#[no_mangle]`: an indicator that the function's name should be the same
         /// as its symbol.
-        const NO_MANGLE                 = 1 << 5;
+        const NO_MANGLE                 = 1 << 3;
         /// `#[rustc_std_internal_symbol]`: an indicator that this symbol is a
         /// "weird symbol" for the standard library in that it has slightly
         /// different linkage, visibility, and reachability rules.
-        const RUSTC_STD_INTERNAL_SYMBOL = 1 << 6;
+        const RUSTC_STD_INTERNAL_SYMBOL = 1 << 4;
         /// `#[thread_local]`: indicates a static is actually a thread local
         /// piece of memory
-        const THREAD_LOCAL              = 1 << 8;
-        /// `#[used]`: indicates that LLVM can't eliminate this function (but the
+        const THREAD_LOCAL              = 1 << 5;
+        /// `#[used(compiler)]`: indicates that LLVM can't eliminate this function (but the
         /// linker can!).
-        const USED                      = 1 << 9;
+        const USED_COMPILER             = 1 << 6;
+        /// `#[used(linker)]`:
+        /// indicates that neither LLVM nor the linker will eliminate this function.
+        const USED_LINKER               = 1 << 7;
         /// `#[track_caller]`: allow access to the caller location
-        const TRACK_CALLER              = 1 << 10;
+        const TRACK_CALLER              = 1 << 8;
         /// #[ffi_pure]: applies clang's `pure` attribute to a foreign function
         /// declaration.
-        const FFI_PURE                  = 1 << 11;
+        const FFI_PURE                  = 1 << 9;
         /// #[ffi_const]: applies clang's `const` attribute to a foreign function
         /// declaration.
-        const FFI_CONST                 = 1 << 12;
-        // (Bit 13 was used for `#[cmse_nonsecure_entry]`, but is now unused.)
-        // (Bit 14 was used for `#[coverage(off)]`, but is now unused.)
-        /// `#[used(linker)]`:
-        /// indicates that neither LLVM nor the linker will eliminate this function.
-        const USED_LINKER               = 1 << 15;
+        const FFI_CONST                 = 1 << 10;
+        /// `#[rustc_allocator]`: a hint to LLVM that the pointer returned from this
+        /// function is never null and the function has no side effects other than allocating.
+        const ALLOCATOR                 = 1 << 11;
         /// `#[rustc_deallocator]`: a hint to LLVM that the function only deallocates memory.
-        const DEALLOCATOR               = 1 << 16;
+        const DEALLOCATOR               = 1 << 12;
         /// `#[rustc_reallocator]`: a hint to LLVM that the function only reallocates memory.
-        const REALLOCATOR               = 1 << 17;
+        const REALLOCATOR               = 1 << 13;
         /// `#[rustc_allocator_zeroed]`: a hint to LLVM that the function only allocates zeroed memory.
-        const ALLOCATOR_ZEROED          = 1 << 18;
+        const ALLOCATOR_ZEROED          = 1 << 14;
         /// `#[no_builtins]`: indicates that disable implicit builtin knowledge of functions for the function.
-        const NO_BUILTINS               = 1 << 19;
+        const NO_BUILTINS               = 1 << 15;
     }
 }
 rustc_data_structures::external_bitflags_debug! { CodegenFnAttrFlags }
diff --git a/compiler/rustc_passes/src/dead.rs b/compiler/rustc_passes/src/dead.rs
@@ -707,7 +707,7 @@ fn has_allow_dead_code_or_lang_attr(
             // #[used], #[no_mangle], #[export_name], etc also keeps the item alive
             // forcefully, e.g., for placing it in a specific section.
             cg_attrs.contains_extern_indicator()
-                || cg_attrs.flags.contains(CodegenFnAttrFlags::USED)
+                || cg_attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER)
                 || cg_attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER)
         }
     }
diff --git a/compiler/rustc_passes/src/reachable.rs b/compiler/rustc_passes/src/reachable.rs
@@ -427,7 +427,7 @@ fn has_custom_linkage(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
         // FIXME(nbdd0121): `#[used]` are marked as reachable here so it's picked up by
         // `linked_symbols` in cg_ssa. They won't be exported in binary or cdylib due to their
         // `SymbolExportLevel::Rust` export level but may end up being exported in dylibs.
-        || codegen_attrs.flags.contains(CodegenFnAttrFlags::USED)
+        || codegen_attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER)
         || codegen_attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER)
 }
 
diff --git a/src/tools/miri/src/bin/miri.rs b/src/tools/miri/src/bin/miri.rs
@@ -281,7 +281,7 @@ impl rustc_driver::Callbacks for MiriBeRustCompilerCalls {
                             }
                             let codegen_fn_attrs = tcx.codegen_fn_attrs(local_def_id);
                             if codegen_fn_attrs.contains_extern_indicator()
-                                || codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::USED)
+                                || codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER)
                                 || codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER)
                             {
                                 Some((
diff --git a/src/tools/miri/src/helpers.rs b/src/tools/miri/src/helpers.rs
@@ -135,7 +135,7 @@ pub fn iter_exported_symbols<'tcx>(
             let codegen_attrs = tcx.codegen_fn_attrs(def_id);
             codegen_attrs.contains_extern_indicator()
                 || codegen_attrs.flags.contains(CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL)
-                || codegen_attrs.flags.contains(CodegenFnAttrFlags::USED)
+                || codegen_attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER)
                 || codegen_attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER)
         };
         if exported {

Original file line number	Diff line number	Diff line change
`@@ -154,7 +154,7 @@ impl<'gcc, 'tcx> StaticCodegenMethods for CodegenCx<'gcc, 'tcx> {`
`154`	`154`	`// TODO(antoyo): set link section.`
`155`	`155`	`}`
`156`	`156`
`157`		`- if attrs.flags.contains(CodegenFnAttrFlags::USED)`
	`157`	`+ if attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER)`
`158`	`158`	`\|\| attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER)`
`159`	`159`	`{`
`160`	`160`	`self.add_used_global(global.to_rvalue());`
Original file line number	Diff line number	Diff line change
`@@ -527,7 +527,7 @@ impl<'ll> CodegenCx<'ll, '_> {`
`527`	`527`
`528`	`528`	`base::set_variable_sanitizer_attrs(g, attrs);`
`529`	`529`
`530`		`- if attrs.flags.contains(CodegenFnAttrFlags::USED) {`
	`530`	`+ if attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER) {`
`531`	`531`	// `USED` and `USED_LINKER` can't be used together.
`532`	`532`	`assert!(!attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER));`
`533`	`533`
`@@ -551,7 +551,7 @@ impl<'ll> CodegenCx<'ll, '_> {`
`551`	`551`	`}`
`552`	`552`	`if attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER) {`
`553`	`553`	// `USED` and `USED_LINKER` can't be used together.
`554`		`- assert!(!attrs.flags.contains(CodegenFnAttrFlags::USED));`
	`554`	`+ assert!(!attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER));`
`555`	`555`
`556`	`556`	`self.add_used_global(g);`
`557`	`557`	`}`
Original file line number	Diff line number	Diff line change
`@@ -189,7 +189,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {`
`189`	`189`	`)`
`190`	`190`	`.emit();`
`191`	`191`	`}`
`192`		`- codegen_fn_attrs.flags \|= CodegenFnAttrFlags::USED;`
	`192`	`+ codegen_fn_attrs.flags \|= CodegenFnAttrFlags::USED_COMPILER;`
`193`	`193`	`}`
`194`	`194`	`Some(_) => {`
`195`	`195`	`tcx.dcx().emit_err(errors::ExpectedUsedSymbol { span: attr.span() });`
`@@ -220,7 +220,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {`
`220`	`220`	`\|\| tcx.sess.target.is_like_windows`
`221`	`221`	`\|\| tcx.sess.target.is_like_wasm);`
`222`	`222`	`codegen_fn_attrs.flags \|= if is_like_elf {`
`223`		`- CodegenFnAttrFlags::USED`
	`223`	`+ CodegenFnAttrFlags::USED_COMPILER`
`224`	`224`	`} else {`
`225`	`225`	`CodegenFnAttrFlags::USED_LINKER`
`226`	`226`	`};`
Original file line number	Diff line number	Diff line change
`@@ -707,7 +707,7 @@ fn has_allow_dead_code_or_lang_attr(`
`707`	`707`	`// #[used], #[no_mangle], #[export_name], etc also keeps the item alive`
`708`	`708`	`// forcefully, e.g., for placing it in a specific section.`
`709`	`709`	`cg_attrs.contains_extern_indicator()`
`710`		`- \|\| cg_attrs.flags.contains(CodegenFnAttrFlags::USED)`
	`710`	`+ \|\| cg_attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER)`
`711`	`711`	`\|\| cg_attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER)`
`712`	`712`	`}`
`713`	`713`	`}`
Original file line number	Diff line number	Diff line change
`@@ -427,7 +427,7 @@ fn has_custom_linkage(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {`
`427`	`427`	// FIXME(nbdd0121): `#[used]` are marked as reachable here so it's picked up by
`428`	`428`	// `linked_symbols` in cg_ssa. They won't be exported in binary or cdylib due to their
`429`	`429`	// `SymbolExportLevel::Rust` export level but may end up being exported in dylibs.
`430`		`- \|\| codegen_attrs.flags.contains(CodegenFnAttrFlags::USED)`
	`430`	`+ \|\| codegen_attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER)`
`431`	`431`	`\|\| codegen_attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER)`
`432`	`432`	`}`
`433`	`433`
Original file line number	Diff line number	Diff line change
`@@ -281,7 +281,7 @@ impl rustc_driver::Callbacks for MiriBeRustCompilerCalls {`
`281`	`281`	`}`
`282`	`282`	`let codegen_fn_attrs = tcx.codegen_fn_attrs(local_def_id);`
`283`	`283`	`if codegen_fn_attrs.contains_extern_indicator()`
`284`		`- \|\| codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::USED)`
	`284`	`+ \|\| codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER)`
`285`	`285`	`\|\| codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER)`
`286`	`286`	`{`
`287`	`287`	`Some((`