Fix UB in empty slice related code

* This actually fixes an issue that was already present in the codebase too

Author: InBetweenNames

crates/bevy_ecs/src/storage/blob_vec.rs

@@ -49,10 +49,39 @@ impl BlobVec {
         drop: Option<unsafe fn(OwningPtr<'_>)>,
         capacity: usize,
     ) -> BlobVec {
+        /*NOTE: dangling pointers still need to be well aligned for the type when using slices (even though they are 0-length).
+                This is important for [`SimdAlignedVec`] and any function that would return a slice view of this BlobVec.
+                It is also important if the BlobVec contains ZSTs and is mutably queried, as this will entail the
+                creation of a slice (even if 0-length).
+
+                Since neither strict_provenance nor alloc_layout_extra is stable, there is no way to construct a NonNull::dangling()
+                pointer from `item_layout`.  Creating an aligned NonNull dangling pointer manually with integer casts works, but Miri doesn't like that,
+                and it could break in the future.  Instead, assume that `MAX_SIMD_ALIGNMENT` will be the greatest alignment required of any
+                possible instruction on the system and create a dangling pointer out of a type guaranteed to need that alignment.
+
+                Currently, that type is batch::AlignedBatch64.
+
+                TODO: In the future, this restriction can be easily removed when either `strict_provenance` or `Layout::dangling()` becomes stable.
+
+
+                Obviously, this won't make sense if the contained type needs more alignment than that.
+                Therefore we have the following check:
+        */
+
+        if item_layout.align() > batch::MAX_SIMD_ALIGNMENT {
+            panic!(
+                "Attempted to create a BlobVec with an item layout alignment > MAX_SIMD_ALIGNMENT"
+            );
+        }
+
+        let dangling = NonNull::<batch::AlignedBatch64<(), 4>>::dangling().cast::<u8>();
+
         if item_layout.size() == 0 {
+            let data_dangling = NonNull::<batch::AlignedBatch64<(), 4>>::dangling().cast::<u8>();
+
             BlobVec {
-                swap_scratch: NonNull::dangling(),
-                data: NonNull::dangling(),
+                swap_scratch: dangling,
+                data: dangling,
                 capacity: usize::MAX,
                 len: 0,
                 item_layout,
@@ -63,7 +92,7 @@ impl BlobVec {
                 .unwrap_or_else(|| std::alloc::handle_alloc_error(item_layout));
             let mut blob_vec = BlobVec {
                 swap_scratch,
-                data: NonNull::dangling(),
+                data: dangling,
                 capacity: 0,
                 len: 0,
                 item_layout,