Port backend trait surface to rustc 1.96 APIs

Author: LegNeato

crates/rustc_codegen_spirv/build.rs

@@ -322,9 +322,6 @@ pub(super) fn elf_e_flags(architecture: Architecture, sess: &Session) -> u32 {",
     let pqp_cg_ssa_top_level = all_extern_crates
         + r#"
 
-// HACK(eddyb) reexporting macro output for further macro use (can't patch macro).
-use maybe_pqp_cg_ssa::fluent_generated;
-
 #[allow(unused, clippy::all, clippy::pedantic, clippy::restriction)]
 #[path = "pqp_cg_ssa/src/lib.rs"]
 mod maybe_pqp_cg_ssa;

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -1825,6 +1825,11 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         self.declare_func_local_var(self.type_array(self.type_i8(), size.bytes()), align)
     }
 
+    fn scalable_alloca(&mut self, elt: u64, align: Align, element_ty: Ty<'_>) -> Self::Value {
+        let element = self.layout_of(element_ty).spirv_type(self.span(), self);
+        self.declare_func_local_var(self.type_array(element, elt), align)
+    }
+
     fn load(&mut self, ty: Self::Type, ptr: Self::Value, _align: Align) -> Self::Value {
         let (ptr, access_ty) = self.adjust_pointer_for_typed_access(ptr, ty);
         let loaded_val = ptr.const_fold_load(self).unwrap_or_else(|| {
@@ -3077,6 +3082,10 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         todo!()
     }
 
+    fn get_funclet_cleanuppad(&self, _funclet: &Self::Funclet) -> Self::Value {
+        bug!("Funclets are not supported")
+    }
+
     fn atomic_cmpxchg(
         &mut self,
         dst: Self::Value,

crates/rustc_codegen_spirv/src/builder/intrinsics.rs

@@ -83,7 +83,7 @@ impl<'a, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'tcx> {
         let ret_ty = self.layout_of(sig.output()).spirv_type(self.span(), self);
 
         let value = match name {
-            sym::likely | sym::unlikely => {
+            _ if name == sym::unlikely || name.as_str() == "likely" => {
                 // Ignore these for now.
                 args[0].immediate()
             }
@@ -369,6 +369,15 @@ impl<'a, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'tcx> {
         Ok(())
     }
 
+    fn codegen_llvm_intrinsic_call(
+        &mut self,
+        instance: ty::Instance<'tcx>,
+        _args: &[OperandRef<'tcx, Self::Value>],
+        _is_cleanup: bool,
+    ) -> Self::Value {
+        bug!("LLVM intrinsic call not supported in SPIR-V backend: {instance:?}")
+    }
+
     fn abort(&mut self) {
         self.abort_with_kind_and_message_debug_printf("abort", "intrinsics::abort() called", []);
     }
@@ -386,7 +395,7 @@ impl<'a, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'tcx> {
         &mut self,
         _llvtable: Self::Value,
         _vtable_byte_offset: u64,
-        _typeid: Self::Metadata,
+        _typeid: &[u8],
     ) -> Self::Value {
         todo!()
     }

crates/rustc_codegen_spirv/src/builder/mod.rs

@@ -291,11 +291,11 @@ impl<'a, 'tcx> StaticBuilderMethods for Builder<'a, 'tcx> {
 
 impl<'a, 'tcx> BackendTypes for Builder<'a, 'tcx> {
     type Value = <CodegenCx<'tcx> as BackendTypes>::Value;
-    type Metadata = <CodegenCx<'tcx> as BackendTypes>::Metadata;
     type Function = <CodegenCx<'tcx> as BackendTypes>::Function;
 
     type BasicBlock = <CodegenCx<'tcx> as BackendTypes>::BasicBlock;
     type Type = <CodegenCx<'tcx> as BackendTypes>::Type;
+    type FunctionSignature = <CodegenCx<'tcx> as BackendTypes>::FunctionSignature;
     type Funclet = <CodegenCx<'tcx> as BackendTypes>::Funclet;
 
     type DIScope = <CodegenCx<'tcx> as BackendTypes>::DIScope;

crates/rustc_codegen_spirv/src/builder_spirv.rs

@@ -15,14 +15,14 @@ use rspirv::{binary::Assemble, binary::Disassemble};
 use rustc_abi::Size;
 use rustc_arena::DroplessArena;
 use rustc_codegen_ssa::traits::ConstCodegenMethods as _;
+use rustc_data_structures::assert_matches;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_middle::bug;
 use rustc_middle::mir::interpret::ConstAllocation;
 use rustc_middle::ty::TyCtxt;
 use rustc_span::source_map::SourceMap;
 use rustc_span::symbol::Symbol;
-use rustc_span::{DUMMY_SP, FileName, FileNameDisplayPreference, SourceFile, Span};
-use std::assert_matches::assert_matches;
+use rustc_span::{DUMMY_SP, SourceFile, Span};
 use std::cell::{RefCell, RefMut};
 use std::hash::{Hash, Hasher};
 use std::iter;
@@ -883,12 +883,7 @@ impl<'tcx> BuilderSpirv<'tcx> {
                 // `RealFileName::to_string_lossy` returning `Cow<'_, str>`,
                 // but sadly that `'_` is the lifetime of the temporary `Arc`,
                 // not `'tcx`, so we have to arena-allocate to get `&'tcx str`.
-                let file_name = match &sf.name {
-                    FileName::Real(name) => {
-                        name.to_string_lossy(FileNameDisplayPreference::Remapped)
-                    }
-                    _ => sf.name.prefer_remapped_unconditionally().to_string().into(),
-                };
+                let file_name = sf.name.prefer_remapped_unconditionally().to_string_lossy();
                 let file_name = {
                     // FIXME(eddyb) it should be possible to arena-allocate a
                     // `&str` directly, but it would require upstream changes,

crates/rustc_codegen_spirv/src/codegen_cx/constant.rs

@@ -250,19 +250,14 @@ impl ConstCodegenMethods for CodegenCx<'_> {
                 let alloc_id = prov.alloc_id();
                 let (base_addr, _base_addr_space) = match self.tcx.global_alloc(alloc_id) {
                     GlobalAlloc::Memory(alloc) => {
-                        let pointee = match self.lookup_type(ty) {
+                        let _pointee = match self.lookup_type(ty) {
                             SpirvType::Pointer { pointee } => pointee,
                             other => self.tcx.dcx().fatal(format!(
                                 "GlobalAlloc::Memory type not implemented: {}",
                                 other.debug(ty, self)
                             )),
                         };
-                        // FIXME(eddyb) always use `const_data_from_alloc`, and
-                        // defer the actual `try_read_from_const_alloc` step.
-                        let init = self
-                            .try_read_from_const_alloc(alloc, pointee)
-                            .unwrap_or_else(|| self.const_data_from_alloc(alloc));
-                        let value = self.static_addr_of(init, alloc.inner().align, None);
+                        let value = self.static_addr_of(alloc, None);
                         (value, AddressSpace::ZERO)
                     }
                     GlobalAlloc::Function { instance } => (
@@ -279,19 +274,14 @@ impl ConstCodegenMethods for CodegenCx<'_> {
                                 }),
                             )))
                             .unwrap_memory();
-                        let pointee = match self.lookup_type(ty) {
+                        let _pointee = match self.lookup_type(ty) {
                             SpirvType::Pointer { pointee } => pointee,
                             other => self.tcx.dcx().fatal(format!(
                                 "GlobalAlloc::VTable type not implemented: {}",
                                 other.debug(ty, self)
                             )),
                         };
-                        // FIXME(eddyb) always use `const_data_from_alloc`, and
-                        // defer the actual `try_read_from_const_alloc` step.
-                        let init = self
-                            .try_read_from_const_alloc(alloc, pointee)
-                            .unwrap_or_else(|| self.const_data_from_alloc(alloc));
-                        let value = self.static_addr_of(init, alloc.inner().align, None);
+                        let value = self.static_addr_of(alloc, None);
                         (value, AddressSpace::ZERO)
                     }
                     GlobalAlloc::Static(def_id) => {
@@ -317,20 +307,6 @@ impl ConstCodegenMethods for CodegenCx<'_> {
         }
     }
 
-    // HACK(eddyb) this uses a symbolic `ConstDataFromAlloc`, to allow deferring
-    // the actual value generation until after a pointer to this value is cast
-    // to its final type (e.g. that will be loaded as).
-    // FIXME(eddyb) replace this with `qptr` handling of constant data.
-    fn const_data_from_alloc(&self, alloc: ConstAllocation<'_>) -> Self::Value {
-        // HACK(eddyb) the `ConstCodegenMethods` trait no longer guarantees the
-        // lifetime that `alloc` is interned for, but since it *is* interned,
-        // we can cheaply recover it (see also the `ty::Lift` infrastructure).
-        let alloc = self.tcx.lift(alloc).unwrap();
-
-        let void_type = SpirvType::Void.def(DUMMY_SP, self);
-        self.def_constant(void_type, SpirvConst::ConstDataFromAlloc(alloc))
-    }
-
     fn const_ptr_byte_offset(&self, val: Self::Value, offset: Size) -> Self::Value {
         if offset == Size::ZERO {
             val
@@ -345,6 +321,20 @@ impl ConstCodegenMethods for CodegenCx<'_> {
 }
 
 impl<'tcx> CodegenCx<'tcx> {
+    // HACK(eddyb) this uses a symbolic `ConstDataFromAlloc`, to allow deferring
+    // the actual value generation until after a pointer to this value is cast
+    // to its final type (e.g. that will be loaded as).
+    // FIXME(eddyb) replace this with `qptr` handling of constant data.
+    pub(crate) fn const_data_from_alloc(&self, alloc: ConstAllocation<'_>) -> SpirvValue {
+        // HACK(eddyb) the `ConstCodegenMethods` trait no longer guarantees the
+        // lifetime that `alloc` is interned for, but since it *is* interned,
+        // we can cheaply recover it (see also the `ty::Lift` infrastructure).
+        let alloc = self.tcx.lift(alloc).unwrap();
+
+        let void_type = SpirvType::Void.def(DUMMY_SP, self);
+        self.def_constant(void_type, SpirvConst::ConstDataFromAlloc(alloc))
+    }
+
     pub fn const_bitcast(&self, val: SpirvValue, ty: Word) -> SpirvValue {
         // HACK(eddyb) special-case `const_data_from_alloc` + `static_addr_of`
         // as the old `from_const_alloc` (now `OperandRef::from_const_alloc`).
@@ -353,9 +343,9 @@ impl<'tcx> CodegenCx<'tcx> {
             && let Some(SpirvConst::ConstDataFromAlloc(alloc)) =
                 self.builder.lookup_const_by_id(pointee)
             && let SpirvType::Pointer { pointee } = self.lookup_type(ty)
-            && let Some(init) = self.try_read_from_const_alloc(alloc, pointee)
+            && self.try_read_from_const_alloc(alloc, pointee).is_some()
         {
-            return self.static_addr_of(init, alloc.inner().align, None);
+            return self.static_addr_of(alloc, None);
         }
 
         if val.ty == ty {

crates/rustc_codegen_spirv/src/codegen_cx/declare.rs

@@ -9,11 +9,11 @@ use crate::custom_decorations::{CustomDecoration, SrcLocDecoration};
 use crate::spirv_type::SpirvType;
 use itertools::Itertools;
 use rspirv::spirv::{FunctionControl, LinkageType, StorageClass, Word};
-use rustc_abi::Align;
 use rustc_codegen_ssa::traits::{PreDefineCodegenMethods, StaticCodegenMethods};
 use rustc_hir::attrs::{InlineAttr, Linkage};
 use rustc_middle::bug;
 use rustc_middle::middle::codegen_fn_attrs::{CodegenFnAttrFlags, CodegenFnAttrs};
+use rustc_middle::mir::interpret::ConstAllocation;
 use rustc_middle::mir::mono::{MonoItem, Visibility};
 use rustc_middle::ty::layout::{FnAbiOf, LayoutOf};
 use rustc_middle::ty::{self, Instance, TypeVisitableExt, TypingEnv};
@@ -368,7 +368,8 @@ impl<'tcx> PreDefineCodegenMethods<'tcx> for CodegenCx<'tcx> {
 }
 
 impl<'tcx> StaticCodegenMethods for CodegenCx<'tcx> {
-    fn static_addr_of(&self, cv: Self::Value, _align: Align, _kind: Option<&str>) -> Self::Value {
+    fn static_addr_of(&self, alloc: ConstAllocation<'_>, _kind: Option<&str>) -> Self::Value {
+        let cv = self.const_data_from_alloc(alloc);
         self.def_constant(
             self.type_ptr_to(cv.ty),
             SpirvConst::PtrTo {

crates/rustc_codegen_spirv/src/codegen_cx/entry.rs

@@ -13,6 +13,7 @@ use rspirv::spirv::{
 };
 use rustc_abi::FieldsShape;
 use rustc_codegen_ssa::traits::{BaseTypeCodegenMethods, BuilderMethods, MiscCodegenMethods as _};
+use rustc_data_structures::assert_matches;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::MultiSpan;
 use rustc_hir as hir;
@@ -21,7 +22,6 @@ use rustc_middle::ty::layout::{LayoutOf, TyAndLayout};
 use rustc_middle::ty::{self, Instance, Ty};
 use rustc_span::{DUMMY_SP, Span};
 use rustc_target::callconv::{ArgAbi, FnAbi, PassMode};
-use std::assert_matches::assert_matches;
 
 /// Various information about an entry-point parameter, which can only be deduced
 /// (and/or checked) in all cases by using the original reference/value Rust type

crates/rustc_codegen_spirv/src/codegen_cx/mod.rs

@@ -788,11 +788,11 @@ impl FromStr for ModuleOutputType {
 
 impl<'tcx> BackendTypes for CodegenCx<'tcx> {
     type Value = SpirvValue;
-    type Metadata = ();
     type Function = SpirvFunctionCursor;
 
     type BasicBlock = SpirvBlockCursor;
     type Type = Word;
+    type FunctionSignature = Word;
     // Funclet: A structure representing an active landing pad for the duration of a basic block. (??)
     // https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_llvm/common/struct.Funclet.html
     //
@@ -880,7 +880,7 @@ impl<'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'tcx> {
         todo!()
     }
 
-    fn declare_c_main(&self, _fn_type: Self::Type) -> Option<Self::Function> {
+    fn declare_c_main(&self, _fn_type: Self::FunctionSignature) -> Option<Self::Function> {
         todo!()
     }
 }

crates/rustc_codegen_spirv/src/codegen_cx/type_.rs

@@ -76,7 +76,7 @@ impl<'tcx> LayoutTypeCodegenMethods<'tcx> for CodegenCx<'tcx> {
         )
     }
 
-    fn fn_decl_backend_type(&self, fn_abi: &FnAbi<'tcx, Ty<'tcx>>) -> Self::Type {
+    fn fn_decl_backend_type(&self, fn_abi: &FnAbi<'tcx, Ty<'tcx>>) -> Self::FunctionSignature {
         fn_abi.spirv_type(DUMMY_SP, self)
     }
 
@@ -171,7 +171,7 @@ impl BaseTypeCodegenMethods for CodegenCx<'_> {
         .def(DUMMY_SP, self)
     }
 
-    fn type_func(&self, args: &[Self::Type], ret: Self::Type) -> Self::Type {
+    fn type_func(&self, args: &[Self::Type], ret: Self::Type) -> Self::FunctionSignature {
         SpirvType::Function {
             return_type: ret,
             arguments: args,