rustup update (#840)

* rustup update

* asm->core::arch::asm

Author: khyperia

crates/rustc_codegen_spirv/src/abi.rs

@@ -386,7 +386,7 @@ impl<'tcx> ConvSpirvType<'tcx> for TyAndLayout<'tcx> {
                     if let Variants::Single { index } = self.variants {
                         for i in self.fields.index_by_increasing_offset() {
                             let field = &adt.variants[index].fields[i];
-                            field_names.push(field.ident.name.to_ident_string());
+                            field_names.push(field.name.to_ident_string());
                         }
                     }
                 }
@@ -664,7 +664,7 @@ fn trans_struct<'tcx>(cx: &CodegenCx<'tcx>, span: Span, ty: TyAndLayout<'tcx>) -
         if let Variants::Single { index } = ty.variants {
             if let TyKind::Adt(adt, _) = ty.ty.kind() {
                 let field = &adt.variants[index].fields[i];
-                field_names.push(field.ident.name.to_ident_string());
+                field_names.push(field.name.to_ident_string());
             } else {
                 field_names.push(format!("{}", i));
             }
@@ -729,7 +729,7 @@ impl fmt::Display for TyLayoutNameKey<'_> {
         write!(f, "{}", self.ty)?;
         if let (TyKind::Adt(def, _), Some(index)) = (self.ty.kind(), self.variant) {
             if def.is_enum() && !def.variants.is_empty() {
-                write!(f, "::{}", def.variants[index].ident)?;
+                write!(f, "::{}", def.variants[index].name)?;
             }
         }
         if let (TyKind::Generator(_, _, _), Some(index)) = (self.ty.kind(), self.variant) {

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -2240,7 +2240,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         self.intcast(val, dest_ty, false)
     }
 
-    fn do_not_inline(&mut self, _llret: Self::Value) {
+    fn apply_attrs_to_cleanup_callsite(&mut self, _llret: Self::Value) {
         // Ignore
     }
 }

crates/rustc_codegen_spirv/src/builder/spirv_asm.rs

@@ -71,6 +71,7 @@ impl<'a, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'tcx> {
         options: InlineAsmOptions,
         _line_spans: &[Span],
         _instance: Instance<'_>,
+        _dest_catch_funclet: Option<(Self::BasicBlock, Self::BasicBlock, Option<&Self::Funclet>)>,
     ) {
         const SUPPORTED_OPTIONS: InlineAsmOptions = InlineAsmOptions::NORETURN;
         let unsupported_options = options & !SUPPORTED_OPTIONS;

crates/rustc_codegen_spirv/src/codegen_cx/declare.rs

@@ -91,7 +91,7 @@ impl<'tcx> CodegenCx<'tcx> {
 
         // HACK(eddyb) this is a bit roundabout, but the easiest way to get a
         // fully absolute path that contains at least as much information as
-        // `instance.to_string()` (at least with `-Z symbol-mangling-version=v0`).
+        // `instance.to_string()` (at least with `-C symbol-mangling-version=v0`).
         // While we could use the mangled symbol instead, like we do for linkage,
         // `OpName` is more of a debugging aid, so not having to separately
         // demangle the SPIR-V can help. However, if some tools assume `OpName`

crates/rustc_codegen_spirv/src/codegen_cx/mod.rs

@@ -97,7 +97,7 @@ impl<'tcx> CodegenCx<'tcx> {
         // target_features is a HashSet, not a Vec, so we need to sort to have deterministic
         // compilation - otherwise, the order of capabilities in binaries depends on the iteration
         // order of the hashset. Sort by the string, since that's easy.
-        feature_names.sort();
+        feature_names.sort_unstable();
 
         let features = feature_names
             .into_iter()

crates/rustc_codegen_spirv/src/lib.rs

@@ -316,6 +316,7 @@ impl CodegenBackend for SpirvCodegenBackend {
         &self,
         ongoing_codegen: Box<dyn Any>,
         sess: &Session,
+        _outputs: &OutputFilenames,
     ) -> Result<(CodegenResults, FxHashMap<WorkProductId, WorkProduct>), ErrorReported> {
         let (codegen_results, work_products) = ongoing_codegen
             .downcast::<OngoingCodegen<Self>>()
@@ -338,7 +339,7 @@ impl CodegenBackend for SpirvCodegenBackend {
             sess,
             &codegen_results,
             outputs,
-            &codegen_results.crate_info.local_crate_name.as_str(),
+            codegen_results.crate_info.local_crate_name.as_str(),
         );
         drop(timer);
 
@@ -454,15 +455,6 @@ impl ExtraBackendMethods for SpirvCodegenBackend {
         Self::Module::new()
     }
 
-    fn write_compressed_metadata<'tcx>(
-        &self,
-        _: TyCtxt<'tcx>,
-        _: &EncodedMetadata,
-        _: &mut Self::Module,
-    ) {
-        // Ignore for now.
-    }
-
     fn codegen_allocator<'tcx>(
         &self,
         _: TyCtxt<'tcx>,

crates/spirv-builder/src/lib.rs

@@ -196,17 +196,20 @@ impl SpirvBuilder {
     }
 
     /// Whether to print build.rs cargo metadata (e.g. cargo:rustc-env=var=val). Defaults to [`MetadataPrintout::Full`].
+    #[must_use]
     pub fn print_metadata(mut self, v: MetadataPrintout) -> Self {
         self.print_metadata = v;
         self
     }
 
+    #[must_use]
     pub fn deny_warnings(mut self, v: bool) -> Self {
         self.deny_warnings = v;
         self
     }
 
     /// Build in release. Defaults to true.
+    #[must_use]
     pub fn release(mut self, v: bool) -> Self {
         self.release = v;
         self
@@ -215,54 +218,62 @@ impl SpirvBuilder {
     /// Splits the resulting SPIR-V file into one module per entry point. This is useful in cases
     /// where ecosystem tooling has bugs around multiple entry points per module - having all entry
     /// points bundled into a single file is the preferred system.
+    #[must_use]
     pub fn multimodule(mut self, v: bool) -> Self {
         self.multimodule = v;
         self
     }
 
     /// Sets the level of metadata (primarily `OpName` and `OpLine`) included in the SPIR-V binary.
     /// Including metadata significantly increases binary size.
+    #[must_use]
     pub fn spirv_metadata(mut self, v: SpirvMetadata) -> Self {
         self.spirv_metadata = v;
         self
     }
 
     /// Adds a capability to the SPIR-V module. Checking if a capability is enabled in code can be
     /// done via `#[cfg(target_feature = "TheCapability")]`.
+    #[must_use]
     pub fn capability(mut self, capability: Capability) -> Self {
         self.capabilities.push(capability);
         self
     }
 
     /// Adds an extension to the SPIR-V module. Checking if an extension is enabled in code can be
     /// done via `#[cfg(target_feature = "ext:the_extension")]`.
+    #[must_use]
     pub fn extension(mut self, extension: impl Into<String>) -> Self {
         self.extensions.push(extension.into());
         self
     }
 
     /// Allow store from one struct type to a different type with compatible layout and members.
+    #[must_use]
     pub fn relax_struct_store(mut self, v: bool) -> Self {
         self.relax_struct_store = v;
         self
     }
 
     /// Allow allocating an object of a pointer type and returning a pointer value from a function
     /// in logical addressing mode
+    #[must_use]
     pub fn relax_logical_pointer(mut self, v: bool) -> Self {
         self.relax_logical_pointer = v;
         self
     }
 
     /// Enable `VK_KHR_relaxed_block_layout` when checking standard uniform, storage buffer, and
     /// push constant layouts. This is the default when targeting Vulkan 1.1 or later.
+    #[must_use]
     pub fn relax_block_layout(mut self, v: bool) -> Self {
         self.relax_block_layout = v;
         self
     }
 
     /// Enable `VK_KHR_uniform_buffer_standard_layout` when checking standard uniform buffer
     /// layouts.
+    #[must_use]
     pub fn uniform_buffer_standard_layout(mut self, v: bool) -> Self {
         self.uniform_buffer_standard_layout = v;
         self
@@ -271,19 +282,22 @@ impl SpirvBuilder {
     /// Enable `VK_EXT_scalar_block_layout` when checking standard uniform, storage buffer, and
     /// push constant layouts. Scalar layout rules are more permissive than relaxed block layout so
     /// in effect this will override the --relax-block-layout option.
+    #[must_use]
     pub fn scalar_block_layout(mut self, v: bool) -> Self {
         self.scalar_block_layout = v;
         self
     }
 
     /// Skip checking standard uniform/storage buffer layout. Overrides any --relax-block-layout or
     /// --scalar-block-layout option.
+    #[must_use]
     pub fn skip_block_layout(mut self, v: bool) -> Self {
         self.skip_block_layout = v;
         self
     }
 
     /// Preserve unused descriptor bindings. Useful for reflection.
+    #[must_use]
     pub fn preserve_bindings(mut self, v: bool) -> Self {
         self.preserve_bindings = v;
         self
@@ -405,7 +419,7 @@ fn invoke_rustc(builder: &SpirvBuilder) -> Result<PathBuf, SpirvBuilderError> {
 
     let mut rustflags = vec![
         format!("-Zcodegen-backend={}", rustc_codegen_spirv.display()),
-        "-Zsymbol-mangling-version=v0".to_string(),
+        "-Csymbol-mangling-version=v0".to_string(),
     ];
 
     let mut llvm_args = vec![];

crates/spirv-std/macros/src/lib.rs

@@ -600,7 +600,7 @@ fn debug_printf_inner(input: DebugPrintfInput) -> TokenStream {
     let op_string = format!("%string = OpString {:?}", format_string);
 
     let output = quote::quote! {
-        asm!(
+        ::core::arch::asm!(
             "%void = OpTypeVoid",
             #op_string,
             "%debug_printf = OpExtInstImport \"NonSemantic.DebugPrintf\"",

crates/spirv-std/src/arch.rs

@@ -8,6 +8,8 @@ use crate::{
     scalar::Scalar,
     vector::Vector,
 };
+#[cfg(target_arch = "spirv")]
+use core::arch::asm;
 
 mod barrier;
 mod demote_to_helper_invocation_ext;

crates/spirv-std/src/arch/barrier.rs

@@ -1,3 +1,6 @@
+#[cfg(target_arch = "spirv")]
+use core::arch::asm;
+
 /// Wait for other invocations of this module to reach the current point
 /// of execution.
 ///