Rollup merge of rust-lang#78950 - khyperia:spirv-asm, r=Amanieu

Add asm register information for SPIR-V

As discussed in [zulip](https://rust-lang.zulipchat.com/#narrow/stream/182449-t-compiler.2Fhelp/topic/Defining.20asm!.20for.20new.20architecture), we at [rust-gpu](https://github.com/EmbarkStudios/rust-gpu) would like to support `asm!` for our SPIR-V backend. However, we cannot do so purely without frontend support: [this match](https://github.com/rust-lang/rust/blob/d4ea0b3e46a0303d5802b632e88ba1ba84d9d16f/compiler/rustc_target/src/asm/mod.rs#L185) fails and so `asm!` is not supported ([error reported here](https://github.com/rust-lang/rust/blob/d4ea0b3e46a0303d5802b632e88ba1ba84d9d16f/compiler/rustc_ast_lowering/src/expr.rs#L1095)). To resolve this, we need to stub out register information for SPIR-V to support getting the `asm!` content all the way to [`AsmBuilderMethods::codegen_inline_asm`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/traits/trait.AsmBuilderMethods.html#tymethod.codegen_inline_asm), at which point the rust-gpu backend can do all the parsing and codegen that is needed.

This is a pretty weird PR - adding support for a backend that isn't in-tree feels pretty gross to me, but I don't see an easy way around this. ``@Amanieu`` said I should submit it anyway, so, here we are! Let me know if this needs to go through a more formal process (MCP?) and what I should do to help this along.

I based this off the [wasm asm PR](rust-lang#78684), which unfortunately this PR conflicts with that one quite a bit, sorry for any merge conflict pain :(

---

Some open questions:

- What do we call the register class? Some context, SPIR-V is an SSA-based IR, there are "instructions" that create IDs (referred to as `<id>` in the spec), which can be referenced by other instructions. So, `reg` isn't exactly accurate, they're SSA IDs, not re-assignable registers.
- What happens when a SPIR-V register gets to the LLVM backend? Right now it's a `bug!`, but should that be a `sess.fatal()`? I'm not sure if it's even possible to reach that point, maybe there's a check that prevents the `spirv` target from even reaching that codepath.

compiler/rustc_codegen_llvm/src/asm.rs

@@ -12,8 +12,8 @@ use rustc_codegen_ssa::mir::place::PlaceRef;
 use rustc_codegen_ssa::traits::*;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir as hir;
-use rustc_middle::span_bug;
 use rustc_middle::ty::layout::TyAndLayout;
+use rustc_middle::{bug, span_bug};
 use rustc_span::{Pos, Span};
 use rustc_target::abi::*;
 use rustc_target::asm::*;
@@ -260,6 +260,7 @@ impl AsmBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
  InlineAsmArch::Nvptx64 => {}
  InlineAsmArch::Hexagon => {}
  InlineAsmArch::Mips | InlineAsmArch::Mips64 => {}
+ InlineAsmArch::SpirV => {}
  }
  }
  if !options.contains(InlineAsmOptions::NOMEM) {
@@ -518,6 +519,9 @@ fn reg_to_llvm(reg: InlineAsmRegOrRegClass, layout: Option<&TyAndLayout<'tcx>>)
  | InlineAsmRegClass::X86(X86InlineAsmRegClass::ymm_reg) => "x",
  InlineAsmRegClass::X86(X86InlineAsmRegClass::zmm_reg) => "v",
  InlineAsmRegClass::X86(X86InlineAsmRegClass::kreg) => "^Yk",
+ InlineAsmRegClass::SpirV(SpirVInlineAsmRegClass::reg) => {
+ bug!("LLVM backend does not support SPIR-V")
+ }
  }
  .to_string(),
  }
@@ -580,6 +584,9 @@ fn modifier_to_llvm(
  _ => unreachable!(),
  },
  InlineAsmRegClass::X86(X86InlineAsmRegClass::kreg) => None,
