Implement ByteAddressableBuffer prototype detached from bindless (#735)

Author: khyperia

crates/rustc_codegen_spirv/src/attr.rs

@@ -90,6 +90,8 @@ pub enum SpirvAttribute {
 
     // `fn`/closure attributes:
     UnrollLoops,
+    BufferLoadIntrinsic,
+    BufferStoreIntrinsic,
 }
 
 // HACK(eddyb) this is similar to `rustc_span::Spanned` but with `value` as the
@@ -123,6 +125,8 @@ pub struct AggregatedSpirvAttributes {
 
     // `fn`/closure attributes:
     pub unroll_loops: Option<Spanned<()>>,
+    pub buffer_load_intrinsic: Option<Spanned<()>>,
+    pub buffer_store_intrinsic: Option<Spanned<()>>,
 }
 
 struct MultipleAttrs {
@@ -210,6 +214,18 @@ impl AggregatedSpirvAttributes {
                 "#[spirv(attachment_index)]",
             ),
             UnrollLoops => try_insert(&mut self.unroll_loops, (), span, "#[spirv(unroll_loops)]"),
+            BufferLoadIntrinsic => try_insert(
+                &mut self.buffer_load_intrinsic,
+                (),
+                span,
+                "#[spirv(buffer_load_intrinsic)]",
+            ),
+            BufferStoreIntrinsic => try_insert(
+                &mut self.buffer_store_intrinsic,
+                (),
+                span,
+                "#[spirv(buffer_store_intrinsic)]",
+            ),
         }
     }
 }
@@ -343,6 +359,12 @@ impl CheckSpirvAttrVisitor<'_> {
 
                     _ => Err(Expected("function or closure")),
                 },
+                SpirvAttribute::BufferLoadIntrinsic | SpirvAttribute::BufferStoreIntrinsic => {
+                    match target {
+                        Target::Fn => Ok(()),
+                        _ => Err(Expected("function")),
+                    }
+                }
             };
             match valid_target {
                 Err(Expected(expected_target)) => self.tcx.sess.span_err(

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -1850,8 +1850,8 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
             | SpirvType::Vector { element, .. }
             | SpirvType::Matrix { element, .. } => element,
             other => self.fatal(&format!(
-                "extract_value not implemented on type {:?}",
-                other
+                "extract_value not implemented on type {}",
+                other.debug(agg_val.ty, self)
             )),
         };
         self.emit()
@@ -2201,6 +2201,24 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
             // needing to materialize `&core::panic::Location` or `format_args!`.
             self.abort();
             self.undef(result_type)
+        } else if self
+            .buffer_load_intrinsic_fn_id
+            .borrow()
+            .contains(&callee_val)
+        {
+            self.codegen_buffer_load_intrinsic(result_type, args)
+        } else if self
+            .buffer_store_intrinsic_fn_id
+            .borrow()
+            .contains(&callee_val)
+        {
+            self.codegen_buffer_store_intrinsic(args);
+
+            let void_ty = SpirvType::Void.def(rustc_span::DUMMY_SP, self);
+            SpirvValue {
+                kind: SpirvValueKind::IllegalTypeUsed(void_ty),
+                ty: void_ty,
+            }
         } else {
             let args = args.iter().map(|arg| arg.def(self)).collect::<Vec<_>>();
             self.emit()