ByteAddressableBuffer: remove mut variant, make ByteAddressableBuffer generic on mutability

Author: Firestar99

crates/spirv-std/src/byte_addressable_buffer.rs

@@ -43,15 +43,16 @@ unsafe fn buffer_store_intrinsic<T>(
         .write(value);
 }
 
-/// `ByteAddressableBuffer` is a read-only untyped blob of data, allowing loads
-/// of arbitrary basic data types at arbitrary indices. See
-/// [`MutByteAddressableBuffer`] for a writeable variant.
+/// `ByteAddressableBuffer` is a view to an untyped blob of data, allowing
+/// loads and stores of arbitrary basic data types at arbitrary indices. Use
+/// `from_slice()` or `from_mut_slice()` to create the `ByteAddressableBuffer`,
+/// with only the mutable slice allowing stores.
 ///
 /// # Alignment
 /// All data must be aligned to size 4, each element within the data (e.g.
 /// struct fields) must have a size and alignment of a multiple of 4, and the
 /// `byte_index` passed to load and store must be a multiple of 4. Technically
-/// it's not a *byte* addressable buffer, but rather a *word* buffer, but this
+/// it is not a *byte* addressable buffer, but rather a *word* buffer, but this
 /// naming and behavior was inherited from HLSL (where it's UB to pass in an
 /// index not a multiple of 4).
 ///