+ InlineAsmRegClass::SpirV(SpirVInlineAsmRegClass::reg) => {
+ bug!("LLVM backend does not support SPIR-V")
+ }
  }
 }
 
@@ -619,6 +626,9 @@ fn dummy_output_type(cx: &CodegenCx<'ll, 'tcx>, reg: InlineAsmRegClass) -> &'ll
  | InlineAsmRegClass::X86(X86InlineAsmRegClass::ymm_reg)
  | InlineAsmRegClass::X86(X86InlineAsmRegClass::zmm_reg) => cx.type_f32(),
  InlineAsmRegClass::X86(X86InlineAsmRegClass::kreg) => cx.type_i16(),
+ InlineAsmRegClass::SpirV(SpirVInlineAsmRegClass::reg) => {
+ bug!("LLVM backend does not support SPIR-V")
+ }
  }
 }
 

compiler/rustc_target/src/asm/mod.rs

@@ -155,6 +155,7 @@ mod hexagon;
 mod mips;
 mod nvptx;
 mod riscv;
+mod spirv;
 mod x86;
 
 pub use aarch64::{AArch64InlineAsmReg, AArch64InlineAsmRegClass};
@@ -163,6 +164,7 @@ pub use hexagon::{HexagonInlineAsmReg, HexagonInlineAsmRegClass};
 pub use mips::{MipsInlineAsmReg, MipsInlineAsmRegClass};
 pub use nvptx::{NvptxInlineAsmReg, NvptxInlineAsmRegClass};
 pub use riscv::{RiscVInlineAsmReg, RiscVInlineAsmRegClass};
+pub use spirv::{SpirVInlineAsmReg, SpirVInlineAsmRegClass};
 pub use x86::{X86InlineAsmReg, X86InlineAsmRegClass};
 
 #[derive(Copy, Clone, Encodable, Decodable, Debug, Eq, PartialEq, Hash)]
@@ -177,6 +179,7 @@ pub enum InlineAsmArch {
  Hexagon,
  Mips,
  Mips64,
+ SpirV,
 }
 
 impl FromStr for InlineAsmArch {
@@ -194,6 +197,7 @@ impl FromStr for InlineAsmArch {
  "hexagon" => Ok(Self::Hexagon),
  "mips" => Ok(Self::Mips),
  "mips64" => Ok(Self::Mips64),
+ "spirv" => Ok(Self::SpirV),
  _ => Err(()),
  }
  }
@@ -208,6 +212,7 @@ pub enum InlineAsmReg {
  Nvptx(NvptxInlineAsmReg),
  Hexagon(HexagonInlineAsmReg),
  Mips(MipsInlineAsmReg),
+ SpirV(SpirVInlineAsmReg),
 }
 
 impl InlineAsmReg {
@@ -264,6 +269,9 @@ impl InlineAsmReg {
  InlineAsmArch::Mips | InlineAsmArch::Mips64 => {
  Self::Mips(MipsInlineAsmReg::parse(arch, has_feature, target, &name)?)
  }
+ InlineAsmArch::SpirV => {
+ Self::SpirV(SpirVInlineAsmReg::parse(arch, has_feature, target, &name)?)
+ }
  })
  }
 
@@ -306,6 +314,7 @@ pub enum InlineAsmRegClass {
  Nvptx(NvptxInlineAsmRegClass),
  Hexagon(HexagonInlineAsmRegClass),
  Mips(MipsInlineAsmRegClass),
+ SpirV(SpirVInlineAsmRegClass),
 }
 
 impl InlineAsmRegClass {
@@ -318,6 +327,7 @@ impl InlineAsmRegClass {
  Self::Nvptx(r) => r.name(),
  Self::Hexagon(r) => r.name(),
  Self::Mips(r) => r.name(),
+ Self::SpirV(r) => r.name(),
  }
  }
 
