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 = "1f225ed" }
 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

@@ -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"),
         }
     }
 }

crates/rustc_codegen_spirv/src/spirv_type.rs

@@ -727,15 +727,15 @@ pub fn instruction_signatures(op: Op) -> Option<&'static [InstSig<'static>]> {
         | Op::ExecuteCallableKHR
         | Op::ConvertUToAccelerationStructureKHR
         | Op::IgnoreIntersectionKHR
-        | Op::TerminateRayKHR => reserved!(SPV_KHR_ray_tracing),
+        | Op::TerminateRayKHR => {}
         // SPV_KHR_ray_query
         Op::TypeRayQueryKHR
         | Op::RayQueryInitializeKHR
         | Op::RayQueryTerminateKHR
         | Op::RayQueryGenerateIntersectionKHR
         | Op::RayQueryConfirmIntersectionKHR
         | Op::RayQueryProceedKHR
-        | Op::RayQueryGetIntersectionTypeKHR => reserved!(SPV_KHR_ray_query),
+        | Op::RayQueryGetIntersectionTypeKHR => {}
         // SPV_AMD_shader_fragment_mask
         Op::FragmentMaskFetchAMD | Op::FragmentFetchAMD => reserved!(SPV_AMD_shader_fragment_mask),
         // SPV_KHR_shader_clock
@@ -748,7 +748,7 @@ pub fn instruction_signatures(op: Op) -> Option<&'static [InstSig<'static>]> {
         | Op::TerminateRayNV
         | Op::TraceNV
         | Op::TypeAccelerationStructureNV
-        | Op::ExecuteCallableNV => reserved!(SPV_NV_ray_tracing),
+        | Op::ExecuteCallableNV => {}
         // SPV_NV_cooperative_matrix
         Op::TypeCooperativeMatrixNV
         | Op::CooperativeMatrixLoadNV

crates/rustc_codegen_spirv/src/spirv_type_constraints.rs

@@ -129,21 +129,21 @@ const BUILTINS: &[(&str, BuiltIn)] = {
         ("bary_coord_no_persp_nv", BaryCoordNoPerspNV),
         ("frag_size_ext", FragSizeEXT),
         ("frag_invocation_count_ext", FragInvocationCountEXT),
-        ("launch_id_nv", LaunchIdNV),
-        ("launch_size_nv", LaunchSizeNV),
-        ("world_ray_origin_nv", WorldRayOriginNV),
-        ("world_ray_direction_nv", WorldRayDirectionNV),
-        ("object_ray_origin_nv", ObjectRayOriginNV),
-        ("object_ray_direction_nv", ObjectRayDirectionNV),
-        ("ray_tmin_nv", RayTminNV),
-        ("ray_tmax_nv", RayTmaxNV),
-        ("instance_custom_index_nv", InstanceCustomIndexNV),
-        ("object_to_world_nv", ObjectToWorldNV),
-        ("world_to_object_nv", WorldToObjectNV),
-        ("hit_t_nv", HitTNV),
-        ("hit_kind_nv", HitKindNV),
-        ("incoming_ray_flags_nv", IncomingRayFlagsNV),
+        ("launch_id_khr", LaunchIdNV),
+        ("launch_size_khr", LaunchSizeNV),
+        ("instance_custom_index_khr", InstanceCustomIndexNV),
         ("ray_geometry_index_khr", RayGeometryIndexKHR),
+        ("world_ray_origin_khr", WorldRayOriginNV),
+        ("world_ray_direction_khr", WorldRayDirectionNV),
+        ("object_ray_origin_khr", ObjectRayOriginNV),
+        ("object_ray_direction_khr", ObjectRayDirectionNV),
+        ("ray_tmin_khr", RayTminNV),
+        ("ray_tmax_khr", RayTmaxNV),
+        ("object_to_world_khr", ObjectToWorldNV),
+        ("world_to_object_khr", WorldToObjectNV),
+        ("hit_kind_khr", HitKindNV),
+        ("incoming_ray_flags_khr", IncomingRayFlagsNV),
+        ("hit_t_nv", HitTNV),
         ("warps_per_sm_nv", WarpsPerSMNV),
         ("sm_count_nv", SMCountNV),
         ("warp_id_nv", WarpIDNV),
@@ -198,12 +198,12 @@ const EXECUTION_MODELS: &[(&str, ExecutionModel)] = {
         ("kernel", Kernel),
         ("task_nv", TaskNV),
         ("mesh_nv", MeshNV),
-        ("ray_generation_nv", RayGenerationNV),
-        ("intersection_nv", IntersectionNV),
-        ("any_hit_nv", AnyHitNV),
-        ("closest_hit_nv", ClosestHitNV),
-        ("miss_nv", MissNV),
-        ("callable_nv", CallableNV),
+        ("ray_generation_khr", RayGenerationNV),
+        ("intersection_khr", IntersectionNV),
+        ("any_hit_khr", AnyHitNV),
+        ("closest_hit_khr", ClosestHitNV),
+        ("miss_khr", MissNV),
+        ("callable_khr", CallableNV),
     ]
 };
 
@@ -334,6 +334,10 @@ impl Symbols {
                 "sampler",
                 SpirvAttribute::IntrinsicType(IntrinsicType::Sampler),
             ),
+            (
+                "acceleration_structure_khr",
+                SpirvAttribute::IntrinsicType(IntrinsicType::AccelerationStructureKhr),
+            ),
             ("block", SpirvAttribute::Block),
             ("flat", SpirvAttribute::Flat),
             ("invariant", SpirvAttribute::Invariant),