Auto merge of #145551 - Zalathar:rollup-eo75r94, r=Zalathar

Rollup of 10 pull requests
Successful merges:
- #144838 (Fix outdated doc comment)
- #145206 (Port `#[custom_mir(..)]` to the new attribute system)
- #145208 (Implement declarative (`macro_rules!`) derive macros (RFC 3698))
- #145309 (Fix `-Zregparm` for LLVM builtins)
- #145355 (Add codegen test for issue 122734)
- #145420 (cg_llvm: Use LLVM-C bindings for `LLVMSetTailCallKind`, `LLVMGetTypeKind`)
- #145451 (Add static glibc to the nix dev shell)
- #145460 (Speedup `copy_src_dirs` in bootstrap)
- #145476 (Fix typo in doc for library/std/src/fs.rs#set_permissions)
- #145485 (Fix deprecation attributes on foreign statics)
r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

compiler/rustc_attr_parsing/src/attributes/deprecation.rs

@@ -54,6 +54,8 @@ impl<S: Stage> SingleAttributeParser<S> for DeprecationParser {
 Allow(Target::TyAlias),
 Allow(Target::Use),
 Allow(Target::ForeignFn),
+Allow(Target::ForeignStatic),
+Allow(Target::ForeignTy),
 Allow(Target::Field),
 Allow(Target::Trait),
 Allow(Target::AssocTy),

compiler/rustc_attr_parsing/src/attributes/mod.rs

@@ -43,6 +43,7 @@ pub(crate) mod no_implicit_prelude;
 pub(crate)mod non_exhaustive;
 pub(crate)mod path;
 pub(crate)mod proc_macro_attrs;
+pub(crate)mod prototype;
 pub(crate)mod repr;
 pub(crate)mod rustc_internal;
 pub(crate)mod semantics;

compiler/rustc_attr_parsing/src/attributes/prototype.rs

@@ -0,0 +1,140 @@
+//! Attributes that are only used on function prototypes.
+
+use rustc_feature::{AttributeTemplate, template};
+use rustc_hir::Target;
+use rustc_hir::attrs::{AttributeKind,MirDialect,MirPhase};
+use rustc_span::{Span,Symbol, sym};
+
+usesuper::{AttributeOrder,OnDuplicate};
+usecrate::attributes::SingleAttributeParser;
+usecrate::context::{AcceptContext,AllowedTargets,MaybeWarn,Stage};
+usecrate::parser::ArgParser;
+
+pub(crate)structCustomMirParser;
+
+impl<S:Stage>SingleAttributeParser<S>forCustomMirParser{
+constPATH:&[rustc_span::Symbol] = &[sym::custom_mir];
+
+constATTRIBUTE_ORDER:AttributeOrder = AttributeOrder::KeepOutermost;
+
+constON_DUPLICATE:OnDuplicate<S> = OnDuplicate::Error;
+
+constALLOWED_TARGETS:AllowedTargets =
+AllowedTargets::AllowList(&[MaybeWarn::Allow(Target::Fn)]);
+
+constTEMPLATE:AttributeTemplate = template!(List:&[r#"dialect = "...", phase = "...""#]);
+
+fnconvert(cx:&mutAcceptContext<'_,'_,S>,args:&ArgParser<'_>) -> Option<AttributeKind>{
+letSome(list) = args.list()else{
+ cx.expected_list(cx.attr_span);
+returnNone;
+};
+
+letmut dialect = None;
+letmut phase = None;
+letmut failed = false;
+
+for item in list.mixed(){
+letSome(meta_item) = item.meta_item()else{
+ cx.expected_name_value(item.span(),None);
+ failed = true;
+break;
+};
+
+ifletSome(arg) = meta_item.word_is(sym::dialect){
+extract_value(cx, sym::dialect, arg, meta_item.span(),&mut dialect,&mut failed);
+}elseifletSome(arg) = meta_item.word_is(sym::phase){
+extract_value(cx, sym::phase, arg, meta_item.span(),&mut phase,&mut failed);
+}elseifletSome(word) = meta_item.path().word(){
+let word = word.to_string();
+ cx.unknown_key(meta_item.span(), word,&["dialect","phase"]);
+ failed = true;
+}else{
+ cx.expected_name_value(meta_item.span(),None);
+ failed = true;
+};
+}
+
+let dialect = parse_dialect(cx, dialect,&mut failed);
+let phase = parse_phase(cx, phase,&mut failed);
+
+if failed {
+returnNone;
+}
+
+Some(AttributeKind::CustomMir(dialect, phase, cx.attr_span))
+}
+}
+
+fnextract_value<S:Stage>(
+cx:&mutAcceptContext<'_,'_,S>,
+key:Symbol,
+arg:&ArgParser<'_>,
+span:Span,
+out_val:&mutOption<(Symbol,Span)>,
+failed:&mutbool,
+){
+if out_val.is_some(){
+ cx.duplicate_key(span, key);
+*failed = true;
+return;
+}
+
+letSome(val) = arg.name_value()else{
+ cx.expected_single_argument(arg.span().unwrap_or(span));
+*failed = true;
+return;
+};
+
+letSome(value_sym) = val.value_as_str()else{
+ cx.expected_string_literal(val.value_span,Some(val.value_as_lit()));
+*failed = true;
+return;
+};
+
+*out_val = Some((value_sym, val.value_span));
+}
+
+fnparse_dialect<S:Stage>(
+cx:&mutAcceptContext<'_,'_,S>,
+dialect:Option<(Symbol,Span)>,
+failed:&mutbool,
+) -> Option<(MirDialect,Span)>{
+let(dialect, span) = dialect?;
+
+let dialect = match dialect {
+ sym::analysis => MirDialect::Analysis,
+ sym::built => MirDialect::Built,
+ sym::runtime => MirDialect::Runtime,
+
+ _ => {
+ cx.expected_specific_argument(span,vec!["analysis","built","runtime"]);
+*failed = true;
+returnNone;
+}
+};
+
+Some((dialect, span))
+}
+
+fnparse_phase<S:Stage>(
+cx:&mutAcceptContext<'_,'_,S>,
+phase:Option<(Symbol,Span)>,
+failed:&mutbool,
+) -> Option<(MirPhase,Span)>{
+let(phase, span) = phase?;
+
+let phase = match phase {
+ sym::initial => MirPhase::Initial,
+ sym::post_cleanup => MirPhase::PostCleanup,
+ sym::optimized => MirPhase::Optimized,
+
+ _ => {
+ cx.expected_specific_argument(span,vec!["initial","post-cleanup","optimized"]);
+*failed = true;
+returnNone;
+}
+};
+
+Some((phase, span))
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -46,6 +46,7 @@ use crate::attributes::path::PathParser as PathAttributeParser;
 usecrate::attributes::proc_macro_attrs::{
 ProcMacroAttributeParser,ProcMacroDeriveParser,ProcMacroParser,RustcBuiltinMacroParser,
 };
+usecrate::attributes::prototype::CustomMirParser;
 usecrate::attributes::repr::{AlignParser,ReprParser};
 usecrate::attributes::rustc_internal::{
 RustcLayoutScalarValidRangeEnd,RustcLayoutScalarValidRangeStart,
@@ -167,6 +168,7 @@ attribute_parsers!(
 
 // tidy-alphabetical-start
 Single<CoverageParser>,
+Single<CustomMirParser>,
 Single<DeprecationParser>,
 Single<DummyParser>,
 Single<ExportNameParser>,
@@ -1060,6 +1062,9 @@ pub(crate) fn allowed_targets_applied(
 if !features.stmt_expr_attributes(){
  allowed_targets.retain(|t| !matches!(t,Target::Expression | Target::Statement));
 }
+if !features.extern_types(){
+ allowed_targets.retain(|t| !matches!(t,Target::ForeignTy));
+}
 }
 
 // We define groups of "similar" targets.

compiler/rustc_codegen_llvm/src/builder.rs

@@ -1453,7 +1453,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
 instance:Option<Instance<'tcx>>,
 ){
 let call = self.call(llty, fn_attrs,Some(fn_abi), llfn, args, funclet, instance);
- llvm::LLVMRustSetTailCallKind(call, llvm::TailCallKind::MustTail);
+ llvm::LLVMSetTailCallKind(call, llvm::TailCallKind::MustTail);
 
 match&fn_abi.ret.mode{
 PassMode::Ignore | PassMode::Indirect{ .. } => self.ret_void(),

compiler/rustc_codegen_llvm/src/context.rs

@@ -377,6 +377,15 @@ pub(crate) unsafe fn create_module<'ll>(
 }
 }
 
+ifletSome(regparm_count) = sess.opts.unstable_opts.regparm{
+ llvm::add_module_flag_u32(
+ llmod,
+ llvm::ModuleFlagMergeBehavior::Error,
+"NumRegisterParameters",
+ regparm_count,
+);
+}
+
 ifletSome(BranchProtection{ bti, pac_ret }) = sess.opts.unstable_opts.branch_protection{
 if sess.target.arch == "aarch64"{
  llvm::add_module_flag_u32(

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -97,6 +97,7 @@ pub(crate) enum ModuleFlagMergeBehavior {
 
 // Consts for the LLVM CallConv type, pre-cast to usize.
 
+/// Must match the layout of `LLVMTailCallKind`.
 #[derive(Copy,Clone,PartialEq,Debug)]
 #[repr(C)]
 #[allow(dead_code)]
@@ -332,10 +333,15 @@ impl RealPredicate {
 }
 }
 
-/// LLVMTypeKind
-#[derive(Copy,Clone,PartialEq,Debug)]
+/// Must match the layout of `LLVMTypeKind`.
+///
+/// Use [`RawEnum<TypeKind>`] for values of `LLVMTypeKind` returned from LLVM,
+/// to avoid risk of UB if LLVM adds new enum values.
+///
+/// All of LLVM's variants should be declared here, even if no Rust-side code refers
+/// to them, because unknown variants will cause [`RawEnum::to_rust`] to panic.
+#[derive(Copy,Clone,PartialEq,Debug,TryFromU32)]
 #[repr(C)]
-#[expect(dead_code, reason = "Some variants are unused, but are kept to match LLVM-C")]
 pub(crate)enumTypeKind{
 Void = 0,
 Half = 1,
@@ -1046,6 +1052,8 @@ unsafe extern "C" {
 CanThrow: llvm::Bool,
 ) -> &'llValue;
 
+pub(crate) safe fnLLVMGetTypeKind(Ty:&Type) -> RawEnum<TypeKind>;
+
 // Operations on integer types
 pub(crate)fnLLVMInt1TypeInContext(C:&Context) -> &Type;
 pub(crate)fnLLVMInt8TypeInContext(C:&Context) -> &Type;
@@ -1197,7 +1205,7 @@ unsafe extern "C" {
 pub(crate) safe fnLLVMIsGlobalConstant(GlobalVar:&Value) -> Bool;
 pub(crate) safe fnLLVMSetGlobalConstant(GlobalVar:&Value,IsConstant:Bool);
 pub(crate) safe fnLLVMSetTailCall(CallInst:&Value,IsTailCall:Bool);
-pub(crate) safe fnLLVMRustSetTailCallKind(CallInst:&Value,Kind:TailCallKind);
+pub(crate) safe fnLLVMSetTailCallKind(CallInst:&Value,kind:TailCallKind);
 
 // Operations on attributes
 pub(crate)fnLLVMCreateStringAttribute(
@@ -1841,9 +1849,6 @@ unsafe extern "C" {
 // Create and destroy contexts.
 pub(crate)fnLLVMRustContextCreate(shouldDiscardNames:bool) -> &'staticmutContext;
 
-/// See llvm::LLVMTypeKind::getTypeID.
-pub(crate)fnLLVMRustGetTypeKind(Ty:&Type) -> TypeKind;
-
 // Operations on all values
 pub(crate)fnLLVMRustGlobalAddMetadata<'a>(
 Val:&'aValue,

compiler/rustc_codegen_llvm/src/type_.rs

@@ -204,7 +204,7 @@ impl<'ll, CX: Borrow<SCx<'ll>>> BaseTypeCodegenMethods for GenericCx<'ll, CX> {
 }
 
 fntype_kind(&self,ty:&'llType) -> TypeKind{
-unsafe{llvm::LLVMRustGetTypeKind(ty).to_generic()}
+ llvm::LLVMGetTypeKind(ty).to_rust().to_generic()
 }
 
 fntype_ptr(&self) -> &'llType{

compiler/rustc_errors/src/diagnostic_impls.rs

@@ -9,6 +9,7 @@ use rustc_abi::TargetDataLayoutErrors;
 use rustc_ast::util::parser::ExprPrecedence;
 use rustc_ast_pretty::pprust;
 use rustc_hir::RustcVersion;
+use rustc_hir::attrs::{MirDialect,MirPhase};
 use rustc_macros::Subdiagnostic;
 use rustc_span::edition::Edition;
 use rustc_span::{Ident,MacroRulesNormalizedIdent,Span,Symbol};
@@ -312,6 +313,28 @@ impl IntoDiagArg for ExprPrecedence {
 }
 }
 
+implIntoDiagArgforMirDialect{
+fninto_diag_arg(self,_path:&mutOption<PathBuf>) -> DiagArgValue{
+let arg = matchself{
+MirDialect::Analysis => "analysis",
+MirDialect::Built => "built",
+MirDialect::Runtime => "runtime",
+};
+DiagArgValue::Str(Cow::Borrowed(arg))
+}
+}
+
+implIntoDiagArgforMirPhase{
+fninto_diag_arg(self,_path:&mutOption<PathBuf>) -> DiagArgValue{
+let arg = matchself{
+MirPhase::Initial => "initial",
+MirPhase::PostCleanup => "post-cleanup",
+MirPhase::Optimized => "optimized",
+};
+DiagArgValue::Str(Cow::Borrowed(arg))
+}
+}
+
 #[derive(Clone)]
 pubstructDiagSymbolList<S = Symbol>(Vec<S>);
 

compiler/rustc_expand/messages.ftl

@@ -70,7 +70,7 @@ expand_invalid_fragment_specifier =
  invalid fragment specifier `{$fragment}`
 .help = {$help}
 
-expand_macro_args_bad_delim = macro attribute argument matchers require parentheses
+expand_macro_args_bad_delim = `{$rule_kw}` rule argument matchers require parentheses
 expand_macro_args_bad_delim_sugg = the delimiters should be `(` and `)`
 
 expand_macro_body_stability =