@@ -333,6 +343,7 @@ impl InlineAsmRegClass {
  Self::Nvptx(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::Nvptx),
  Self::Hexagon(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::Hexagon),
  Self::Mips(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::Mips),
+ Self::SpirV(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::SpirV),
  }
  }
 
@@ -355,6 +366,7 @@ impl InlineAsmRegClass {
  Self::Nvptx(r) => r.suggest_modifier(arch, ty),
  Self::Hexagon(r) => r.suggest_modifier(arch, ty),
  Self::Mips(r) => r.suggest_modifier(arch, ty),
+ Self::SpirV(r) => r.suggest_modifier(arch, ty),
  }
  }
 
@@ -373,6 +385,7 @@ impl InlineAsmRegClass {
  Self::Nvptx(r) => r.default_modifier(arch),
  Self::Hexagon(r) => r.default_modifier(arch),
  Self::Mips(r) => r.default_modifier(arch),
+ Self::SpirV(r) => r.default_modifier(arch),
  }
  }
 
@@ -390,6 +403,7 @@ impl InlineAsmRegClass {
  Self::Nvptx(r) => r.supported_types(arch),
  Self::Hexagon(r) => r.supported_types(arch),
  Self::Mips(r) => r.supported_types(arch),
+ Self::SpirV(r) => r.supported_types(arch),
  }
  }
 
@@ -414,6 +428,7 @@ impl InlineAsmRegClass {
  InlineAsmArch::Mips | InlineAsmArch::Mips64 => {
  Self::Mips(MipsInlineAsmRegClass::parse(arch, name)?)
  }
+ InlineAsmArch::SpirV => Self::SpirV(SpirVInlineAsmRegClass::parse(arch, name)?),
  })
  })
  }
@@ -429,6 +444,7 @@ impl InlineAsmRegClass {
  Self::Nvptx(r) => r.valid_modifiers(arch),
  Self::Hexagon(r) => r.valid_modifiers(arch),
  Self::Mips(r) => r.valid_modifiers(arch),
+ Self::SpirV(r) => r.valid_modifiers(arch),
  }
  }
 }
@@ -571,5 +587,10 @@ pub fn allocatable_registers(
  mips::fill_reg_map(arch, has_feature, target, &mut map);
  map
  }
+ InlineAsmArch::SpirV => {
+ let mut map = spirv::regclass_map();
+ spirv::fill_reg_map(arch, has_feature, target, &mut map);
+ map
+ }
  }
 }

compiler/rustc_target/src/asm/spirv.rs

@@ -0,0 +1,46 @@
+use super::{InlineAsmArch, InlineAsmType};
+use rustc_macros::HashStable_Generic;
+
+def_reg_class! {
+ SpirV SpirVInlineAsmRegClass {
+ reg,
+ }
+}
+
+impl SpirVInlineAsmRegClass {
+ pub fn valid_modifiers(self, _arch: super::InlineAsmArch) -> &'static [char] {
+ &[]
+ }
+
+ pub fn suggest_class(self, _arch: InlineAsmArch, _ty: InlineAsmType) -> Option<Self> {
+ None
+ }
+
+ pub fn suggest_modifier(
+ self,
+ _arch: InlineAsmArch,
+ _ty: InlineAsmType,
+ ) -> Option<(char, &'static str)> {
+ None
+ }
+
+ pub fn default_modifier(self, _arch: InlineAsmArch) -> Option<(char, &'static str)> {
+ None
+ }
+
+ pub fn supported_types(
+ self,
+ _arch: InlineAsmArch,
+ ) -> &'static [(InlineAsmType, Option<&'static str>)] {
+ match self {
+ Self::reg => {
+ types! { _: I8, I16, I32, I64, F32, F64; }
+ }
+ }
+ }
+}
+
+def_regs! {
+ // SPIR-V is SSA-based, it does not have registers.
+ SpirV SpirVInlineAsmReg SpirVInlineAsmRegClass {}
+}