Add Const Generic Image Type

Cargo.toml

@@ -12,6 +12,8 @@ members = [
     "crates/rustc_codegen_spirv",
     "crates/spirv-builder",
     "crates/spirv-std",
+    "crates/spirv-std/shared",
+    "crates/spirv-std/macros",
 
     "tests",
     "tests/deps-helper",
@@ -34,7 +36,7 @@ codegen-units = 256
 
 [patch.crates-io]
 spirv-std = { path = "./crates/spirv-std" }
-spirv-std-macros = { path = "./crates/spirv-std-macros" }
+spirv-std-macros = { path = "./crates/spirv-std/macros" }
 # TODO: Remove once next version is released - needed to include these two PRs:
 # * Manishearth/compiletest-rs#240 (for handling SPIR-V extension across platforms)
 # * Manishearth/compiletest-rs#241 (for the `$TEST_BUILD_DIR` path normalization)

crates/rustc_codegen_spirv/src/abi.rs

@@ -10,7 +10,9 @@ use rustc_errors::ErrorReported;
 use rustc_middle::bug;
 use rustc_middle::ty::layout::{FnAbiExt, TyAndLayout};
 use rustc_middle::ty::subst::SubstsRef;
-use rustc_middle::ty::{GeneratorSubsts, PolyFnSig, Ty, TyKind, TypeAndMut};
+use rustc_middle::ty::{
+    Const, FloatTy, GeneratorSubsts, IntTy, ParamEnv, PolyFnSig, Ty, TyKind, TypeAndMut, UintTy,
+};
 use rustc_span::def_id::DefId;
 use rustc_span::Span;
 use rustc_target::abi::call::{CastTarget, FnAbi, PassMode, Reg, RegKind};
@@ -21,6 +23,9 @@ use std::cell::RefCell;
 use std::collections::hash_map::Entry;
 use std::fmt;
 
+use num_traits::cast::FromPrimitive;
+use rspirv::spirv;
+
 /// If a struct contains a pointer to itself, even indirectly, then doing a naiive recursive walk
 /// of the fields will result in an infinite loop. Because pointers are the only thing that are
 /// allowed to be recursive, keep track of what pointers we've translated, or are currently in the
@@ -768,6 +773,94 @@ fn trans_intrinsic_type<'tcx>(
             }
             // Hardcode to float for now
             let sampled_type = SpirvType::Float(32).def(span, cx);
