Add support for SPV_KHR_ray_tracing

Author: XAMPPRocky

Cargo.lock

@@ -37,7 +37,7 @@ syn = { version = "1", features = ["visit", "visit-mut"] }
 # Normal dependencies.
 bimap = "0.6"
 indexmap = "1.6.0"
-rspirv = { git = "https://github.com/gfx-rs/rspirv.git", rev = "ee1e913" }
+rspirv = { git = "https://github.com/EmbarkStudios/rspirv.git", rev = "7c72c65" }
 rustc-demangle = "0.1.18"
 sanitize-filename = "0.3"
 serde = { version = "1.0", features = ["derive"] }

crates/rustc_codegen_spirv/Cargo.toml

@@ -825,6 +825,9 @@ fn trans_intrinsic_type<'tcx>(
             }
             Ok(SpirvType::Sampler.def(span, cx))
         }
+        IntrinsicType::AccelerationStructureKhr => {
+            Ok(SpirvType::AccelerationStructureKhr.def(span, cx))
+        }
         IntrinsicType::SampledImage => {
             // see SpirvType::sizeof
             if ty.size != Size::from_bytes(4) {

crates/rustc_codegen_spirv/src/abi.rs

@@ -71,6 +71,7 @@ pub enum IntrinsicType {
         access_qualifier: Option<AccessQualifier>,
     },
     Sampler,
+    AccelerationStructureKhr,
     SampledImage,
 }
 

crates/rustc_codegen_spirv/src/attr.rs

@@ -232,6 +232,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             SpirvType::Image { .. } => self.fatal("cannot memset image"),
             SpirvType::Sampler => self.fatal("cannot memset sampler"),
             SpirvType::SampledImage { .. } => self.fatal("cannot memset sampled image"),
+            SpirvType::AccelerationStructureKhr => {
+                self.fatal("cannot memset acceleration structure")
+            }
         }
     }
 
@@ -288,6 +291,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             SpirvType::Image { .. } => self.fatal("cannot memset image"),
             SpirvType::Sampler => self.fatal("cannot memset sampler"),
             SpirvType::SampledImage { .. } => self.fatal("cannot memset sampled image"),
+            SpirvType::AccelerationStructureKhr => {
+                self.fatal("cannot memset acceleration structure")
+            }
         }
     }
 

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -524,6 +524,10 @@ impl<'tcx> CodegenCx<'tcx> {
                 .tcx
                 .sess
                 .fatal("Cannot create a constant sampled image value"),
+            SpirvType::AccelerationStructureKhr => self
+                .tcx
+                .sess
+                .fatal("Cannot create a constant acceleration structure"),
         }
     }
 }

crates/rustc_codegen_spirv/src/codegen_cx/constant.rs

@@ -174,9 +174,11 @@ impl<'tcx> BaseTypeMethods<'tcx> for CodegenCx<'tcx> {
             SpirvType::Function { .. } => TypeKind::Function,
             // HACK(eddyb) this is probably the closest `TypeKind` (which is still
             // very much LLVM-specific, sadly) has to offer to "resource handle".
-            SpirvType::Image { .. } |
-            SpirvType::Sampler |
-            SpirvType::SampledImage { .. } => TypeKind::Token,
+            | SpirvType::Image { .. }
+            | SpirvType::Sampler
+            | SpirvType::SampledImage { .. }
+            | SpirvType::AccelerationStructureKhr
+                => TypeKind::Token,
         }
     }
     fn type_ptr_to(&self, ty: Self::Type) -> Self::Type {

crates/rustc_codegen_spirv/src/codegen_cx/type_.rs

@@ -168,7 +168,12 @@ impl Structurizer<'_> {
             let block_id = self.func.blocks()[block].label_id().unwrap();
             let terminator = self.func.blocks()[block].instructions.last().unwrap();
             let mut region = match terminator.class.opcode {
-                Op::Return | Op::ReturnValue | Op::Kill | Op::Unreachable => Region {
+                Op::Return
+                | Op::ReturnValue
+                | Op::Kill
+                | Op::IgnoreIntersectionKHR
+                | Op::TerminateRayKHR
+                | Op::Unreachable => Region {
                     merge: block,
                     merge_id: block_id,
                     exits: indexmap! {},

crates/rustc_codegen_spirv/src/linker/new_structurizer.rs

@@ -98,7 +98,12 @@ pub fn outgoing_edges(block: &Block) -> Vec<Word> {
                     .map(|op| op.unwrap_id_ref()),
             )
             .collect(),
-        Op::Return | Op::ReturnValue | Op::Kill | Op::Unreachable => Vec::new(),
+        Op::Return
+        | Op::ReturnValue
+        | Op::Kill
+        | Op::Unreachable
+        | Op::IgnoreIntersectionKHR
+        | Op::TerminateRayKHR => Vec::new(),
         _ => panic!("Invalid block terminator: {:?}", terminator),
     }
 }

crates/rustc_codegen_spirv/src/linker/simple_passes.rs

@@ -80,6 +80,7 @@ pub enum SpirvType {
     SampledImage {
         image_type: Word,
     },
+    AccelerationStructureKhr,
 }
 
 impl SpirvType {
@@ -247,6 +248,7 @@ impl SpirvType {
                 access_qualifier,
             ),
             Self::Sampler => cx.emit_global().type_sampler(),
+            Self::AccelerationStructureKhr => cx.emit_global().type_acceleration_structure_khr(),
             Self::SampledImage { image_type } => cx.emit_global().type_sampled_image(image_type),
         };
         cx.type_cache.def(result, self);
@@ -320,7 +322,8 @@ impl SpirvType {
             Self::Void
             | Self::Opaque { .. }
             | Self::RuntimeArray { .. }
-            | Self::Function { .. } => return None,
+            | Self::Function { .. }
+            | Self::AccelerationStructureKhr => return None,
 
             Self::Bool => Size::from_bytes(1),
             Self::Integer(width, _) | Self::Float(width) => Size::from_bits(width),
@@ -340,9 +343,10 @@ impl SpirvType {
     pub fn alignof<'tcx>(&self, cx: &CodegenCx<'tcx>) -> Align {
         match *self {
             // Types that have no concept of size or alignment.
-            Self::Void | Self::Opaque { .. } | Self::Function { .. } => {
-                Align::from_bytes(0).unwrap()
-            }
+            Self::Void
+            | Self::Opaque { .. }
+            | Self::Function { .. }
+            | Self::AccelerationStructureKhr => Align::from_bytes(0).unwrap(),
 
             Self::Bool => Align::from_bytes(1).unwrap(),
             Self::Integer(width, _) | Self::Float(width) => Align::from_bits(width as u64).unwrap(),
@@ -499,6 +503,9 @@ impl fmt::Debug for SpirvTypePrinter<'_, '_> {
                 .field("id", &self.id)
                 .field("image_type", &self.cx.debug_type(image_type))
                 .finish(),
+            SpirvType::AccelerationStructureKhr => {
+                f.debug_struct("AccelerationStructureKhr").finish()
+            }
         };
         {
             let mut debug_stack = DEBUG_STACK.lock().unwrap();
@@ -654,6 +661,7 @@ impl SpirvTypePrinter<'_, '_> {
                 .debug_struct("SampledImage")
                 .field("image_type", &self.cx.debug_type(image_type))
                 .finish(),
+            SpirvType::AccelerationStructureKhr => f.write_str("AccelerationStructureKhr"),
         }
     }
 }