Merge pull request #2717 from rust-lang/rustc-pull

Rustc pull update

Author: tshepang

Cargo.lock

@@ -188,7 +188,20 @@ version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f75363874b771be265f4ffe307ca705ef6f3baa19011c149da8674a87f1b75c4"
 dependencies = [
- "askama_derive",
+ "askama_derive 0.14.0",
+ "itoa",
+ "percent-encoding",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "askama"
+version = "0.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb7125972258312e79827b60c9eb93938334100245081cf701a2dee981b17427"
+dependencies = [
+ "askama_macros",
  "itoa",
  "percent-encoding",
  "serde",
@@ -201,7 +214,7 @@ version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "129397200fe83088e8a68407a8e2b1f826cf0086b21ccdb866a722c8bcd3a94f"
 dependencies = [
- "askama_parser",
+ "askama_parser 0.14.0",
  "basic-toml",
  "memchr",
  "proc-macro2",
@@ -212,6 +225,32 @@ dependencies = [
  "syn 2.0.110",
 ]
 
+[[package]]
+name = "askama_derive"
+version = "0.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ba5e7259a1580c61571e3116ebaaa01e3c001b2132b17c4cc5c70780ca3e994"
+dependencies = [
+ "askama_parser 0.15.1",
+ "basic-toml",
+ "memchr",
+ "proc-macro2",
+ "quote",
+ "rustc-hash 2.1.1",
+ "serde",
+ "serde_derive",
+ "syn 2.0.110",
+]
+
+[[package]]
+name = "askama_macros"
+version = "0.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "236ce20b77cb13506eaf5024899f4af6e12e8825f390bd943c4c37fd8f322e46"
+dependencies = [
+ "askama_derive 0.15.1",
+]
+
 [[package]]
 name = "askama_parser"
 version = "0.14.0"
@@ -224,6 +263,19 @@ dependencies = [
  "winnow 0.7.13",
 ]
 
+[[package]]
+name = "askama_parser"
+version = "0.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3c63392767bb2df6aa65a6e1e3b80fd89bb7af6d58359b924c0695620f1512e"
+dependencies = [
+ "rustc-hash 2.1.1",
+ "serde",
+ "serde_derive",
+ "unicode-ident",
+ "winnow 0.7.13",
+]
+
 [[package]]
 name = "assert_cmd"
 version = "2.1.1"
@@ -624,7 +676,7 @@ name = "clippy"
 version = "0.1.94"
 dependencies = [
  "anstream",
- "askama",
+ "askama 0.14.0",
  "cargo_metadata 0.18.1",
  "clippy_config",
  "clippy_lints",
@@ -1515,7 +1567,7 @@ name = "generate-copyright"
 version = "0.1.0"
 dependencies = [
  "anyhow",
- "askama",
+ "askama 0.15.1",
  "cargo_metadata 0.21.0",
  "serde",
  "serde_json",
@@ -4572,7 +4624,6 @@ dependencies = [
 name = "rustc_resolve"
 version = "0.0.0"
 dependencies = [
- "bitflags",
  "indexmap",
  "itertools",
  "pulldown-cmark",
@@ -4862,7 +4913,7 @@ name = "rustdoc"
 version = "0.0.0"
 dependencies = [
  "arrayvec",
- "askama",
+ "askama 0.15.1",
  "base64",
  "expect-test",
  "indexmap",

bootstrap.example.toml

@@ -106,6 +106,9 @@
 # Whether to build LLVM with support for it's gpu offload runtime.
 #llvm.offload = false
 
+# Absolute path to the directory containing ClangConfig.cmake
+#llvm.offload-clang-dir = ""
+
 # When true, link libstdc++ statically into the rustc_llvm.
 # This is useful if you don't want to use the dynamic version of that
 # library provided by LLVM.

compiler/rustc_ast_lowering/src/asm.rs

@@ -52,7 +52,15 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     | asm::InlineAsmArch::LoongArch64
                     | asm::InlineAsmArch::S390x
             );
-            if !is_stable && !self.tcx.features().asm_experimental_arch() {
+            if !is_stable
+                && !self.tcx.features().asm_experimental_arch()
+                && sp
+                    .ctxt()
+                    .outer_expn_data()
+                    .allow_internal_unstable
+                    .filter(|features| features.contains(&sym::asm_experimental_arch))
+                    .is_none()
+            {
                 feature_err(
                     &self.tcx.sess,
                     sym::asm_experimental_arch,

compiler/rustc_attr_parsing/messages.ftl

@@ -229,6 +229,8 @@ attr_parsing_unstable_cfg_target_compact =
 attr_parsing_unstable_feature_bound_incompatible_stability = item annotated with `#[unstable_feature_bound]` should not be stable
     .help = If this item is meant to be stable, do not use any functions annotated with `#[unstable_feature_bound]`. Otherwise, mark this item as unstable with `#[unstable]`
 
+attr_parsing_unsupported_instruction_set = target `{$current_target}` does not support `#[instruction_set({$instruction_set}::*)]`
+
 attr_parsing_unsupported_literal_suggestion =
     consider removing the prefix
 

compiler/rustc_attr_parsing/src/attributes/instruction_set.rs

@@ -0,0 +1,73 @@
+use rustc_hir::attrs::InstructionSetAttr;
+
+use super::prelude::*;
+use crate::session_diagnostics;
+
+pub(crate) struct InstructionSetParser;
+
+impl<S: Stage> SingleAttributeParser<S> for InstructionSetParser {
+    const PATH: &[Symbol] = &[sym::instruction_set];
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowListWarnRest(&[
+        Allow(Target::Fn),
+        Allow(Target::Closure),
+        Allow(Target::Method(MethodKind::Inherent)),
+        Allow(Target::Method(MethodKind::TraitImpl)),
+        Allow(Target::Method(MethodKind::Trait { body: true })),
+    ]);
+    const TEMPLATE: AttributeTemplate = template!(List: &["set"], "https://doc.rust-lang.org/reference/attributes/codegen.html#the-instruction_set-attribute");
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
+
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
+        const POSSIBLE_SYMBOLS: &[Symbol] = &[sym::arm_a32, sym::arm_t32];
+        const POSSIBLE_ARM_SYMBOLS: &[Symbol] = &[sym::a32, sym::t32];
+        let Some(maybe_meta_item) = args.list().and_then(MetaItemListParser::single) else {
+            cx.expected_specific_argument(cx.attr_span, POSSIBLE_SYMBOLS);
+            return None;
+        };
+
+        let Some(meta_item) = maybe_meta_item.meta_item() else {
+            cx.expected_specific_argument(maybe_meta_item.span(), POSSIBLE_SYMBOLS);
+            return None;
+        };
+
+        let mut segments = meta_item.path().segments();
+
+        let Some(architecture) = segments.next() else {
+            cx.expected_specific_argument(meta_item.span(), POSSIBLE_SYMBOLS);
+            return None;
+        };
+
+        let Some(instruction_set) = segments.next() else {
+            cx.expected_specific_argument(architecture.span, POSSIBLE_SYMBOLS);
+            return None;
+        };
+
+        let instruction_set = match architecture.name {
+            sym::arm => {
+                if !cx.sess.target.has_thumb_interworking {
+                    cx.dcx().emit_err(session_diagnostics::UnsupportedInstructionSet {
+                        span: cx.attr_span,
+                        instruction_set: sym::arm,
+                        current_target: &cx.sess.opts.target_triple,
+                    });
+                    return None;
+                }
+                match instruction_set.name {
+                    sym::a32 => InstructionSetAttr::ArmA32,
+                    sym::t32 => InstructionSetAttr::ArmT32,
+                    _ => {
+                        cx.expected_specific_argument(instruction_set.span, POSSIBLE_ARM_SYMBOLS);
+                        return None;
+                    }
+                }
+            }
+            _ => {
+                cx.expected_specific_argument(architecture.span, POSSIBLE_SYMBOLS);
+                return None;
+            }
+        };
+
+        Some(AttributeKind::InstructionSet(instruction_set))
+    }
+}

compiler/rustc_attr_parsing/src/attributes/mod.rs

@@ -42,6 +42,7 @@ pub(crate) mod deprecation;
 pub(crate) mod doc;
 pub(crate) mod dummy;
 pub(crate) mod inline;
+pub(crate) mod instruction_set;
 pub(crate) mod link_attrs;
 pub(crate) mod lint_helpers;
 pub(crate) mod loop_match;

compiler/rustc_attr_parsing/src/context.rs

@@ -37,6 +37,7 @@ use crate::attributes::deprecation::DeprecationParser;
 use crate::attributes::doc::DocParser;
 use crate::attributes::dummy::DummyParser;
 use crate::attributes::inline::{InlineParser, RustcForceInlineParser};
+use crate::attributes::instruction_set::InstructionSetParser;
 use crate::attributes::link_attrs::{
     ExportStableParser, FfiConstParser, FfiPureParser, LinkNameParser, LinkOrdinalParser,
     LinkParser, LinkSectionParser, LinkageParser, StdInternalSymbolParser,
@@ -198,6 +199,7 @@ attribute_parsers!(
         Single<ExportNameParser>,
         Single<IgnoreParser>,
         Single<InlineParser>,
+        Single<InstructionSetParser>,
         Single<LinkNameParser>,
         Single<LinkOrdinalParser>,
         Single<LinkSectionParser>,

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -9,6 +9,7 @@ use rustc_feature::AttributeTemplate;
 use rustc_hir::AttrPath;
 use rustc_macros::{Diagnostic, Subdiagnostic};
 use rustc_span::{Span, Symbol};
+use rustc_target::spec::TargetTuple;
 
 use crate::fluent_generated as fluent;
 
@@ -936,3 +937,12 @@ pub(crate) struct DocAliasMalformed {
     #[primary_span]
     pub span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag(attr_parsing_unsupported_instruction_set)]
+pub(crate) struct UnsupportedInstructionSet<'a> {
+    #[primary_span]
+    pub span: Span,
+    pub instruction_set: Symbol,
+    pub current_target: &'a TargetTuple,
+}

compiler/rustc_borrowck/src/universal_regions.rs

@@ -543,38 +543,9 @@ impl<'cx, 'tcx> UniversalRegionsBuilder<'cx, 'tcx> {
             &indices,
         );
 
-        let (unnormalized_output_ty, mut unnormalized_input_tys) =
+        let (unnormalized_output_ty, unnormalized_input_tys) =
             inputs_and_output.split_last().unwrap();
 
-        // C-variadic fns also have a `VaList` input that's not listed in the signature
-        // (as it's created inside the body itself, not passed in from outside).
-        if let DefiningTy::FnDef(def_id, _) = defining_ty {
-            if self.infcx.tcx.fn_sig(def_id).skip_binder().c_variadic() {
-                let va_list_did = self
-                    .infcx
-                    .tcx
-                    .require_lang_item(LangItem::VaList, self.infcx.tcx.def_span(self.mir_def));
-
-                let reg_vid = self
-                    .infcx
-                    .next_nll_region_var(NllRegionVariableOrigin::FreeRegion, || {
-                        RegionCtxt::Free(sym::c_dash_variadic)
-                    })
-                    .as_var();
-
-                let region = ty::Region::new_var(self.infcx.tcx, reg_vid);
-                let va_list_ty = self
-                    .infcx
-                    .tcx
-                    .type_of(va_list_did)
-                    .instantiate(self.infcx.tcx, &[region.into()]);
-
-                unnormalized_input_tys = self.infcx.tcx.mk_type_list_from_iter(
-                    unnormalized_input_tys.iter().copied().chain(iter::once(va_list_ty)),
-                );
-            }
-        }
-
         let fr_fn_body = self
             .infcx
             .next_nll_region_var(NllRegionVariableOrigin::FreeRegion, || {
@@ -816,7 +787,40 @@ impl<'cx, 'tcx> UniversalRegionsBuilder<'cx, 'tcx> {
             DefiningTy::FnDef(def_id, _) => {
                 let sig = tcx.fn_sig(def_id).instantiate_identity();
                 let sig = indices.fold_to_region_vids(tcx, sig);
-                sig.inputs_and_output()
+                let inputs_and_output = sig.inputs_and_output();
+
+                // C-variadic fns also have a `VaList` input that's not listed in the signature
+                // (as it's created inside the body itself, not passed in from outside).
+                if self.infcx.tcx.fn_sig(def_id).skip_binder().c_variadic() {
+                    let va_list_did = self
+                        .infcx
+                        .tcx
+                        .require_lang_item(LangItem::VaList, self.infcx.tcx.def_span(self.mir_def));
+
+                    let reg_vid = self
+                        .infcx
+                        .next_nll_region_var(NllRegionVariableOrigin::FreeRegion, || {
+                            RegionCtxt::Free(sym::c_dash_variadic)
+                        })
+                        .as_var();
+
+                    let region = ty::Region::new_var(self.infcx.tcx, reg_vid);
+                    let va_list_ty = self
+                        .infcx
+                        .tcx
+                        .type_of(va_list_did)
+                        .instantiate(self.infcx.tcx, &[region.into()]);
+
+                    // The signature needs to follow the order [input_tys, va_list_ty, output_ty]
+                    return inputs_and_output.map_bound(|tys| {
+                        let (output_ty, input_tys) = tys.split_last().unwrap();
+                        tcx.mk_type_list_from_iter(
+                            input_tys.iter().copied().chain([va_list_ty, *output_ty]),
+                        )
+                    });
+                }
+
+                inputs_and_output
             }
 
             DefiningTy::Const(def_id, _) => {

compiler/rustc_codegen_llvm/src/back/write.rs

@@ -250,7 +250,7 @@ pub(crate) fn target_machine_factory(
 
     let use_emulated_tls = matches!(sess.tls_model(), TlsModel::Emulated);
 
-    let debuginfo_compression = match sess.opts.debuginfo_compression {
+    let debuginfo_compression = match sess.opts.unstable_opts.debuginfo_compression {
         config::DebugInfoCompression::None => llvm::CompressionKind::None,
         config::DebugInfoCompression::Zlib => {
             if llvm::LLVMRustLLVMHasZlibCompression() {