+
+            let ty = SpirvType::Image {
+                sampled_type,
+                dim,
+                depth,
+                arrayed,
+                multisampled,
+                sampled,
+                image_format,
+                access_qualifier,
+            };
+
+            Ok(ty.def(span, cx))
+        }
+        IntrinsicType::GenericImageType => {
+            // see SpirvType::sizeof
+            if ty.size != Size::from_bytes(4) {
+                cx.tcx
+                    .sess
+                    .err("#[spirv(generic_image)] type must have size 4");
+                return Err(ErrorReported);
+            }
+
+            fn type_from_variant_discriminant<'tcx, P: FromPrimitive>(
+                cx: &CodegenCx<'tcx>,
+                const_: &'tcx Const<'tcx>,
+            ) -> P {
+                let adt_def = const_.ty.ty_adt_def().unwrap();
+                assert!(adt_def.is_enum());
+                let destructured = cx.tcx.destructure_const(ParamEnv::reveal_all().and(const_));
+                let idx = destructured.variant.unwrap();
+                let value = const_.ty.discriminant_for_variant(cx.tcx, idx).unwrap().val as u64;
+                <_>::from_u64(value).unwrap()
+            }
+
+            let sampled_type = match substs.type_at(0).kind() {
+                TyKind::Int(int) => match int {
+                    IntTy::Isize => {
+                        SpirvType::Integer(cx.tcx.data_layout.pointer_size.bits() as u32, true)
+                            .def(span, cx)
+                    }
+                    IntTy::I8 => SpirvType::Integer(8, true).def(span, cx),
+                    IntTy::I16 => SpirvType::Integer(16, true).def(span, cx),
+                    IntTy::I32 => SpirvType::Integer(32, true).def(span, cx),
+                    IntTy::I64 => SpirvType::Integer(64, true).def(span, cx),
+                    IntTy::I128 => SpirvType::Integer(128, true).def(span, cx),
+                },
+                TyKind::Uint(uint) => match uint {
+                    UintTy::Usize => {
+                        SpirvType::Integer(cx.tcx.data_layout.pointer_size.bits() as u32, false)
+                            .def(span, cx)
+                    }
+                    UintTy::U8 => SpirvType::Integer(8, false).def(span, cx),
+                    UintTy::U16 => SpirvType::Integer(16, false).def(span, cx),
+                    UintTy::U32 => SpirvType::Integer(32, false).def(span, cx),
+                    UintTy::U64 => SpirvType::Integer(64, false).def(span, cx),
+                    UintTy::U128 => SpirvType::Integer(128, false).def(span, cx),
+                },
+                TyKind::Float(FloatTy::F32) => SpirvType::Float(32).def(span, cx),
+                TyKind::Float(FloatTy::F64) => SpirvType::Float(64).def(span, cx),
+                _ => {
+                    cx.tcx
+                        .sess
+                        .span_err(span, "Invalid sampled type to `Image`.");
+                    return Err(ErrorReported);
+                }
+            };
+
+            let dim: spirv::Dim = type_from_variant_discriminant(cx, substs.const_at(1));
+            let depth: u32 = type_from_variant_discriminant(cx, substs.const_at(2));
+            let arrayed: u32 = type_from_variant_discriminant(cx, substs.const_at(3));
+            let multisampled: u32 = type_from_variant_discriminant(cx, substs.const_at(4));
+            let sampled: u32 = type_from_variant_discriminant(cx, substs.const_at(5));
+            let image_format: spirv::ImageFormat =
+                type_from_variant_discriminant(cx, substs.const_at(6));
+
+            let access_qualifier = {
+                let option = cx
+                    .tcx
+                    .destructure_const(ParamEnv::reveal_all().and(substs.const_at(7)));
+
+                match option.variant.map(|i| i.as_u32()).unwrap_or(0) {
+                    0 => None,
+                    1 => Some(type_from_variant_discriminant(cx, option.fields[0])),
+                    _ => unreachable!(),
+                }
+            };
+
             let ty = SpirvType::Image {
                 sampled_type,
                 dim,

crates/rustc_codegen_spirv/src/attr.rs

@@ -61,6 +61,7 @@ impl From<ExecutionModel> for Entry {
 /// `struct` types that are used to represent special SPIR-V types.
 #[derive(Debug, Clone)]
 pub enum IntrinsicType {
+    GenericImageType,
     ImageType {
         dim: Dim,
         depth: u32,

crates/rustc_codegen_spirv/src/symbols.rs

@@ -317,6 +317,10 @@ impl Symbols {
                 "sampler",
                 SpirvAttribute::IntrinsicType(IntrinsicType::Sampler),
             ),
+            (
+                "generic_image_type",
+                SpirvAttribute::IntrinsicType(IntrinsicType::GenericImageType),
+            ),
             (
                 "acceleration_structure",
                 SpirvAttribute::IntrinsicType(IntrinsicType::AccelerationStructureKhr),

crates/spirv-builder/src/lib.rs

@@ -204,7 +204,7 @@ fn invoke_rustc(builder: &SpirvBuilder, multimodule: bool) -> Result<PathBuf, Sp
         .unwrap_or_default();
 
     let rustflags = format!(
-        "-Z codegen-backend={} -Z symbol-mangling-version=v0{}",
+        "-Z codegen-backend={} -Zsymbol-mangling-version=v0{}",
         rustc_codegen_spirv.display(),
         llvm_args,
     );

crates/spirv-std/Cargo.toml

@@ -10,7 +10,8 @@ description = "Standard functions and types for SPIR-V"
 [dependencies]
 bitflags = "1.2.1"
 num-traits = { version = "0.2.14", default-features = false, features = ["libm"] }
-spirv-std-macros = { path = "../spirv-std-macros", version = "0.4.0-alpha.0" }
+spirv-types = { path = "./shared", version = "0.4.0-alpha.3" }
+spirv-std-macros = { path = "./macros", version = "0.4.0-alpha.3" }
 
 [features]
 default = []

crates/spirv-std-macros/Cargo.toml → crates/spirv-std/macros/Cargo.toml

@@ -11,6 +11,8 @@ description = "Macros for spirv-std"
 proc-macro = true
 
 [dependencies]
+spirv-types = { path = "../shared", version = "0.4.0-alpha.3" }
+heck = "0.3.2"
 proc-macro2 = "1.0.24"
 quote = "1.0.8"
 syn = { version = "1.0.58", features=["full"] }