avoid phi node for pointers flowing into Vec appends

Author: the8472

library/alloc/src/slice.rs

@@ -451,6 +451,9 @@ impl<T> [T] {
                 // allocated above with the capacity of `s`, and initialize to `s.len()` in
                 // ptr::copy_to_non_overlapping below.
                 unsafe {
+                    use core::hint::assert_unchecked;
+
+                    assert_unchecked(v.capacity() != 0);
                     s.as_ptr().copy_to_nonoverlapping(v.as_mut_ptr(), s.len());
                     v.set_len(s.len());
                 }

library/alloc/src/vec/mod.rs

@@ -2589,8 +2589,17 @@ impl<T, A: Allocator> Vec<T, A> {
     #[track_caller]
     unsafe fn append_elements(&mut self, other: *const [T]) {
         let count = other.len();
+        if count == 0 {
+            // The early return is not necessary for correctness, but in cases
+            // where LLVM sees all the way to the allocation site of `other`
+            // this can avoid a phi-node merging the two different pointers
+            // when zero-length allocations are special-cased.
+            // That in turn can enable more optimizations around the memcpy below.
+            return;
+        }
         self.reserve(count);
         let len = self.len();
+        unsafe { core::hint::assert_unchecked(self.capacity() != 0) };
         unsafe { ptr::copy_nonoverlapping(other as *const T, self.as_mut_ptr().add(len), count) };
         self.len += count;
     }