[GVN] Make handling of zeros more consistent

[vtjnash]

Summary

This is an attempt to be slightly more consistent about what checks each function does, by deferring most of them to using canCoerceMustAliasedTypeToLoad. The expected benefit of this approach is demonstrated by the new optimizations exposed represented by the additional test examples.

This tries to handle zeroinitializer consistently, by preferring using
helper functions instead of re-implementing some of the same checks.
This lets us forward zeros successfully in a few more cases.

And since casting a zero should always be possible (without needing a
bitcast), make sure the canCoerce check reflects that, and that all
relevant users are handling that.

(After adding tests to show the goals, I took pieces of https://reviews.llvm.org/D59661 and https://reviews.llvm.org/D69910 to get those improvements, and so then closed those)

[vtjnash]

rebase onto LLVM main, allowing it to handle null values everywhere, and not just for non-integral pointers

[reames]

This patch appears to be doing at least two things:

1. Consistent handling on zero constants for bitcastable types.
2. Changing scalable vector handling.

I strongly recommend you split this into two patches. My reasoning is that while I can probably review 1 for you, I do not have the context to usefully review 2. I suspect other reviewers will have the same problem, possibly in the other direction.

llvm/lib/Transforms/Utils/VNCoercion.cpp

12

Please add this rename/invert separately. No review needed.

llvm/lib/Transforms/Utils/VNCoercion.cpp

 #include "llvm/Transforms/Utils/VNCoercion.h"
 #include "llvm/Analysis/ConstantFolding.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "vncoerce"
 
 namespace llvm {
 namespace VNCoercion {
 
-static bool isFirstClassAggregateOrScalableType(Type *Ty) {
-  return Ty->isStructTy() || Ty->isArrayTy() || isa<ScalableVectorType>(Ty);
+static bool isBitCastable(Type *Ty) {
+  return !(Ty->isStructTy() || Ty->isArrayTy() || isa<ScalableVectorType>(Ty));
 }
 
-/// Return true if coerceAvailableValueToLoadType will succeed.
-bool canCoerceMustAliasedValueToLoad(Value *StoredVal, Type *LoadTy,
-                                     const DataLayout &DL) {
-  Type *StoredTy = StoredVal->getType();
-
+bool canCoerceMustAliasedTypeToLoad(Type *StoredTy, Type *LoadTy,
   if (StoredTy == LoadTy)
     return true;
 
   // If the loaded/stored value is a first class array/struct, or scalable type,
   // don't try to transform them. We need to be able to bitcast to integer.
-  if (isFirstClassAggregateOrScalableType(LoadTy) ||
-      isFirstClassAggregateOrScalableType(StoredTy))
+  if (!isBitCastable(LoadTy) || !isBitCastable(StoredTy))
     return false;
 
   uint64_t StoreSize = DL.getTypeSizeInBits(StoredTy).getFixedSize();
 
   // The store size must be byte-aligned to support future type casts.
   if (llvm::alignTo(StoreSize, 8) != StoreSize)
     return false;
 
   // The store has to be at least as big as the load.
   if (StoreSize < DL.getTypeSizeInBits(LoadTy).getFixedSize())
     return false;
 
   bool StoredNI = DL.isNonIntegralPointerType(StoredTy->getScalarType());
   bool LoadNI = DL.isNonIntegralPointerType(LoadTy->getScalarType());
   // Don't coerce non-integral pointers to integers or vice versa.
-  if (StoredNI != LoadNI) {
-    // As a special case, allow coercion of memset used to initialize
-    // an array w/null.  Despite non-integral pointers not generally having a
-    // specific bit pattern, we do assume null is zero.
-    if (auto *CI = dyn_cast<Constant>(StoredVal))
-      return CI->isNullValue();
+  if (StoredNI != LoadNI)
     return false;
-  } else if (StoredNI && LoadNI &&
-             StoredTy->getPointerAddressSpace() !=
-                 LoadTy->getPointerAddressSpace()) {
+  else if (StoredNI && LoadNI &&
+               LoadTy->getPointerAddressSpace())
     return false;
-  }
-
 
   // The implementation below uses inttoptr for vectors of unequal size; we
   // can't allow this for non integral pointers. We could teach it to extract
-  // exact subvectors if desired. 
+  // exact subvectors if desired.
   if (StoredNI && StoreSize != DL.getTypeSizeInBits(LoadTy).getFixedSize())
     return false;
 
   return true;
 }
 
+/// Return true if coerceAvailableValueToLoadType will succeed.
+bool canCoerceMustAliasedValueToLoad(Value *StoredVal, Type *LoadTy,
+                                     const DataLayout &DL) {
+  Type *StoredTy = StoredVal->getType();
+  // If we know the value is available too, then, unlike for
+  // canCoerceMustAliasedTypeToLoad, we expect the caller to not need to
+  // or try to check that the size/offset is inbounds.
+  if (auto *CI = dyn_cast<Constant>(StoredVal))
+    // All callers are expected to be able to detect and handle the zeros case.
+    if (CI->isNullValue())
+      if (isa<ScalableVectorType>(StoredTy) ==
+              isa<ScalableVectorType>(LoadTy) &&
+          DL.getTypeSizeInBits(StoredTy).getKnownMinSize() >=
+              DL.getTypeSizeInBits(LoadTy).getKnownMinSize())
+        return true;
+  return canCoerceMustAliasedTypeToLoad(StoredTy, LoadTy, DL);
+}
+
 template <class T, class HelperClass>
 static T *coerceAvailableValueToLoadTypeHelper(T *StoredVal, Type *LoadedTy,
                                                HelperClass &Helper,
                                                const DataLayout &DL) {
   assert(canCoerceMustAliasedValueToLoad(StoredVal, LoadedTy, DL) &&
          "precondition violation - materialization can't fail");
   if (auto *C = dyn_cast<Constant>(StoredVal))
     StoredVal = ConstantFoldConstant(C, DL);
 
-  // If this is already the right type, just return it.
+  // If this is already the right type, just return it,
+  // before trying to check the size of the SVE.
   Type *StoredValTy = StoredVal->getType();
+  if (StoredValTy == LoadedTy)
+    return StoredVal;
 
   uint64_t StoredValSize = DL.getTypeSizeInBits(StoredValTy).getFixedSize();
   uint64_t LoadedValSize = DL.getTypeSizeInBits(LoadedTy).getFixedSize();
 
   // If the store and reload are the same size, we can always reuse it.
   if (StoredValSize == LoadedValSize) {
     // Pointer to Pointer -> use bitcast.
     if (StoredValTy->isPtrOrPtrVectorTy() && LoadedTy->isPtrOrPtrVectorTy()) {
if (auto *C = dyn_cast<ConstantExpr>(StoredVal))
       StoredVal = ConstantFoldConstant(C, DL);
 
     return StoredVal;
   }
   // If the loaded value is smaller than the available value, then we can
   // extract out a piece from it.  If the available value is too small, then we
   // can't do anything.
   assert(StoredValSize >= LoadedValSize &&
-         "canCoerceMustAliasedValueToLoad fail");
+         "canCoerceMustAliasedTypeToLoad fail");
 
   // Convert source pointers to integers, which can be manipulated.
   if (StoredValTy->isPtrOrPtrVectorTy()) {
     StoredValTy = DL.getIntPtrType(StoredValTy);
     StoredVal = Helper.CreatePtrToInt(StoredVal, StoredValTy);
   }
 
   // Convert vectors and fp to integer, which can be manipulated.

 ///
 /// Check this case to see if there is anything more we can do before we give
 /// up.  This returns -1 if we have to give up, or a byte number in the stored
 /// value of the piece that feeds the load.
 static int analyzeLoadFromClobberingWrite(Type *LoadTy, Value *LoadPtr,
                                           Value *WritePtr,
                                           uint64_t WriteSizeInBits,
                                           const DataLayout &DL) {
-  // If the loaded/stored value is a first class array/struct, or scalable type,
-  // don't try to transform them. We need to be able to bitcast to integer.
-  if (isFirstClassAggregateOrScalableType(LoadTy))
-    return -1;
-
   int64_t StoreOffset = 0, LoadOffset = 0;
   Value *StoreBase =
       GetPointerBaseWithConstantOffset(WritePtr, StoreOffset, DL);
   Value *LoadBase = GetPointerBaseWithConstantOffset(LoadPtr, LoadOffset, DL);
   if (StoreBase != LoadBase)
     return -1;
 
   uint64_t LoadSize = DL.getTypeSizeInBits(LoadTy).getFixedSize();

 }
 
 /// This function is called when we have a
 /// memdep query of a load that ends up being a clobbering store.
 int analyzeLoadFromClobberingStore(Type *LoadTy, Value *LoadPtr,
                                    StoreInst *DepSI, const DataLayout &DL) {
   auto *StoredVal = DepSI->getValueOperand();
 
-  // Cannot handle reading from store of first-class aggregate or scalable type.
-  if (isFirstClassAggregateOrScalableType(StoredVal->getType()))
+  // We need to be able to look at the size of the result.
+  if (isa<ScalableVectorType>(StoredVal->getType()) ||
+      isa<ScalableVectorType>(LoadTy))
     return -1;
 
   if (!canCoerceMustAliasedValueToLoad(StoredVal, LoadTy, DL))
     return -1;
 
   Value *StorePtr = DepSI->getPointerOperand();
   uint64_t StoreSize =
-      DL.getTypeSizeInBits(DepSI->getValueOperand()->getType()).getFixedSize();
+      DL.getTypeSizeInBits(StoredVal->getType()).getFixedSize();
   return analyzeLoadFromClobberingWrite(LoadTy, LoadPtr, StorePtr, StoreSize,
                                         DL);
 }
 
 /// Looks at a memory location for a load (specified by MemLocBase, Offs, and
 /// Size) and compares it against a load.
 ///
 /// If the specified load could be safely widened to a larger integer load
static unsigned getLoadLoadClobberFullWidthSize(const Value *MemLocBase,
   }
 }
 
 /// This function is called when we have a
 /// memdep query of a load that ends up being clobbered by another load.  See if
 /// the other load can feed into the second load.
 int analyzeLoadFromClobberingLoad(Type *LoadTy, Value *LoadPtr, LoadInst *DepLI,
                                   const DataLayout &DL) {
-  // Cannot handle reading from store of first-class aggregate yet.
-  if (DepLI->getType()->isStructTy() || DepLI->getType()->isArrayTy())
-    return -1;
+  Value *DepPtr = DepLI->getPointerOperand();
 
-  if (!canCoerceMustAliasedValueToLoad(DepLI, LoadTy, DL))
+  // We need to be able to look at the size of the result.
+  if (isa<ScalableVectorType>(DepLI->getType()) ||
+      isa<ScalableVectorType>(LoadTy))
     return -1;
 
-  Value *DepPtr = DepLI->getPointerOperand();
+  if (canCoerceMustAliasedTypeToLoad(DepLI->getType(), LoadTy, DL)) {
     uint64_t DepSize = DL.getTypeSizeInBits(DepLI->getType()).getFixedSize();
-  int R = analyzeLoadFromClobberingWrite(LoadTy, LoadPtr, DepPtr, DepSize, DL);
+    int R =
+        analyzeLoadFromClobberingWrite(LoadTy, LoadPtr, DepPtr, DepSize, DL);
     if (R != -1)
       return R;
+  }
 
-  // If we have a load/load clobber an DepLI can be widened to cover this load,
+  // If we have a load/load clobber and DepLI can be widened to cover this load,
   // then we should widen it!
+  if (!canCoerceMustAliasedTypeToLoad(LoadTy, DepLI->getType(), DL))
+    return -1;
+
   int64_t LoadOffs = 0;
   const Value *LoadBase =
       GetPointerBaseWithConstantOffset(LoadPtr, LoadOffs, DL);
   unsigned LoadSize = DL.getTypeStoreSize(LoadTy).getFixedSize();
 
   unsigned Size =
       getLoadLoadClobberFullWidthSize(LoadBase, LoadOffs, LoadSize, DepLI);
   if (Size == 0)

 int analyzeLoadFromClobberingMemInst(Type *LoadTy, Value *LoadPtr,
                                      MemIntrinsic *MI, const DataLayout &DL) {
   // If the mem operation is a non-constant size, we can't handle it.
   ConstantInt *SizeCst = dyn_cast<ConstantInt>(MI->getLength());
   if (!SizeCst)
     return -1;
   uint64_t MemSizeInBits = SizeCst->getZExtValue() * 8;
 
+  // We need to be able to look at the size of the result.
+  if (isa<ScalableVectorType>(LoadTy))
+    return -1;
+
   // If this is memset, we just need to see if the offset is valid in the size
   // of the memset..
   if (MI->getIntrinsicID() == Intrinsic::memset) {
-    if (DL.isNonIntegralPointerType(LoadTy->getScalarType())) {
-      auto *CI = dyn_cast<ConstantInt>(cast<MemSetInst>(MI)->getValue());
-      if (!CI || !CI->isZero())
-        return -1;
-    }
+    Value *StoredVal = cast<MemSetInst>(MI)->getValue();
+    bool CanCast = ([&]() {
+      if (auto *CI = dyn_cast<Constant>(StoredVal))
+        if (CI->isNullValue())
+          return true;
+      Type *StoreTy = IntegerType::get(LoadTy->getContext(), MemSizeInBits);
+      return canCoerceMustAliasedTypeToLoad(StoreTy, LoadTy, DL);
+    })();
+    if (CanCast)
       return analyzeLoadFromClobberingWrite(LoadTy, LoadPtr, MI->getDest(),
                                             MemSizeInBits, DL);
+    return -1;
   }
 
   // If we have a memcpy/memmove, the only case we can handle is if this is a
   // copy from constant memory.  In that case, we can read directly from the
   // constant memory.
   MemTransferInst *MTI = cast<MemTransferInst>(MI);
 
   Constant *Src = dyn_cast<Constant>(MTI->getSource());
int analyzeLoadFromClobberingMemInst(Type *LoadTy, Value *LoadPtr,
   return -1;
 }
 
 template <class T, class HelperClass>
 static T *getStoreValueForLoadHelper(T *SrcVal, unsigned Offset, Type *LoadTy,
                                      HelperClass &Helper,
                                      const DataLayout &DL) {
   LLVMContext &Ctx = SrcVal->getType()->getContext();
+  if (auto *CI = dyn_cast<Constant>(getUnderlyingObject(SrcVal)))
+    if (CI->isNullValue())
+      return Constant::getNullValue(LoadTy);
 
   // If two pointers are in the same address space, they have the same size,
   // so we don't need to do any truncation, etc. This avoids introducing
   // ptrtoint instructions for pointers that may be non-integral.
   if (SrcVal->getType()->isPointerTy() && LoadTy->isPointerTy() &&
       cast<PointerType>(SrcVal->getType())->getAddressSpace() ==
           cast<PointerType>(LoadTy)->getAddressSpace()) {
     return SrcVal;
T *getMemInstValueForLoadHelper(MemIntrinsic *SrcInst, unsigned Offset,
   uint64_t LoadSize = DL.getTypeSizeInBits(LoadTy).getFixedSize() / 8;
 
   // We know that this method is only called when the mem transfer fully
   // provides the bits for the load.
   if (MemSetInst *MSI = dyn_cast<MemSetInst>(SrcInst)) {
     // memset(P, 'x', 1234) -> splat('x'), even if x is a variable, and
     // independently of what the offset is.
     T *Val = cast<T>(MSI->getValue());
+    if (auto *CI = dyn_cast<Constant>(Val)) {
+      // memset(P, '\0', 1234) -> just directly create the null value for the
+      // use of *P, bypassing any later validity checks for using BitCast to
+      // make this constant
+      if (CI->isNullValue())
+        return Constant::getNullValue(LoadTy);
+    }
+
     if (LoadSize != 1)
       Val =
           Helper.CreateZExtOrBitCast(Val, IntegerType::get(Ctx, LoadSize * 8));
     T *OneElt = Val;
 
     // Splat the value out to the right number of bits.
     for (unsigned NumBytesSet = 1; NumBytesSet != LoadSize;) {
       // If we can double the number of bytes set, do it.

llvm/test/Transforms/GVN/non-integral-pointers.ll

 ;
   entry:
   %loc.bc = bitcast i8 addrspace(4)* addrspace(4)* %loc to i8 addrspace(4)*
   call void @llvm.memset.p4i8.i64(i8 addrspace(4)* align 4 %loc.bc, i8 0, i64 8, i1 false)
   %ref = load i8 addrspace(4)*, i8 addrspace(4)* addrspace(4)* %loc
   ret i8 addrspace(4)* %ref
 }
 
+define [2 x i8 addrspace(4)*] @forward_memset_zero_fca([2 x i8 addrspace(4)*] addrspace(4)* %loc) {
+; CHECK-LABEL: @forward_memset_zero_fca(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[LOC_BC:%.*]] = bitcast [2 x i8 addrspace(4)*] addrspace(4)* [[LOC:%.*]] to i8 addrspace(4)*
+; CHECK-NEXT:    call void @llvm.memset.p4i8.i64(i8 addrspace(4)* align 4 [[LOC_BC]], i8 0, i64 16, i1 false)
+; CHECK-NEXT:    ret [2 x i8 addrspace(4)*] zeroinitializer
+;
+  entry:
+  %loc.bc = bitcast [2 x i8 addrspace(4)*] addrspace(4)* %loc to i8 addrspace(4)*
+  call void @llvm.memset.p4i8.i64(i8 addrspace(4)* align 4 %loc.bc, i8 0, i64 16, i1 false)
+  %ref = load [2 x i8 addrspace(4)*], [2 x i8 addrspace(4)*] addrspace(4)* %loc
+  ret [2 x i8 addrspace(4)*] %ref
+}
+
+
 ; Can't forward as the load might be dead.  (Pretend we wrote out the alwaysfalse idiom above.)
 define i8 addrspace(4)* @neg_forward_store(i8 addrspace(4)* addrspace(4)* %loc) {
 ; CHECK-LABEL: @neg_forward_store(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[LOC_BC:%.*]] = bitcast i8 addrspace(4)* addrspace(4)* [[LOC:%.*]] to i64 addrspace(4)*
 ; CHECK-NEXT:    store i64 5, i64 addrspace(4)* [[LOC_BC]], align 8
 ; CHECK-NEXT:    [[REF:%.*]] = load i8 addrspace(4)*, i8 addrspace(4)* addrspace(4)* [[LOC]], align 8
 ; CHECK-NEXT:    ret i8 addrspace(4)* [[REF]]

llvm/test/Transforms/GVN/vscale.ll

;
   call void asm sideeffect "", ""()
   %load2 = load <vscale x 4 x i32>, <vscale x 4 x i32>* %p
   %add = add <vscale x 4 x i32> %load1, %load2
   ret <vscale x 4 x i32> %add
 }
 
 ; Analyze Load from clobbering Store.
 
-define <vscale x 4 x i32> @store_forward_to_load(<vscale x 4 x i32>* %p) {
-; CHECK-LABEL: @store_forward_to_load(
+define <vscale x 4 x i32> @nullstore_forward_to_load(<vscale x 4 x i32>* %p) {
+; CHECK-LABEL: @nullstore_forward_to_load(
 ; CHECK-NEXT:    store <vscale x 4 x i32> zeroinitializer, <vscale x 4 x i32>* [[P:%.*]], align 16
 ; CHECK-NEXT:    ret <vscale x 4 x i32> zeroinitializer
 ;
   store <vscale x 4 x i32> zeroinitializer, <vscale x 4 x i32>* %p
   %load = load <vscale x 4 x i32>, <vscale x 4 x i32>* %p
   ret <vscale x 4 x i32> %load
 }
 
+define <vscale x 16 x i8> @nullstore_forward_to_load_casted(<vscale x 4 x i32>* %p) {
+; CHECK-LABEL: @nullstore_forward_to_load_casted(
+; CHECK-NEXT:    store <vscale x 4 x i32> zeroinitializer, <vscale x 4 x i32>* [[P:%.*]], align 16
+; CHECK-NEXT:    ret <vscale x 16 x i8> zeroinitializer
+;
+  store <vscale x 4 x i32> zeroinitializer, <vscale x 4 x i32>* %p
+  %conv = bitcast <vscale x 4 x i32>* %p to <vscale x 16 x i8>*
+  %load = load <vscale x 16 x i8>, <vscale x 16 x i8>* %conv
+  ret <vscale x 16 x i8> %load
+}
+
+define <vscale x 2 x i8> @nullstore_forward_to_load_trunc(<vscale x 4 x i32>* %p) {
+; CHECK-LABEL: @nullstore_forward_to_load_trunc(
+; CHECK-NEXT:    store <vscale x 4 x i32> zeroinitializer, <vscale x 4 x i32>* [[P:%.*]], align 16
+; CHECK-NEXT:    ret <vscale x 2 x i8> zeroinitializer
+;
+  store <vscale x 4 x i32> zeroinitializer, <vscale x 4 x i32>* %p
+  %conv = bitcast <vscale x 4 x i32>* %p to <vscale x 2 x i8>*
+  %load = load <vscale x 2 x i8>, <vscale x 2 x i8>* %conv
+  ret <vscale x 2 x i8> %load
+}
+
+
 define <vscale x 4 x i32> @store_forward_to_load_sideeffect(<vscale x 4 x i32>* %p) {
 ; CHECK-LABEL: @store_forward_to_load_sideeffect(
 ; CHECK-NEXT:    store <vscale x 4 x i32> zeroinitializer, <vscale x 4 x i32>* [[P:%.*]], align 16
 ; CHECK-NEXT:    call void asm sideeffect "", ""()
 ; CHECK-NEXT:    [[LOAD:%.*]] = load <vscale x 4 x i32>, <vscale x 4 x i32>* [[P]], align 16
 ; CHECK-NEXT:    ret <vscale x 4 x i32> [[LOAD]]
 ;
   store <vscale x 4 x i32> zeroinitializer, <vscale x 4 x i32>* %p

 ;
   %alloc = alloca <vscale x 4 x i32>
   store <vscale x 4 x i32> undef, <vscale x 4 x i32>* %alloc
   %ptr = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc, i32 0, i32 1
   %load = load i32, i32* %ptr
   ret i32 %load
 }
 
+define <vscale x 16 x i8> @store_forward_to_load_casted(<vscale x 4 x i32>* %p, <vscale x 4 x i32> %v) {
+; CHECK-LABEL: @store_forward_to_load_casted(
+; CHECK-NEXT:    store <vscale x 4 x i32> %v, <vscale x 4 x i32>* [[P:%.*]], align 16
+; CHECK-NEXT:    %conv = bitcast <vscale x 4 x i32>* %p to <vscale x 16 x i8>*
+; CHECK-NEXT:    %load = load <vscale x 16 x i8>, <vscale x 16 x i8>* %conv
+; CHECK-NEXT:    ret <vscale x 16 x i8> %load
+;
+  store <vscale x 4 x i32> %v, <vscale x 4 x i32>* %p
+  %conv = bitcast <vscale x 4 x i32>* %p to <vscale x 16 x i8>*
+  %load = load <vscale x 16 x i8>, <vscale x 16 x i8>* %conv
+  ret <vscale x 16 x i8> %load
+}
+
+define <vscale x 4 x i32> @store_forward_to_load(<vscale x 4 x i32>* %p, <vscale x 4 x i32> %v) {
+; CHECK-LABEL: @store_forward_to_load(
+; CHECK-NEXT:    store <vscale x 4 x i32> %v, <vscale x 4 x i32>* [[P:%.*]], align 16
+; CHECK-NEXT:    ret <vscale x 4 x i32> %v
+;
+  store <vscale x 4 x i32> %v, <vscale x 4 x i32>* %p
+  %load = load <vscale x 4 x i32>, <vscale x 4 x i32>* %p
+  ret <vscale x 4 x i32> %load
+}
+
+
 ; Analyze Load from clobbering MemInst.
 
 declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i1)
 
 define i32 @memset_clobber_load(<vscale x 4 x i32> *%p) {
 ; CHECK-LABEL: @memset_clobber_load(
 ; CHECK-NEXT:    [[CONV:%.*]] = bitcast <vscale x 4 x i32>* [[P:%.*]] to i8*
 ; CHECK-NEXT:    tail call void @llvm.memset.p0i8.i64(i8* [[CONV]], i8 1, i64 200, i1 false)
 ; CHECK-NEXT:    ret i32 16843009
 ;
   %conv = bitcast <vscale x 4 x i32>* %p to i8*
   tail call void @llvm.memset.p0i8.i64(i8* %conv, i8 1, i64 200, i1 false)
   %gep = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %p, i64 0, i64 5
   %load = load i32, i32* %gep
   ret i32 %load
 }
 
+define <vscale x 4 x i32> @memset_clobber_load_vscale(<vscale x 4 x i32> *%p) {
+; CHECK-LABEL: @memset_clobber_load_vscale(
+; CHECK-NEXT:    [[CONV:%.*]] = bitcast <vscale x 4 x i32>* [[P:%.*]] to i8*
+; CHECK-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[CONV]], i8 0, i64 128, i1 false)
+; CHECK-NEXT:    %load = load <vscale x 4 x i32>, <vscale x 4 x i32>* %p
+; CHECK-NEXT:    ret <vscale x 4 x i32> %load
+;
+  %conv = bitcast <vscale x 4 x i32>* %p to i8*
+  call void @llvm.memset.p0i8.i64(i8* %conv, i8 0, i64 128, i1 false)
+  %load = load <vscale x 4 x i32>, <vscale x 4 x i32>* %p
+  ret <vscale x 4 x i32> %load
+}
+
+
 define i32 @memset_clobber_load_vscaled_base(<vscale x 4 x i32> *%p) {
 ; CHECK-LABEL: @memset_clobber_load_vscaled_base(
 ; CHECK-NEXT:    [[CONV:%.*]] = bitcast <vscale x 4 x i32>* [[P:%.*]] to i8*
 ; CHECK-NEXT:    tail call void @llvm.memset.p0i8.i64(i8* [[CONV]], i8 1, i64 200, i1 false)
 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* [[P]], i64 1, i64 1
 ; CHECK-NEXT:    [[LOAD:%.*]] = load i32, i32* [[GEP]], align 4
 ; CHECK-NEXT:    ret i32 [[LOAD]]
 ;