@@ -61,15 +62,15 @@ unsafe fn buffer_store_intrinsic<T>(
 /// allowing all sorts of safety guarantees to be bypassed (effectively a
 /// transmute).
 #[repr(transparent)]
-pub struct ByteAddressableBuffer<'a> {
+pub struct ByteAddressableBuffer<T> {
     /// The underlying array of bytes, able to be directly accessed.
-    pub data: &'a [u32],
+    pub data: T,
 }
 
-impl<'a> ByteAddressableBuffer<'a> {
+impl<'a> ByteAddressableBuffer<&'a [u32]> {
     /// Creates a `ByteAddressableBuffer` from the untyped blob of data.
     #[inline]
-    pub fn new(data: &'a [u32]) -> Self {
+    pub fn from_slice(data: &'a [u32]) -> Self {
         Self { data }
     }
 
@@ -102,19 +103,10 @@ impl<'a> ByteAddressableBuffer<'a> {
     }
 }
 
-/// `MutByteAddressableBuffer` is a mutable untyped blob of data, allowing
-/// loads and stores of arbitrary basic data types at arbitrary indices. See
-/// [`ByteAddressableBuffer`] for details.
-#[repr(transparent)]
-pub struct MutByteAddressableBuffer<'a> {
-    /// The underlying array of bytes, able to be directly accessed.
-    pub data: &'a mut [u32],
-}
-
-impl<'a> MutByteAddressableBuffer<'a> {
+impl<'a> ByteAddressableBuffer<&'a mut [u32]> {
     /// Creates a `ByteAddressableBuffer` from the untyped blob of data.
     #[inline]
-    pub fn new(data: &'a mut [u32]) -> Self {
+    pub fn from_mut_slice(data: &'a mut [u32]) -> Self {
         Self { data }
     }
 

crates/spirv-std/src/lib.rs

@@ -112,13 +112,10 @@ pub mod vector;
 
 pub use self::sampler::Sampler;
 pub use crate::macros::Image;
+pub use byte_addressable_buffer::ByteAddressableBuffer;
 pub use num_traits;
 pub use runtime_array::*;
 pub use typed_buffer::*;
-pub use {
-    byte_addressable_buffer::ByteAddressableBuffer,
-    byte_addressable_buffer::MutByteAddressableBuffer,
-};
 
 pub use glam;
 

tests/ui/arch/debug_printf_type_checking.stderr

@@ -75,9 +75,9 @@ help: the return type of this call is `u32` due to the type of the argument pass
     |                             |
     |                             this argument influences the return type of `spirv_std`
 note: function defined here
-   --> $SPIRV_STD_SRC/lib.rs:141:8
+   --> $SPIRV_STD_SRC/lib.rs:138:8
     |
-141 | pub fn debug_printf_assert_is_type<T>(ty: T) -> T {
+138 | pub fn debug_printf_assert_is_type<T>(ty: T) -> T {
     |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = note: this error originates in the macro `debug_printf` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: change the type of the numeric literal from `u32` to `f32`
@@ -102,9 +102,9 @@ help: the return type of this call is `f32` due to the type of the argument pass
     |                             |
     |                             this argument influences the return type of `spirv_std`
 note: function defined here
-   --> $SPIRV_STD_SRC/lib.rs:141:8
+   --> $SPIRV_STD_SRC/lib.rs:138:8
     |
-141 | pub fn debug_printf_assert_is_type<T>(ty: T) -> T {
+138 | pub fn debug_printf_assert_is_type<T>(ty: T) -> T {
     |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = note: this error originates in the macro `debug_printf` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: change the type of the numeric literal from `f32` to `u32`
@@ -129,12 +129,12 @@ error[E0277]: the trait bound `{float}: Vector<f32, 2>` is not satisfied
               <UVec3 as Vector<u32, 3>>
             and 5 others
 note: required by a bound in `debug_printf_assert_is_vector`
-   --> $SPIRV_STD_SRC/lib.rs:148:8
+   --> $SPIRV_STD_SRC/lib.rs:145:8
     |
-146 | pub fn debug_printf_assert_is_vector<
+143 | pub fn debug_printf_assert_is_vector<
     |        ----------------------------- required by a bound in this function
-147 |     TY: crate::scalar::Scalar,
-148 |     V: crate::vector::Vector<TY, SIZE>,
+144 |     TY: crate::scalar::Scalar,
+145 |     V: crate::vector::Vector<TY, SIZE>,
     |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `debug_printf_assert_is_vector`
     = note: this error originates in the macro `debug_printf` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -155,9 +155,9 @@ help: the return type of this call is `Vec2` due to the type of the argument pas
     |                             |
     |                             this argument influences the return type of `spirv_std`
 note: function defined here
-   --> $SPIRV_STD_SRC/lib.rs:141:8
+   --> $SPIRV_STD_SRC/lib.rs:138:8
     |
-141 | pub fn debug_printf_assert_is_type<T>(ty: T) -> T {
+138 | pub fn debug_printf_assert_is_type<T>(ty: T) -> T {
     |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = note: this error originates in the macro `debug_printf` (in Nightly builds, run with -Z macro-backtrace for more info)
 

tests/ui/byte_addressable_buffer/arr.rs

@@ -1,15 +1,26 @@
 // build-pass
 
 use spirv_std::spirv;
-use spirv_std::{glam::Vec4, ByteAddressableBuffer, MutByteAddressableBuffer};
+use spirv_std::{glam::Vec4, ByteAddressableBuffer};
 
 #[spirv(fragment)]
 pub fn load(
+    #[spirv(descriptor_set = 0, binding = 0, storage_buffer)] buf: &[u32],
+    out: &mut [i32; 4],
+) {
+    unsafe {
+        let buf = ByteAddressableBuffer::from_slice(buf);
+        *out = buf.load(5);
+    }
+}
+
+#[spirv(fragment)]
+pub fn load_mut(
     #[spirv(descriptor_set = 0, binding = 0, storage_buffer)] buf: &mut [u32],
     out: &mut [i32; 4],
 ) {
     unsafe {
-        let buf = ByteAddressableBuffer::new(buf);
+        let buf = ByteAddressableBuffer::from_mut_slice(buf);
         *out = buf.load(5);
     }
 }
@@ -20,7 +31,7 @@ pub fn store(
     #[spirv(flat)] val: [i32; 4],
 ) {
     unsafe {
-        let mut buf = MutByteAddressableBuffer::new(buf);
+        let mut buf = ByteAddressableBuffer::from_mut_slice(buf);
         buf.store(5, val);
     }
 }

tests/ui/byte_addressable_buffer/big_struct.rs

@@ -1,7 +1,7 @@
 // build-pass
 
 use spirv_std::spirv;
-use spirv_std::{ByteAddressableBuffer, MutByteAddressableBuffer};
+use spirv_std::ByteAddressableBuffer;
 
 pub struct BigStruct {
     a: u32,
@@ -14,11 +14,22 @@ pub struct BigStruct {
 
 #[spirv(fragment)]
 pub fn load(
+    #[spirv(descriptor_set = 0, binding = 0, storage_buffer)] buf: &[u32],
+    out: &mut BigStruct,
+) {
+    unsafe {
+        let buf = ByteAddressableBuffer::from_slice(buf);
+        *out = buf.load(5);
+    }
+}
+
+#[spirv(fragment)]
+pub fn load_mut(
     #[spirv(descriptor_set = 0, binding = 0, storage_buffer)] buf: &mut [u32],
     out: &mut BigStruct,
 ) {
     unsafe {
-        let buf = ByteAddressableBuffer::new(buf);
+        let buf = ByteAddressableBuffer::from_mut_slice(buf);
         *out = buf.load(5);
     }
 }
@@ -29,7 +40,7 @@ pub fn store(
     #[spirv(flat)] val: BigStruct,
 ) {
     unsafe {
-        let mut buf = MutByteAddressableBuffer::new(buf);
+        let mut buf = ByteAddressableBuffer::from_mut_slice(buf);
         buf.store(5, val);
     }
 }

tests/ui/byte_addressable_buffer/complex.rs

@@ -1,7 +1,7 @@
 // build-pass
 
 use spirv_std::spirv;
-use spirv_std::{glam::Vec2, ByteAddressableBuffer, MutByteAddressableBuffer};
+use spirv_std::{glam::Vec2, ByteAddressableBuffer};
 
 pub struct Complex {
     x: u32,
@@ -20,11 +20,22 @@ pub struct Nesty {
 
 #[spirv(fragment)]
 pub fn load(
+    #[spirv(descriptor_set = 0, binding = 0, storage_buffer)] buf: &[u32],
+    out: &mut Nesty,
+) {
+    unsafe {
+        let buf = ByteAddressableBuffer::from_slice(buf);
+        *out = buf.load(5);
+    }
+}
+
+#[spirv(fragment)]
+pub fn load_mut(
     #[spirv(descriptor_set = 0, binding = 0, storage_buffer)] buf: &mut [u32],
     out: &mut Nesty,
 ) {
     unsafe {
-        let buf = ByteAddressableBuffer::new(buf);
+        let buf = ByteAddressableBuffer::from_mut_slice(buf);
         *out = buf.load(5);
     }
 }
@@ -35,7 +46,7 @@ pub fn store(
     val: Nesty,
 ) {
     unsafe {
-        let mut buf = MutByteAddressableBuffer::new(buf);
+        let mut buf = ByteAddressableBuffer::from_mut_slice(buf);
         buf.store(5, val);
     }
 }

tests/ui/byte_addressable_buffer/empty_struct.rs

@@ -1,17 +1,28 @@
 // build-pass
 
 use spirv_std::spirv;
-use spirv_std::{ByteAddressableBuffer, MutByteAddressableBuffer};
+use spirv_std::ByteAddressableBuffer;
 
 pub struct EmptyStruct {}
 
 #[spirv(fragment)]
 pub fn load(
+    #[spirv(descriptor_set = 0, binding = 0, storage_buffer)] buf: &[u32],
+    out: &mut EmptyStruct,
+) {
+    unsafe {
+        let buf = ByteAddressableBuffer::from_slice(buf);
+        *out = buf.load(5);
+    }
+}
+
+#[spirv(fragment)]
+pub fn load_mut(
     #[spirv(descriptor_set = 0, binding = 0, storage_buffer)] buf: &mut [u32],
     out: &mut EmptyStruct,
 ) {
     unsafe {
-        let buf = ByteAddressableBuffer::new(buf);
+        let buf = ByteAddressableBuffer::from_mut_slice(buf);
         *out = buf.load(5);
     }
 }
@@ -20,7 +31,7 @@ pub fn load(
 pub fn store(#[spirv(descriptor_set = 0, binding = 0, storage_buffer)] buf: &mut [u32]) {
     let val = EmptyStruct {};
     unsafe {
-        let mut buf = MutByteAddressableBuffer::new(buf);
+        let mut buf = ByteAddressableBuffer::from_mut_slice(buf);
         buf.store(5, val);
     }
 }

tests/ui/byte_addressable_buffer/f32.rs

@@ -1,23 +1,31 @@
 // build-pass
 
 use spirv_std::spirv;
-use spirv_std::{ByteAddressableBuffer, MutByteAddressableBuffer};
+use spirv_std::ByteAddressableBuffer;
 
 #[spirv(fragment)]
-pub fn load(
+pub fn load(#[spirv(descriptor_set = 0, binding = 0, storage_buffer)] buf: &[u32], out: &mut f32) {
+    unsafe {
+        let buf = ByteAddressableBuffer::from_slice(buf);
+        *out = buf.load(5);
+    }
+}
+
+#[spirv(fragment)]
+pub fn load_mut(
     #[spirv(descriptor_set = 0, binding = 0, storage_buffer)] buf: &mut [u32],
     out: &mut f32,
 ) {
     unsafe {
-        let buf = ByteAddressableBuffer::new(buf);
+        let buf = ByteAddressableBuffer::from_mut_slice(buf);
         *out = buf.load(5);
     }
 }
 
 #[spirv(fragment)]
 pub fn store(#[spirv(descriptor_set = 0, binding = 0, storage_buffer)] buf: &mut [u32], val: f32) {
     unsafe {
-        let mut buf = MutByteAddressableBuffer::new(buf);
+        let mut buf = ByteAddressableBuffer::from_mut_slice(buf);
         buf.store(5, val);
     }
 }

tests/ui/byte_addressable_buffer/small_struct.rs

@@ -1,7 +1,7 @@
 // build-pass
 
 use spirv_std::spirv;
-use spirv_std::{ByteAddressableBuffer, MutByteAddressableBuffer};
+use spirv_std::ByteAddressableBuffer;
 
 pub struct SmallStruct {
     a: u32,
@@ -10,11 +10,22 @@ pub struct SmallStruct {
 
 #[spirv(fragment)]
 pub fn load(
+    #[spirv(descriptor_set = 0, binding = 0, storage_buffer)] buf: &[u32],
+    out: &mut SmallStruct,
+) {
+    unsafe {
+        let buf = ByteAddressableBuffer::from_slice(buf);
+        *out = buf.load(5);
+    }
+}
+
+#[spirv(fragment)]
+pub fn load_mut(
     #[spirv(descriptor_set = 0, binding = 0, storage_buffer)] buf: &mut [u32],
     out: &mut SmallStruct,
 ) {
     unsafe {
-        let buf = ByteAddressableBuffer::new(buf);
+        let buf = ByteAddressableBuffer::from_mut_slice(buf);
         *out = buf.load(5);
     }
 }
@@ -27,7 +38,7 @@ pub fn store(
 ) {
     let val = SmallStruct { a, b };
     unsafe {
-        let mut buf = MutByteAddressableBuffer::new(buf);
+        let mut buf = ByteAddressableBuffer::from_mut_slice(buf);
         buf.store(5, val);
     }
 }