[SimplifyLibCalls] handle subobjects of constant aggregates

[msebor]

Summary

This change removes the known limitation of the library function call folders to only work with top-level arrays of characters (as per the TODO comment in the code) and allows them to also fold calls involving subobjects of constant aggregates such as member arrays. It does that by

1. adding a new function, ReadByteArrayFromGlobal that returns the byte representation of the initializer of a global constant, as a ConstantArray, and
2. removing the restriction from getConstantDataArrayInfo to only consider simple strings and having it use ReadByteArrayFromGlobal to convert other aggregates to arrays of bytes.

This initial change only handles constant offsets into these aggregates.

I have tested the change by building LLVM on x86_64 and running check-all. In full disclosure, the patch seems to cause a few surprising regressions in the test suite that I'm yet to investigate:

LLVM :: CodeGen/AArch64/arm64-2012-05-07-MemcpyAlignBug.ll
LLVM :: CodeGen/ARM/constantpool-promote-ldrh.ll
LLVM :: CodeGen/BPF/remove_truncate_5.ll
LLVM :: CodeGen/BPF/rodata_2.ll
LLVM :: CodeGen/PowerPC/aix-vec-arg-spills-mir.ll
LLVM :: CodeGen/PowerPC/aix-vec-arg-spills.ll
LLVM :: DebugInfo/COFF/types-array.ll

[nikic]

In terms of high-level design, converting the initializer to a ConstantDataArray is not great: This is a very inefficient representation, especially if you take into account that these "temporary" ConstantDataArrays are globally interned and will probably never get freed.

Now that the ConstantDataArraySlice no longer corresponds to an already existing ConstantDataArray, it should probably be switched to store an array of bytes instead. From a cursory look, I don't think anything fundamentally depends on the current representation.

[nikic]

In D125114#3497477, @nikic wrote:

Now that the ConstantDataArraySlice no longer corresponds to an already existing ConstantDataArray, it should probably be switched to store an array of bytes instead. From a cursory look, I don't think anything fundamentally depends on the current representation.

Hm, I guess the need to represent slices of different element types could make things somewhat awkward. ConstantDataArray represents everything as an array of bytes internally, and then type-puns to the actual element type on access.

[nikic]

llvm/lib/Analysis/ConstantFolding.cpp

660

There is no need to convert the values to ConstantInt, you should be able to use the ConstantDataArray::get() constructor with the SmallVector directly.

llvm/lib/Analysis/ValueTracking.cpp

4109

You can replace this with stripAndAccumulateOffsets(), in which case you don't need explicit handling for GEPs.

[msebor]

In D125114#3497477, @nikic wrote:

In terms of high-level design, converting the initializer to a ConstantDataArray is not great: This is a very inefficient representation, especially if you take into account that these "temporary" ConstantDataArrays are globally interned and will probably never get freed.

I agree that the conversion is less than optimal. The proposed approach is the least intrusive one I could come up with. Everything else I considered would have required more extensive changes. I'm interested in improving it but I'd prefer to do it incrementally rather than in the initial revision (or in a patch series).
If I missed something please let me know. If we want to improve this I'm not sure that starting by rearchitecting the existing design of these classes is a better approach than starting with this simple enhancement. But I also don't know enough LLVM memory management to judge the costs of the overhead.

In D125114#3497580, @nikic wrote:

In D125114#3497477, @nikic wrote:

Now that the ConstantDataArraySlice no longer corresponds to an already existing ConstantDataArray, it should probably be switched to store an array of bytes instead. From a cursory look, I don't think anything fundamentally depends on the current representation.

Hm, I guess the need to represent slices of different element types could make things somewhat awkward. ConstantDataArray represents everything as an array of bytes internally, and then type-puns to the actual element type on access.

My initial thought was to store the byte representation but I ended up giving up on the idea because of that, at least for the initial patch.

[msebor]

llvm/lib/Analysis/ConstantFolding.cpp

660

Nice, thanks!

llvm/lib/Analysis/ValueTracking.cpp

4109

You mean replace the line above and the whole if statement below with a call to stripAndAccumulateOffsets() plus the handling of the resulting offset? To do that I need to get a DataLayout reference from the GlobalVariable that V refers to, and I don't see how to do that without first stripping the intervening pointer casts.

[msebor]

Use ConstantDataArray::get() ctor with SmallVector instead of looping.
Updated the failing tests below:

[msebor]

The revised patch updates the failing tests below. I made some effort to verify the correctness of the changes to the first batch:

LLVM :: CodeGen/AArch64/arm64-2012-05-07-MemcpyAlignBug.ll
LLVM :: CodeGen/ARM/constantpool-promote-ldrh.ll
LLVM :: CodeGen/BPF/remove_truncate_5.ll
LLVM :: CodeGen/BPF/rodata_2.ll

but none for these:

LLVM :: CodeGen/PowerPC/aix-vec-arg-spills-mir.ll
LLVM :: CodeGen/PowerPC/aix-vec-arg-spills.ll
LLVM :: DebugInfo/COFF/types-array.ll

[nikic]

In D125114#3523078, @msebor wrote:

In D125114#3497477, @nikic wrote:

In terms of high-level design, converting the initializer to a ConstantDataArray is not great: This is a very inefficient representation, especially if you take into account that these "temporary" ConstantDataArrays are globally interned and will probably never get freed.

I agree that the conversion is less than optimal. The proposed approach is the least intrusive one I could come up with. Everything else I considered would have required more extensive changes. I'm interested in improving it but I'd prefer to do it incrementally rather than in the initial revision (or in a patch series).
If I missed something please let me know. If we want to improve this I'm not sure that starting by rearchitecting the existing design of these classes is a better approach than starting with this simple enhancement. But I also don't know enough LLVM memory management to judge the costs of the overhead.

Yeah, I think we can start with this patch.

llvm/lib/Analysis/ConstantFolding.cpp

650

I think this is going to assert for a scalable vector global (unusual, but legal). You should probably just bail out in that case.

651

Do we need to protect against large globals here? I'm thinking about something like { i8 1, [100000000 x i8] zeroinitializer }, which has a compact representation, but will be materialized in its full size here.

llvm/lib/Analysis/ValueTracking.cpp

4109

You'd normally just pass in const DataLayout &DL as an argument. Happy to have that done as a followup though, to reduce API churn in this patch.

4171

Is the type store size really what you want to check here? This means a) for ElementSize==32 this would accept a float array and b) for ElementSize==8 it would accept an i4 array.

Now, this will actually get rejected by the isIntegerTy() check below afterwards, but it seems odd to first do a different check here. (This also means we should miss the ReadByteArrayFromGlobal code path for cases where it disagrees).

[msebor]

Update patch per feedback, add a new test. Retested by running make check-all on x86_64-linux.

llvm/lib/Analysis/ConstantFolding.cpp

650

I found the following in llvm/test/Verifier/scalable-global-vars.ll while looking for a way to define such a vector:

;; Global variables cannot be scalable vectors, since we don't
;; know the size at compile time.

; CHECK: Globals cannot contain scalable vectors
; CHECK-NEXT: <vscale x 4 x i32>* @ScalableVecGlobal
@ScalableVecGlobal = global <vscale x 4 x i32> zeroinitializer

Are there other scalable vectors that can be defined at global scope?

651

It might make sense to cap the size (at a minimum to avoid the 32 vs 64-bit size_t problem). Otherwise the SmallVectorctor aborts when malloc fails. I couldn't find code to follow as an example to prevent this so I sort of arbitrarily picked INT_MAX as the maximum. I've added memchr-7.ll to exercise this although I imagine the test could fail on memory constrained systems. Let me know if there's a guideline for how to choose a more suitable maximum in these situations or how to write a more robust test.

llvm/lib/Analysis/ValueTracking.cpp

4171

I'm not sure I understand the question but matching sizes is the purpose of the test and of the ElementSize argument. The point of the isIntegerTy() check seems to be to prevent folding wcslen calls with zero-initialized arrays with a smaller size. Since such calls are undefined the only benefit of going out of our way and expanding them to the library call that I can think of is to get them caught by the sanitizer. I've replaced the check for type with one for size.

[nikic]

llvm/lib/Analysis/ConstantFolding.cpp

650

Ah, I was just wrong about this, sorry. We have scalable Constants, but if they can't be used as a GV initializer, then there's no problem as far as this code is concerned.

651

The closest thing I could find is instcombine-maxarray-size with value 1024, which might be a bit low for this usage. I'd probably pick 65536 as a nice round value, but I don't care strongly about this limit -- it's a theoretical concern at this point, and we can always adjust it.

llvm/lib/Analysis/ValueTracking.cpp

4171

Okay, I see now that ConstantDataArray only accepts power-of-2, multiple of 8 types, so arrays of i4 and similar don't take this codepath. An example for the float issue is this:

declare i64 @wcslen(ptr)

@g = constant [3 x float] [float 1.0, float 2.0, float 0.0]

define i64 @test() {
  %res = call i64 @wcslen(ptr @g)
  ret i64 %res
}

!llvm.module.flags = !{!0}
!0 = !{i32 1, !"wchar_size", i32 4}

This will assert with the current patch.

The initializer can only be directly reused if isIntegerTy(ElementSize), in other cases we should go through the ReadByteArrayFromGlobal() code to convert the elements into integers (even if they already have the correct size -- the consuming code expects that they are integers).

We could change the API contract to allow non-integer elements to be returned, but I don't think that would be useful for any current users of this API.

4257

Something is broken with the indentation here and below.

4274

Just ArrayTy = cast<ArrayType>(Init->getType()) should be sufficient for both cases -- ReadByteArrayFromGlobal() should always return a constant with array type.

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1321

Broken indentation here as well.

[msebor]

Revision 3 with the following changes:

• Only extract data from constants of integral types.
• Simplify computation of array type.
• Replace stray tabs with spaces.
• Add a test.

llvm/lib/Analysis/ValueTracking.cpp

4171

I see what you mean now, thanks for the test case! This is a limitation of the current approach of restricting conversions to arrays of i8. The only existing use case would be the wcslen folder so that alone is probably not worth an API change. But as we discussed the conversion from the underlying byte representation to a byte array is inefficient and avoiding it would also make it possible to extend the API to support arbitrary conversions. I'll keep that in mind for a possible follow up.

4257

Tabs (required by GCC) vs spaces (LLVM).

[nikic]

Can you please upload the patch with full context (-U99999) again? Hard to check the tests otherwise, as the global declarations are missing. The patch generally looks good to me though.

llvm/include/llvm/Analysis/ConstantFolding.h

179

nit: Constant *

llvm/lib/Analysis/ValueTracking.cpp

4242

I don't really get the purpose of this special case. InstCombine tests pass for me if I drop the if() part and always go into the else branch.

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1203

This change is kind of unrelated, but it will go away with your other patch anyway.

1321

Still broken :)

[msebor]

Revision 4 of the patch includes the following changes:

• Keep optimizeMemCmpVarSize from folding calls with excessive constant sizes (exposed by rebasing on top of latest trunk).
• Remove code in getConstantDataArrayInfo made redundant by other changes in the same function.
• Remove tests from memcmp-3.ll that are duplicated in memcmp-4.ll.
• Let clang-format adjust formatting.

Retested by running make check-all.

[msebor]

llvm/lib/Analysis/ValueTracking.cpp

4242

The code predates this change (see line 4217). The only difference dropping the if has on trunk is on the assertion in wcslen-3.ll:192 which has this comment:

; This could in principle be simplified, but the current implementation bails on
; type mismatches.

This patch simplifies the emitted code as noted in the comment (and adjusts the test) so it doesn't seem like the special case ever served a good purpose and can be removed.

[nikic]

LGTM

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1182

I assume this is done to preserve some existing test behavior?

llvm/test/Transforms/InstCombine/strlen-8.ll

40

This is actually folding strlen(&a5_4[2][1]) -- probably not intentional?

[msebor]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1182

Yes, sort of: memcmp-4.ll, added in preparation for this change.

llvm/test/Transforms/InstCombine/strlen-8.ll

40

Yes, that's a typo, thanks! None of the cases in this test is expected to be folded yet. There's a TODO: Handle subobjects comment in optimizeStringLength but let me add a comment to the test too. It might be helpful to start tracking these outstanding gaps more formally.

[nikic]

Closed by b19194c032e7640be0a482f20491341a62e7304f.

llvm/include/llvm/Analysis/ConstantFolding.h

 // DataLayout information. These functions cannot go in VMCore due to library
 // dependency issues.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ANALYSIS_CONSTANTFOLDING_H
 #define LLVM_ANALYSIS_CONSTANTFOLDING_H
 
+#include <stdint.h>
+
 namespace llvm {
 class APInt;
 template <typename T> class ArrayRef;
 class CallBase;
 class Constant;
 class DSOLocalEquivalent;
 class DataLayout;
 class Function;
 class GlobalValue;
+class GlobalVariable;
 class Instruction;
 class TargetLibraryInfo;
 class Type;
 
 /// If this constant is a constant offset from a global, return the global and
 /// the constant. Because of constantexprs, this function is recursive.
 /// If the global is part of a dso_local_equivalent constant, return it through
 /// `Equiv` if it is provided.

 /// returning null if unsuccessful. Can cast pointer to pointer or pointer to
 /// integer and vice versa if their sizes are equal.
 Constant *ConstantFoldLoadThroughBitcast(Constant *C, Type *DestTy,
                                          const DataLayout &DL);
 
 /// Check whether the given call has no side-effects.
 /// Specifically checks for math routimes which sometimes set errno.
 bool isMathLibCallNoop(const CallBase *Call, const TargetLibraryInfo *TLI);
+
+Constant *ReadByteArrayFromGlobal(const GlobalVariable *GV, uint64_t Offset);
 }
 
 #endif

llvm/lib/Analysis/ConstantFolding.cpp

for (unsigned i = 1; i != BytesLoaded; ++i) {
       ResultVal <<= 8;
       ResultVal |= RawBytes[i];
     }
   }
 
   return ConstantInt::get(IntType->getContext(), ResultVal);
 }
 
+} // anonymous namespace
+
+// If GV is a constant with an initializer read its representation starting
+// at Offset and return it as a constant array of unsigned char.  Otherwise
+// return null.
+Constant *llvm::ReadByteArrayFromGlobal(const GlobalVariable *GV,
+                                        uint64_t Offset) {
+  if (!GV->isConstant() || !GV->hasDefinitiveInitializer())
+    return nullptr;
+
+  const DataLayout &DL = GV->getParent()->getDataLayout();
+  Constant *Init = const_cast<Constant *>(GV->getInitializer());
+  TypeSize InitSize = DL.getTypeAllocSize(Init->getType());
+  if (InitSize < Offset)
+    return nullptr;
+
+  uint64_t NBytes = InitSize - Offset;
+  if (NBytes > UINT16_MAX)
+    // Bail for large initializers in excess of 64K to avoid allocating
+    // too much memory.
+    // Offset is assumed to be less than or equal than InitSize (this
+    // is enforced in ReadDataFromGlobal).
+    return nullptr;
+
+  SmallVector<unsigned char, 256> RawBytes(static_cast<size_t>(NBytes));
+  unsigned char *CurPtr = RawBytes.data();
+
+  if (!ReadDataFromGlobal(Init, Offset, CurPtr, NBytes, DL))
+    return nullptr;
+
+  return ConstantDataArray::get(GV->getContext(), RawBytes);
+}
+
 /// If this Offset points exactly to the start of an aggregate element, return
 /// that element, otherwise return nullptr.
 Constant *getConstantAtOffset(Constant *Base, APInt Offset,
                               const DataLayout &DL) {
   if (Offset.isZero())
     return Base;
 
   if (!isa<ConstantAggregate>(Base) && !isa<ConstantDataSequential>(Base))
for (const APInt &Index : drop_begin(Indices)) {
     C = C->getAggregateElement(Index.getZExtValue());
     if (!C)
       return nullptr;
   }
 
   return C;
 }
 
-} // end anonymous namespace
-
 Constant *llvm::ConstantFoldLoadFromConst(Constant *C, Type *Ty,
                                           const APInt &Offset,
                                           const DataLayout &DL) {
   if (Constant *AtOffset = getConstantAtOffset(C, Offset, DL))
     if (Constant *Result = ConstantFoldLoadThroughBitcast(AtOffset, Ty, DL))
       return Result;
 
   // Explicitly check for out-of-bounds access, so we return undef even if the

llvm/lib/Analysis/ValueTracking.cpp

 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/AssumeBundleQueries.h"
 #include "llvm/Analysis/AssumptionCache.h"
+#include "llvm/Analysis/ConstantFolding.h"
 #include "llvm/Analysis/EHPersonalities.h"
 #include "llvm/Analysis/GuardUtils.h"
 #include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/Analysis/Loads.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/IR/Argument.h"

           return nullptr;
 
         // The requested index identifies a part of a nested aggregate. Handle
         // this specially. For example,
         // %A = insertvalue { i32, {i32, i32 } } undef, i32 10, 1, 0
         // %B = insertvalue { i32, {i32, i32 } } %A, i32 11, 1, 1
         // %C = extractvalue {i32, { i32, i32 } } %B, 1
         // This can be changed into
         // %A = insertvalue {i32, i32 } undef, i32 10, 0
         // %C = insertvalue {i32, i32 } %A, i32 11, 1
         // which allows the unused 0,0 element from the nested struct to be
         // removed.
         return BuildSubAggregate(V, makeArrayRef(idx_range.begin(), req_idx),
                                  InsertBefore);
       }
 
       // This insert value inserts something else than what we are looking for.

 
   // Make sure the index-ee is a pointer to array of \p CharSize integers.
   // CharSize.
   ArrayType *AT = dyn_cast<ArrayType>(GEP->getSourceElementType());
   if (!AT || !AT->getElementType()->isIntegerTy(CharSize))
     return false;
 
   // Check to make sure that the first operand of the GEP is an integer and
   // has value 0 so that we are sure we're indexing into the initializer.
   const ConstantInt *FirstIdx = dyn_cast<ConstantInt>(GEP->getOperand(1));
   if (!FirstIdx || !FirstIdx->isZero())
     return false;
 
   return true;
 }
 
+// If V refers to an initialized global constant, set Slice either to
+// its initializer if the size of its elements equals ElementSize, or,
+// for ElementSize == 8, to its representation as an array of unsiged
+// char. Return true on success.
 bool llvm::getConstantDataArrayInfo(const Value *V,
                                     ConstantDataArraySlice &Slice,
                                     unsigned ElementSize, uint64_t Offset) {
   assert(V);
 
   // Look through bitcast instructions and geps.
   V = V->stripPointerCasts();
 
   // If the value is a GEP instruction or constant expression, treat it as an
   // offset.
   if (const GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
-    // The GEP operator should be based on a pointer to string constant, and is
-    // indexing into the string constant.
-    if (!isGEPBasedOnPointerToString(GEP, ElementSize))
+    // Fail if the first GEP operand is not a constant zero and we're
+    // not indexing into the initializer.
+    const ConstantInt *FirstIdx = dyn_cast<ConstantInt>(GEP->getOperand(1));
+    if (!FirstIdx || !FirstIdx->isZero())
       return false;
 
-    // If the second index isn't a ConstantInt, then this is a variable index
-    // into the array.  If this occurs, we can't say anything meaningful about
-    // the string.
-    uint64_t StartIdx = 0;
-    if (const ConstantInt *CI = dyn_cast<ConstantInt>(GEP->getOperand(2)))
-      StartIdx = CI->getZExtValue();
-    else
+    Value *Op0 = GEP->getOperand(0);
+    const GlobalVariable *GV = dyn_cast<GlobalVariable>(Op0);
+    if (!GV)
+      return false;
+
+    // Fail if the offset into the initializer is not constant.
+    const DataLayout &DL = GV->getParent()->getDataLayout();
+    APInt Off(DL.getIndexSizeInBits(GEP->getPointerAddressSpace()), 0);
+    if (!GEP->accumulateConstantOffset(DL, Off))
       return false;
-    return getConstantDataArrayInfo(GEP->getOperand(0), Slice, ElementSize,
-                                    StartIdx + Offset);
+
+    // Fail if the constant offset is excessive.
+    uint64_t StartIdx = Off.getLimitedValue();
+    if (StartIdx == UINT64_MAX)
+      return false;
+
+    return getConstantDataArrayInfo(Op0, Slice, ElementSize, StartIdx + Offset);
   }
 
   // The GEP instruction, constant or instruction, must reference a global
   // variable that is a constant and is initialized. The referenced constant
   // initializer is the array that we'll use for optimization.
   const GlobalVariable *GV = dyn_cast<GlobalVariable>(V);
   if (!GV || !GV->isConstant() || !GV->hasDefinitiveInitializer())
     return false;
 
-  const ConstantDataArray *Array;
-  ArrayType *ArrayTy;
+  const DataLayout &DL = GV->getParent()->getDataLayout();
+  ConstantDataArray *Array = nullptr;
+  ArrayType *ArrayTy = nullptr;
+
   if (GV->getInitializer()->isNullValue()) {
     Type *GVTy = GV->getValueType();
-    if ( (ArrayTy = dyn_cast<ArrayType>(GVTy)) ) {
-      // A zeroinitializer for the array; there is no ConstantDataArray.
-      Array = nullptr;
-    } else {
-      const DataLayout &DL = GV->getParent()->getDataLayout();
-      uint64_t SizeInBytes = DL.getTypeStoreSize(GVTy).getFixedSize();
-      uint64_t Length = SizeInBytes / (ElementSize / 8);
-      if (Length <= Offset)
-        return false;
+    uint64_t SizeInBytes = DL.getTypeStoreSize(GVTy).getFixedSize();
+    uint64_t Length = SizeInBytes / (ElementSize / 8);
+    if (Length <= Offset)
+      // Bail on undersized constants to let sanitizers detect library
+      // calls with them as arguments.
+      return false;
 
-      Slice.Array = nullptr;
-      Slice.Offset = 0;
-      Slice.Length = Length - Offset;
-      return true;
+  }
+
+  auto *Init = const_cast<Constant *>(GV->getInitializer());
+  if (auto *ArrayInit = dyn_cast<ConstantDataArray>(Init)) {
+    Type *InitElTy = ArrayInit->getElementType();
+    if (InitElTy->isIntegerTy(ElementSize)) {
+      // If Init is an initializer for an array of the expected type
+      // and size, use it as is.
+      Array = ArrayInit;
+      ArrayTy = ArrayInit->getType();
     }
-  } else {
-    // This must be a ConstantDataArray.
-    Array = dyn_cast<ConstantDataArray>(GV->getInitializer());
-    if (!Array)
+  }
+
+  if (!Array) {
+    if (ElementSize != 8)
+      // TODO: Handle conversions to larger integral types.
+      return false;
+
+    // Otherwise extract the portion of the initializer starting
+    // at Offset as an array of bytes, and reset Offset.
+    Init = ReadByteArrayFromGlobal(GV, Offset);
+    if (!Init)
       return false;
-    ArrayTy = Array->getType();
+
+    Offset = 0;
+    Array = dyn_cast<ConstantDataArray>(Init);
+    ArrayTy = dyn_cast<ArrayType>(Init->getType());
   }
-  if (!ArrayTy->getElementType()->isIntegerTy(ElementSize))
-    return false;
 
   uint64_t NumElts = ArrayTy->getArrayNumElements();
   if (Offset > NumElts)
     return false;
 
   Slice.Array = Array;
   Slice.Offset = Offset;
   Slice.Length = NumElts - Offset;
   return true;
 }
 
 /// This function computes the length of a null-terminated C string pointed to

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

Value *LibCallSimplifier::optimizeStringLength(CallInst *CI, IRBuilderBase &B,
   // strlen(s + x) to strlen(s) - x, when x is known to be in the range
   // [0, strlen(s)] or the string has a single null terminator '\0' at the end.
   // We only try to simplify strlen when the pointer s points to an array
   // of i8. Otherwise, we would need to scale the offset x before doing the
   // subtraction. This will make the optimization more complex, and it's not
   // very useful because calling strlen for a pointer of other types is
   // very uncommon.
   if (GEPOperator *GEP = dyn_cast<GEPOperator>(Src)) {
+    // TODO: Handle subobjects.
     if (!isGEPBasedOnPointerToString(GEP, CharSize))
       return nullptr;
 
     ConstantDataArraySlice Slice;
     if (getConstantDataArrayInfo(GEP->getOperand(0), Slice, CharSize)) {
       uint64_t NullTermIdx;
       if (Slice.Array == nullptr) {
         NullTermIdx = 0;
Value *LibCallSimplifier::optimizeMemChr(CallInst *CI, IRBuilderBase &B) {
   Value *Bits = B.CreateIsNotNull(B.CreateAnd(Shl, BitfieldC), "memchr.bits");
 
   // Finally merge both checks and cast to pointer type. The inttoptr
   // implicitly zexts the i1 to intptr type.
   return B.CreateIntToPtr(B.CreateLogicalAnd(Bounds, Bits, "memchr"),
                           CI->getType());
 }
 
-// Optimize a memcmp call CI with constant arrays LHS and RHS and nonconstant
-// Size.
+// Optimize a memcmp call CI with constant arrays LHS and RHS and either
+// nonconstant Size or constant size known to be in bounds.
 static Value *optimizeMemCmpVarSize(CallInst *CI, Value *LHS, Value *RHS,
                                     Value *Size, IRBuilderBase &B,
                                     const DataLayout &DL) {
   if (LHS == RHS) // memcmp(s,s,x) -> 0
     return Constant::getNullValue(CI->getType());
 
   StringRef LStr, RStr;
   if (!getConstantStringInfo(LHS, LStr, 0, /*TrimAtNul=*/false) ||
if (LStr[Pos] != RStr[Pos]) {
       Value *Cmp = B.CreateICmp(ICmpInst::ICMP_ULE, Size, MaxSize);
       typedef unsigned char UChar;
       int IRes = UChar(LStr[Pos]) < UChar(RStr[Pos]) ? -1 : 1;
       Value *Res = ConstantInt::get(CI->getType(), IRes);
       return B.CreateSelect(Cmp, Zero, Res);
     }
   }
 
+  if (auto *SizeC = dyn_cast<ConstantInt>(Size))
+    if (MinSize < SizeC->getZExtValue())
+      // Fail if the bound happens to be constant and excessive and
+      // let sanitizers catch it.
+      return nullptr;
+
   // One array is a leading part of the other of equal or greater size.
-  // Fold the result to zero.  Size is assumed to be in bounds, since
-  // otherwise the call would be undefined.
+  // Fold the result to zero.  Nonconstant size is assumed to be in bounds,
+  // since otherwise the call would be undefined.
   return Zero;
 }
 
 // Optimize a memcmp call CI with constant size Len.
 static Value *optimizeMemCmpConstantSize(CallInst *CI, Value *LHS, Value *RHS,
                                          uint64_t Len, IRBuilderBase &B,
                                          const DataLayout &DL) {
   if (Len == 0) // memcmp(s1,s2,0) -> 0
     return Constant::getNullValue(CI->getType());
 
   // memcmp(S1,S2,1) -> *(unsigned char*)LHS - *(unsigned char*)RHS
   if (Len == 1) {
     Value *LHSV =
         B.CreateZExt(B.CreateLoad(B.getInt8Ty(), castToCStr(LHS, B), "lhsc"),
                      CI->getType(), "lhsv");
     Value *RHSV =
         B.CreateZExt(B.CreateLoad(B.getInt8Ty(), castToCStr(RHS, B), "rhsc"),
                      CI->getType(), "rhsv");
     return B.CreateSub(LHSV, RHSV, "chardiff");
   }
 
   // memcmp(S1,S2,N/8)==0 -> (*(intN_t*)S1 != *(intN_t*)S2)==0
   // TODO: The case where both inputs are constants does not need to be limited
   // to legal integers or equality comparison. See block below this.
   if (DL.isLegalInteger(Len * 8) && isOnlyUsedInZeroEqualityComparison(CI)) {
Value *LibCallSimplifier::optimizeMemCCpy(CallInst *CI, IRBuilderBase &B) {
   if (CI->use_empty() && Dst == Src)
     return Dst;
   // memccpy(d, s, c, 0) -> nullptr
   if (N) {
     if (N->isNullValue())
       return Constant::getNullValue(CI->getType());
     if (!getConstantStringInfo(Src, SrcStr, /*Offset=*/0,
                                /*TrimAtNul=*/false) ||
+        // TODO: Handle zeroinitializer.
         !StopChar)
       return nullptr;
   } else {
     return nullptr;
   }
 
   // Wrap arg 'c' of type int to char
   size_t Pos = SrcStr.find(StopChar->getSExtValue() & 0xFF);
   if (Pos == StringRef::npos) {
     if (N->getZExtValue() <= SrcStr.size()) {

llvm/test/CodeGen/AArch64/arm64-2012-05-07-MemcpyAlignBug.ll

 ; RUN: llc < %s -mtriple=arm64-eabi -mcpu=cyclone | FileCheck %s
 ; <rdar://problem/11294426>
 
-@b = private unnamed_addr constant [3 x i32] [i32 1768775988, i32 1685481784, i32 1836253201], align 4
+@b = common unnamed_addr global [3 x i32] zeroinitializer, align 4
 
 ; The important thing for this test is that we need an unaligned load of `l_b'
 ; ("ldr w2, [x1, #8]" in this case).
 
-; CHECK:      adrp x[[PAGE:[0-9]+]], {{l_b@PAGE|.Lb}}
-; CHECK: add  x[[ADDR:[0-9]+]], x[[PAGE]], {{l_b@PAGEOFF|:lo12:.Lb}}
+; CHECK:      adrp x[[PAGE:[0-9]+]], :got:b
+; CHECK-NEXT: ldr  x[[PAGE]], [x[[ADDR:[0-9]+]], :got_lo12:b]
 ; CHECK-NEXT: ldr  [[VAL2:x[0-9]+]], [x[[ADDR]]]
 ; CHECK-NEXT: ldr  [[VAL:w[0-9]+]], [x[[ADDR]], #8]
 ; CHECK-NEXT: str  [[VAL]], [x0, #8]
 ; CHECK-NEXT: str  [[VAL2]], [x0]
 
 define void @foo(i8* %a) {
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %a, i8* align 4 bitcast ([3 x i32]* @b to i8*), i64 12, i1 false)
   ret void
 }
 
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind

llvm/test/CodeGen/ARM/constantpool-promote-ldrh.ll

 ; RUN: llc < %s -O0 -fast-isel=false -arm-promote-constant | FileCheck %s
 ; RUN: llc < %s -O0 -fast-isel=false -filetype=obj -arm-promote-constant
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
 target triple = "thumbv6m-arm-linux-gnueabi"
 
-@fn1.a = private unnamed_addr constant [4 x i16] [i16 6, i16 0, i16 0, i16 0], align 2
+@fn1.a = private unnamed_addr global [4 x i16] [i16 6, i16 0, i16 0, i16 0], align 2
 
 ; We must not try and emit this bad instruction: "ldrh r1, .LCPI0_0"
 ; CHECK-LABEL: fn1:
-; CHECK: adr [[base:r[0-9]+]], .LCPI0_0
+; CHECK: ldr [[base:r[0-9]+]], .LCPI0_0
 ; CHECK-NOT: ldrh {{r[0-9]+}}, .LCPI0_0
 ; CHECK: ldrh r{{[0-9]+}}, [[[base]]]
 define hidden i32 @fn1() #0 {
 entry:
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 2 undef, i8* align 2 bitcast ([4 x i16]* @fn1.a to i8*), i32 8, i1 false)
   ret i32 undef
 }
 
 ; Function Attrs: argmemonly nounwind
 declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture writeonly, i8* nocapture readonly, i32, i1)
 attributes #0 = { "target-features"="+strict-align" }

llvm/test/CodeGen/BPF/remove_truncate_5.ll

 ; Function Attrs: nounwind
 define dso_local void @test() local_unnamed_addr #0 {
 ; CHECK-LABEL: test:
   %1 = alloca %struct.test_t, align 4
   %2 = bitcast %struct.test_t* %1 to i8*
   call void @llvm.lifetime.start.p0i8(i64 16, i8* nonnull %2) #3
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 4 %2, i8* align 4 bitcast (%struct.test_t* @test.t to i8*), i64 16, i1 false)
 ; CHECK: r1 = 0
-; CHECK: r1 <<= 32
-; CHECK: r2 = r1
-; CHECK: r2 |= 0
-; CHECK: *(u64 *)(r10 - 8) = r2
-; CHECK: r1 |= 5
+; CHECK: *(u64 *)(r10 - 8) = r1
+; CHECK: r1 = 5
 ; CHECK: *(u64 *)(r10 - 16) = r1
+; CHECK: r1 = r10
+; CHECK: r1 += -16
   call void @foo(i8* nonnull %2) #3
 ; CHECK: call foo
   call void @llvm.lifetime.end.p0i8(i64 16, i8* nonnull %2) #3
   ret void
 }
 
 ; Function Attrs: argmemonly nounwind
 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1

llvm/test/CodeGen/BPF/rodata_2.ll

 @g = common local_unnamed_addr global %struct.test_t2 zeroinitializer, align 4
 
 ; Function Attrs: nounwind
 define i32 @test() local_unnamed_addr #0 {
 ; CHECK-LABEL: test:
 
 entry:
     tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 getelementptr inbounds (%struct.test_t2, %struct.test_t2* @g, i64 0, i32 0), i8* align 4 getelementptr inbounds (%struct.test_t2, %struct.test_t2* @test.t2, i64 0, i32 0), i64 32, i1 false)
-; CHECK:  r1 = g
-; CHECK:  r2 = 0
-; CHECK:  *(u32 *)(r1 + 28) = r2
-; CHECK:  r3 = 3
-; CHECK:  *(u32 *)(r1 + 24) = r3
-; CHECK:  r3 = 2
-; CHECK:  *(u32 *)(r1 + 20) = r3
-; CHECK:  r3 = 1
-; CHECK:  *(u32 *)(r1 + 16) = r3
+; CHECK: r1 = g ll
+; CHECK: r2 = 3
+; CHECK: *(u32 *)(r1 + 24) = r2
+; CHECK: r2 = 2
+; CHECK: *(u32 *)(r1 + 20) = r2
+; CHECK: r2 = 1
+; CHECK: *(u32 *)(r1 + 16) = r2
+; CHECK: r2 = 0
+; CHECK: *(u32 *)(r1 + 28) = r2
+; CHECK: *(u32 *)(r1 + 8) = r2
+; CHECK: *(u32 *)(r1 + 4) = r2
+; CHECK: *(u32 *)(r1 + 0) = r2
       ret i32 0
 }
 ; CHECK: .section  .rodata.cst32,"aM",@progbits,32
 
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1) #1
 
 attributes #0 = { nounwind }
 attributes #1 = { argmemonly nounwind }

llvm/test/CodeGen/PowerPC/aix-vec-arg-spills-mir.ll

 %struct.Test = type { double, double, double, double }
 
 @__const.caller.t = private unnamed_addr constant %struct.Test { double 0.000000e+00, double 1.000000e+00, double 2.000000e+00, double 3.000000e+00 }, align 8
 
 define double @caller() {
 
   ; MIR32-LABEL: name: caller
   ; MIR32: bb.0.entry:
-  ; MIR32:   renamable $r3 = LWZtoc @__const.caller.t, $r2 :: (load (s32) from got)
-  ; MIR32:   renamable $r4 = LI 31
-  ; MIR32:   renamable $v2 = LVX renamable $r3, killed renamable $r4
-  ; MIR32:   renamable $r4 = LI 16
-  ; MIR32:   renamable $v3 = LVX renamable $r3, killed renamable $r4
-  ; MIR32:   renamable $v4 = LVSL $zero, renamable $r3
-  ; MIR32:   renamable $v2 = VPERM renamable $v3, killed renamable $v2, renamable $v4
-  ; MIR32:   renamable $r4 = LI 172
-  ; MIR32:   STXVW4X killed renamable $v2, $r1, killed renamable $r4 :: (store (s128) into unknown-address + 16, align 4)
-  ; MIR32:   renamable $v2 = LVX $zero, killed renamable $r3
-  ; MIR32:   renamable $v2 = VPERM killed renamable $v2, killed renamable $v3, killed renamable $v4
-  ; MIR32:   renamable $r3 = LI 156
-  ; MIR32:   STXVW4X killed renamable $v2, $r1, killed renamable $r3 :: (store (s128), align 4)
-  ; MIR32:   ADJCALLSTACKDOWN 188, 0, implicit-def dead $r1, implicit $r1
-  ; MIR32:   renamable $vsl0 = XXLXORz
-  ; MIR32:   $f1 = XXLXORdpz
-  ; MIR32:   $f2 = XXLXORdpz
-  ; MIR32:   $v2 = XXLXORz
-  ; MIR32:   $v3 = XXLXORz
-  ; MIR32:   $v4 = XXLXORz
-  ; MIR32:   $v5 = XXLXORz
-  ; MIR32:   $v6 = XXLXORz
-  ; MIR32:   $v7 = XXLXORz
-  ; MIR32:   $v8 = XXLXORz
-  ; MIR32:   $v9 = XXLXORz
-  ; MIR32:   $v10 = XXLXORz
-  ; MIR32:   $v11 = XXLXORz
-  ; MIR32:   $v12 = XXLXORz
-  ; MIR32:   $v13 = XXLXORz
-  ; MIR32:   $f3 = XXLXORdpz
-  ; MIR32:   $f4 = XXLXORdpz
-  ; MIR32:   $f5 = XXLXORdpz
-  ; MIR32:   $f6 = XXLXORdpz
-  ; MIR32:   $f7 = XXLXORdpz
-  ; MIR32:   renamable $r3 = LI 136
-  ; MIR32:   $f8 = XXLXORdpz
-  ; MIR32:   renamable $r4 = LI 120
-  ; MIR32:   renamable $r5 = LWZtoc %const.0, $r2 :: (load (s32) from got)
-  ; MIR32:   STXVW4X renamable $vsl0, $r1, killed renamable $r3 :: (store (s128), align 8)
-  ; MIR32:   $f9 = XXLXORdpz
-  ; MIR32:   renamable $r3 = LI 104
-  ; MIR32:   STXVW4X renamable $vsl0, $r1, killed renamable $r4 :: (store (s128), align 8)
-  ; MIR32:   $f10 = XXLXORdpz
-  ; MIR32:   STXVW4X renamable $vsl0, $r1, killed renamable $r3 :: (store (s128), align 8)
-  ; MIR32:   renamable $r3 = LI 88
-  ; MIR32:   $f11 = XXLXORdpz
-  ; MIR32:   STXVW4X renamable $vsl0, $r1, killed renamable $r3 :: (store (s128), align 8)
-  ; MIR32:   renamable $r3 = LI 72
-  ; MIR32:   renamable $v0 = LXVD2X $zero, killed renamable $r5 :: (load (s128) from constant-pool)
-  ; MIR32:   $f12 = XXLXORdpz
-  ; MIR32:   STXVW4X killed renamable $vsl0, $r1, killed renamable $r3 :: (store (s128), align 8)
-  ; MIR32:   $f13 = XXLXORdpz
-  ; MIR32:   renamable $r5 = LI 48
-  ; MIR32:   renamable $r6 = LI 512
-  ; MIR32:   $r3 = LI 128
-  ; MIR32:   $r4 = LI 256
-  ; MIR32:   STXVD2X killed renamable $v0, $r1, killed renamable $r5 :: (store (s128))
-  ; MIR32:   STW killed renamable $r6, 152, $r1 :: (store (s32))
-  ; MIR32:   BL_NOP <mcsymbol .callee[PR]>, csr_aix32_altivec, implicit-def dead $lr, implicit $rm, implicit $r3, implicit $r4, implicit $f1, implicit $f2, implicit $v2, implicit $v3, implicit $v4, implicit $v5, implicit killed $v6, implicit killed $v7, implicit killed $v8, implicit killed $v9, implicit killed $v10, implicit killed $v11, implicit killed $v12, implicit killed $v13, implicit $f3, implicit $f4, implicit $f5, implicit $f6, implicit $f7, implicit $f8, implicit $f9, implicit $f10, implicit $f11, implicit $f12, implicit $f13, implicit $r2, implicit-def $r1, implicit-def $f1
-  ; MIR32:   ADJCALLSTACKUP 188, 0, implicit-def dead $r1, implicit $r1
-  ; MIR32:   BLR implicit $lr, implicit $rm, implicit $f1
+  ; MIR32-NEXT:   renamable $r3 = LIS 16392
+  ; MIR32-NEXT:   renamable $r4 = LIS 16384
+  ; MIR32-NEXT:   STW killed renamable $r3, 180, $r1 :: (store (s32) into unknown-address + 24)
+  ; MIR32-NEXT:   renamable $r3 = LI 0
+  ; MIR32-NEXT:   STW killed renamable $r4, 172, $r1 :: (store (s32) into unknown-address + 16)
+  ; MIR32-NEXT:   renamable $r4 = LIS 16368
+  ; MIR32-NEXT:   STW renamable $r3, 184, $r1 :: (store (s32) into unknown-address + 28)
+  ; MIR32-NEXT:   STW renamable $r3, 176, $r1 :: (store (s32) into unknown-address + 20)
+  ; MIR32-NEXT:   STW renamable $r3, 168, $r1 :: (store (s32) into unknown-address + 12)
+  ; MIR32-NEXT:   STW killed renamable $r4, 164, $r1 :: (store (s32) into unknown-address + 8)
+  ; MIR32-NEXT:   STW renamable $r3, 160, $r1 :: (store (s32) into unknown-address + 4)
+  ; MIR32-NEXT:   STW killed renamable $r3, 156, $r1 :: (store (s32))
+  ; MIR32-NEXT:   ADJCALLSTACKDOWN 188, 0, implicit-def dead $r1, implicit $r1
+  ; MIR32-NEXT:   renamable $vsl0 = XXLXORz
+  ; MIR32-NEXT:   $f1 = XXLXORdpz
+  ; MIR32-NEXT:   $f2 = XXLXORdpz
+  ; MIR32-NEXT:   $v2 = XXLXORz
+  ; MIR32-NEXT:   $v3 = XXLXORz
+  ; MIR32-NEXT:   $v4 = XXLXORz
+  ; MIR32-NEXT:   $v5 = XXLXORz
+  ; MIR32-NEXT:   $v6 = XXLXORz
+  ; MIR32-NEXT:   $v7 = XXLXORz
+  ; MIR32-NEXT:   $v8 = XXLXORz
+  ; MIR32-NEXT:   $v9 = XXLXORz
+  ; MIR32-NEXT:   $v10 = XXLXORz
+  ; MIR32-NEXT:   $v11 = XXLXORz
+  ; MIR32-NEXT:   $v12 = XXLXORz
+  ; MIR32-NEXT:   $v13 = XXLXORz
+  ; MIR32-NEXT:   $f3 = XXLXORdpz
+  ; MIR32-NEXT:   $f4 = XXLXORdpz
+  ; MIR32-NEXT:   $f5 = XXLXORdpz
+  ; MIR32-NEXT:   $f6 = XXLXORdpz
+  ; MIR32-NEXT:   $f7 = XXLXORdpz
+  ; MIR32-NEXT:   renamable $r3 = LI 136
+  ; MIR32-NEXT:   $f8 = XXLXORdpz
+  ; MIR32-NEXT:   renamable $r4 = LI 120
+  ; MIR32-NEXT:   renamable $r5 = LWZtoc %const.0, $r2 :: (load (s32) from got)
+  ; MIR32-NEXT:   STXVW4X renamable $vsl0, $r1, killed renamable $r3 :: (store (s128), align 8)
+  ; MIR32-NEXT:   $f9 = XXLXORdpz
+  ; MIR32-NEXT:   renamable $r3 = LI 104
+  ; MIR32-NEXT:   STXVW4X renamable $vsl0, $r1, killed renamable $r4 :: (store (s128), align 8)
+  ; MIR32-NEXT:   $f10 = XXLXORdpz
+  ; MIR32-NEXT:   STXVW4X renamable $vsl0, $r1, killed renamable $r3 :: (store (s128), align 8)
+  ; MIR32-NEXT:   renamable $r3 = LI 88
+  ; MIR32-NEXT:   $f11 = XXLXORdpz
+  ; MIR32-NEXT:   STXVW4X renamable $vsl0, $r1, killed renamable $r3 :: (store (s128), align 8)
+  ; MIR32-NEXT:   renamable $r3 = LI 72
+  ; MIR32-NEXT:   renamable $v0 = LXVD2X $zero, killed renamable $r5 :: (load (s128) from constant-pool)
+  ; MIR32-NEXT:   $f12 = XXLXORdpz
+  ; MIR32-NEXT:   STXVW4X killed renamable $vsl0, $r1, killed renamable $r3 :: (store (s128), align 8)
+  ; MIR32-NEXT:   $f13 = XXLXORdpz
+  ; MIR32-NEXT:   renamable $r5 = LI 48
+  ; MIR32-NEXT:   renamable $r6 = LI 512
+  ; MIR32-NEXT:   $r3 = LI 128
+  ; MIR32-NEXT:   $r4 = LI 256
+  ; MIR32-NEXT:   STXVD2X killed renamable $v0, $r1, killed renamable $r5 :: (store (s128))
+  ; MIR32-NEXT:   STW killed renamable $r6, 152, $r1 :: (store (s32))
+  ; MIR32-NEXT:   BL_NOP <mcsymbol .callee[PR]>, csr_aix32_altivec, implicit-def dead $lr, implicit $rm, implicit $r3, implicit $r4, implicit $f1, implicit $f2, implicit $v2, implicit $v3, implicit $v4, implicit $v5, implicit killed $v6, implicit killed $v7, implicit killed $v8, implicit killed $v9, implicit killed $v10, implicit killed $v11, implicit killed $v12, implicit killed $v13, implicit $f3, implicit $f4, implicit $f5, implicit $f6, implicit $f7, implicit $f8, implicit $f9, implicit $f10, implicit $f11, implicit $f12, implicit $f13, implicit $r2, implicit-def $r1, implicit-def $f1
+  ; MIR32-NEXT:   ADJCALLSTACKUP 188, 0, implicit-def dead $r1, implicit $r1
+  ; MIR32-NEXT:   BLR implicit $lr, implicit $rm, implicit $f1
   ; MIR64-LABEL: name: caller
   ; MIR64: bb.0.entry:
-  ; MIR64:   renamable $x3 = LDtoc @__const.caller.t, $x2 :: (load (s64) from got)
-  ; MIR64:   renamable $x4 = LI8 16
-  ; MIR64:   renamable $vsl0 = LXVD2X renamable $x3, killed renamable $x4 :: (load (s128) from unknown-address + 16, align 8)
-  ; MIR64:   renamable $x4 = LI8 208
-  ; MIR64:   STXVD2X killed renamable $vsl0, $x1, killed renamable $x4 :: (store (s128) into unknown-address + 16, align 4)
-  ; MIR64:   renamable $vsl0 = LXVD2X $zero8, killed renamable $x3 :: (load (s128), align 8)
-  ; MIR64:   renamable $x3 = LI8 192
-  ; MIR64:   STXVD2X killed renamable $vsl0, $x1, killed renamable $x3 :: (store (s128), align 4)
-  ; MIR64:   ADJCALLSTACKDOWN 224, 0, implicit-def dead $r1, implicit $r1
-  ; MIR64:   renamable $vsl0 = XXLXORz
-  ; MIR64:   $f1 = XXLXORdpz
-  ; MIR64:   $f2 = XXLXORdpz
-  ; MIR64:   $v2 = XXLXORz
-  ; MIR64:   $v3 = XXLXORz
-  ; MIR64:   $v4 = XXLXORz
-  ; MIR64:   $v5 = XXLXORz
-  ; MIR64:   $v6 = XXLXORz
-  ; MIR64:   $v7 = XXLXORz
-  ; MIR64:   $v8 = XXLXORz
-  ; MIR64:   $v9 = XXLXORz
-  ; MIR64:   $v10 = XXLXORz
-  ; MIR64:   $v11 = XXLXORz
-  ; MIR64:   $v12 = XXLXORz
-  ; MIR64:   $v13 = XXLXORz
-  ; MIR64:   $f3 = XXLXORdpz
-  ; MIR64:   $f4 = XXLXORdpz
-  ; MIR64:   $f5 = XXLXORdpz
-  ; MIR64:   $f6 = XXLXORdpz
-  ; MIR64:   renamable $x3 = LDtocCPT %const.0, $x2 :: (load (s64) from got)
-  ; MIR64:   $f7 = XXLXORdpz
-  ; MIR64:   $f8 = XXLXORdpz
-  ; MIR64:   renamable $x4 = LI8 160
-  ; MIR64:   $f9 = XXLXORdpz
-  ; MIR64:   renamable $x5 = LI8 144
-  ; MIR64:   STXVW4X renamable $vsl0, $x1, killed renamable $x4 :: (store (s128), align 8)
-  ; MIR64:   renamable $vsl13 = LXVD2X $zero8, killed renamable $x3 :: (load (s128) from constant-pool)
-  ; MIR64:   $f10 = XXLXORdpz
-  ; MIR64:   renamable $x3 = LI8 128
-  ; MIR64:   STXVW4X renamable $vsl0, $x1, killed renamable $x5 :: (store (s128), align 8)
-  ; MIR64:   $f11 = XXLXORdpz
-  ; MIR64:   renamable $x4 = LI8 80
-  ; MIR64:   STXVW4X killed renamable $vsl0, $x1, killed renamable $x3 :: (store (s128), align 8)
-  ; MIR64:   $f12 = XXLXORdpz
-  ; MIR64:   STXVD2X killed renamable $vsl13, $x1, killed renamable $x4 :: (store (s128))
-  ; MIR64:   $f13 = XXLXORdpz
-  ; MIR64:   renamable $x5 = LI8 512
-  ; MIR64:   renamable $x6 = LI8 0
-  ; MIR64:   $x3 = LI8 128
-  ; MIR64:   $x4 = LI8 256
-  ; MIR64:   STD killed renamable $x5, 184, $x1 :: (store (s64))
-  ; MIR64:   STD killed renamable $x6, 176, $x1 :: (store (s64))
-  ; MIR64:   BL8_NOP <mcsymbol .callee[PR]>, csr_ppc64_altivec, implicit-def dead $lr8, implicit $rm, implicit $x3, implicit $x4, implicit $f1, implicit $f2, implicit killed $v2, implicit killed $v3, implicit killed $v4, implicit killed $v5, implicit killed $v6, implicit killed $v7, implicit killed $v8, implicit killed $v9, implicit killed $v10, implicit killed $v11, implicit killed $v12, implicit killed $v13, implicit $f3, implicit $f4, implicit $f5, implicit $f6, implicit $f7, implicit $f8, implicit $f9, implicit $f10, implicit $f11, implicit $f12, implicit $f13, implicit $x2, implicit-def $r1, implicit-def $f1
-  ; MIR64:   ADJCALLSTACKUP 224, 0, implicit-def dead $r1, implicit $r1
-  ; MIR64:   BLR8 implicit $lr8, implicit $rm, implicit $f1
+  ; MIR64-NEXT:   renamable $x3 = LI8 2049
+  ; MIR64-NEXT:   renamable $x4 = LI8 1
+  ; MIR64-NEXT:   renamable $x3 = RLDIC killed renamable $x3, 51, 1
+  ; MIR64-NEXT:   renamable $x4 = RLDIC killed renamable $x4, 62, 1
+  ; MIR64-NEXT:   STD killed renamable $x3, 216, $x1 :: (store (s64) into unknown-address + 24, align 4)
+  ; MIR64-NEXT:   renamable $x3 = LI8 1023
+  ; MIR64-NEXT:   STD killed renamable $x4, 208, $x1 :: (store (s64) into unknown-address + 16, align 4)
+  ; MIR64-NEXT:   renamable $x5 = LI8 0
+  ; MIR64-NEXT:   renamable $x3 = RLDIC killed renamable $x3, 52, 2
+  ; MIR64-NEXT:   STD renamable $x5, 192, $x1 :: (store (s64), align 4)
+  ; MIR64-NEXT:   STD killed renamable $x3, 200, $x1 :: (store (s64) into unknown-address + 8, align 4)
+  ; MIR64-NEXT:   ADJCALLSTACKDOWN 224, 0, implicit-def dead $r1, implicit $r1
+  ; MIR64-NEXT:   renamable $vsl0 = XXLXORz
+  ; MIR64-NEXT:   $f1 = XXLXORdpz
+  ; MIR64-NEXT:   $f2 = XXLXORdpz
+  ; MIR64-NEXT:   $v2 = XXLXORz
+  ; MIR64-NEXT:   $v3 = XXLXORz
+  ; MIR64-NEXT:   $v4 = XXLXORz
+  ; MIR64-NEXT:   $v5 = XXLXORz
+  ; MIR64-NEXT:   $v6 = XXLXORz
+  ; MIR64-NEXT:   $v7 = XXLXORz
+  ; MIR64-NEXT:   $v8 = XXLXORz
+  ; MIR64-NEXT:   $v9 = XXLXORz
+  ; MIR64-NEXT:   $v10 = XXLXORz
+  ; MIR64-NEXT:   $v11 = XXLXORz
+  ; MIR64-NEXT:   $v12 = XXLXORz
+  ; MIR64-NEXT:   $v13 = XXLXORz
+  ; MIR64-NEXT:   $f3 = XXLXORdpz
+  ; MIR64-NEXT:   $f4 = XXLXORdpz
+  ; MIR64-NEXT:   $f5 = XXLXORdpz
+  ; MIR64-NEXT:   $f6 = XXLXORdpz
+  ; MIR64-NEXT:   $f7 = XXLXORdpz
+  ; MIR64-NEXT:   renamable $x3 = LDtocCPT %const.0, $x2 :: (load (s64) from got)
+  ; MIR64-NEXT:   $f8 = XXLXORdpz
+  ; MIR64-NEXT:   $f9 = XXLXORdpz
+  ; MIR64-NEXT:   renamable $x4 = LI8 160
+  ; MIR64-NEXT:   $f10 = XXLXORdpz
+  ; MIR64-NEXT:   renamable $x6 = LI8 144
+  ; MIR64-NEXT:   STXVW4X renamable $vsl0, $x1, killed renamable $x4 :: (store (s128), align 8)
+  ; MIR64-NEXT:   renamable $v0 = LXVD2X $zero8, killed renamable $x3 :: (load (s128) from constant-pool)
+  ; MIR64-NEXT:   $f11 = XXLXORdpz
+  ; MIR64-NEXT:   renamable $x3 = LI8 128
+  ; MIR64-NEXT:   STXVW4X renamable $vsl0, $x1, killed renamable $x6 :: (store (s128), align 8)
+  ; MIR64-NEXT:   $f12 = XXLXORdpz
+  ; MIR64-NEXT:   renamable $x4 = LI8 80
+  ; MIR64-NEXT:   STXVW4X killed renamable $vsl0, $x1, killed renamable $x3 :: (store (s128), align 8)
+  ; MIR64-NEXT:   $f13 = XXLXORdpz
+  ; MIR64-NEXT:   STXVD2X killed renamable $v0, $x1, killed renamable $x4 :: (store (s128))
+  ; MIR64-NEXT:   renamable $x6 = LI8 512
+  ; MIR64-NEXT:   $x3 = LI8 128
+  ; MIR64-NEXT:   $x4 = LI8 256
+  ; MIR64-NEXT:   STD killed renamable $x6, 184, $x1 :: (store (s64))
+  ; MIR64-NEXT:   STD killed renamable $x5, 176, $x1 :: (store (s64))
+  ; MIR64-NEXT:   BL8_NOP <mcsymbol .callee[PR]>, csr_ppc64_altivec, implicit-def dead $lr8, implicit $rm, implicit $x3, implicit $x4, implicit $f1, implicit $f2, implicit $v2, implicit $v3, implicit $v4, implicit $v5, implicit killed $v6, implicit killed $v7, implicit killed $v8, implicit killed $v9, implicit killed $v10, implicit killed $v11, implicit killed $v12, implicit killed $v13, implicit $f3, implicit $f4, implicit $f5, implicit $f6, implicit $f7, implicit $f8, implicit $f9, implicit $f10, implicit $f11, implicit $f12, implicit $f13, implicit $x2, implicit-def $r1, implicit-def $f1
+  ; MIR64-NEXT:   ADJCALLSTACKUP 224, 0, implicit-def dead $r1, implicit $r1
+  ; MIR64-NEXT:   BLR8 implicit $lr8, implicit $rm, implicit $f1
   entry:
     %call = tail call double @callee(i32 signext 128, i32 signext 256, double 0.000000e+00, double 0.000000e+00, <2 x double> <double 0.000000e+00, double 0.000000e+00>, <2 x double> <double 0.000000e+00, double 0.000000e+00>, <2 x double> <double 0.000000e+00, double 0.000000e+00>, <2 x double> <double 0.000000e+00, double 0.000000e+00>, <2 x double> <double 0.000000e+00, double 0.000000e+00>, <2 x double> <double 0.000000e+00, double 0.000000e+00>, <2 x double> <double 0.000000e+00, double 0.000000e+00>, <2 x double> <double 0.000000e+00, double 0.000000e+00>, <2 x double> <double 0.000000e+00, double 0.000000e+00>, <2 x double> <double 0.000000e+00, double 0.000000e+00>, <2 x double> <double 0.000000e+00, double 0.000000e+00>, <2 x double> <double 0.000000e+00, double 0.000000e+00>, <2 x double> <double 2.400000e+01, double 2.500000e+01>, double 0.000000e+00, double 0.000000e+00, double 0.000000e+00, double 0.000000e+00, double 0.000000e+00, double 0.000000e+00, double 0.000000e+00, double 0.000000e+00, double 0.000000e+00, double 0.000000e+00, double 0.000000e+00, i32 signext 512, %struct.Test* nonnull byval(%struct.Test) align 4 @__const.caller.t)
       ret double %call
 }
 
 declare double @callee(i32 signext, i32 signext, double, double, <2 x double>, <2 x double>, <2 x double>, <2 x double>, <2 x double>, <2 x double>, <2 x double>, <2 x double>, <2 x double>, <2 x double>, <2 x double>, <2 x double>, <2 x double>, double, double, double, double, double, double, double, double, double, double, double, i32 signext, %struct.Test* byval(%struct.Test) align 8)

llvm/test/CodeGen/PowerPC/aix-vec-arg-spills.ll

 @__const.caller.t = private unnamed_addr constant %struct.Test { double 0.000000e+00, double 1.000000e+00, double 2.000000e+00, double 3.000000e+00 }, align 8
 
 define double @caller() {
 ; 32BIT-LABEL: caller:
 ; 32BIT:       # %bb.0: # %entry
 ; 32BIT-NEXT:    mflr 0
 ; 32BIT-NEXT:    stw 0, 8(1)
 ; 32BIT-NEXT:    stwu 1, -192(1)
-; 32BIT-NEXT:    lwz 3, L..C0(2) # @__const.caller.t
-; 32BIT-NEXT:    li 4, 31
+; 32BIT-NEXT:    lis 3, 16392
+; 32BIT-NEXT:    lis 4, 16384
 ; 32BIT-NEXT:    xxlxor 0, 0, 0
-; 32BIT-NEXT:    lwz 5, L..C1(2) # %const.0
+; 32BIT-NEXT:    lwz 5, L..C0(2) # %const.0
 ; 32BIT-NEXT:    li 6, 512
+; 32BIT-NEXT:    stw 3, 180(1)
+; 32BIT-NEXT:    li 3, 0
 ; 32BIT-NEXT:    xxlxor 1, 1, 1
+; 32BIT-NEXT:    stw 4, 172(1)
+; 32BIT-NEXT:    lis 4, 16368
 ; 32BIT-NEXT:    xxlxor 2, 2, 2
-; 32BIT-NEXT:    lvx 2, 3, 4
-; 32BIT-NEXT:    li 4, 16
-; 32BIT-NEXT:    lvsl 4, 0, 3
-; 32BIT-NEXT:    xxlxor 37, 37, 37
-; 32BIT-NEXT:    lvx 3, 3, 4
-; 32BIT-NEXT:    li 4, 172
+; 32BIT-NEXT:    stw 3, 184(1)
+; 32BIT-NEXT:    stw 3, 176(1)
+; 32BIT-NEXT:    xxlxor 34, 34, 34
+; 32BIT-NEXT:    stw 3, 168(1)
+; 32BIT-NEXT:    stw 3, 160(1)
+; 32BIT-NEXT:    xxlxor 35, 35, 35
+; 32BIT-NEXT:    stw 3, 156(1)
+; 32BIT-NEXT:    li 3, 136
 ; 32BIT-NEXT:    lxvd2x 32, 0, 5
+; 32BIT-NEXT:    xxlxor 36, 36, 36
+; 32BIT-NEXT:    stw 4, 164(1)
+; 32BIT-NEXT:    li 4, 120
+; 32BIT-NEXT:    stxvw4x 0, 1, 3
+; 32BIT-NEXT:    xxlxor 37, 37, 37
+; 32BIT-NEXT:    li 3, 104
+; 32BIT-NEXT:    stxvw4x 0, 1, 4
 ; 32BIT-NEXT:    xxlxor 38, 38, 38
-; 32BIT-NEXT:    xxlxor 39, 39, 39
 ; 32BIT-NEXT:    li 5, 48
-; 32BIT-NEXT:    vperm 2, 3, 2, 4
+; 32BIT-NEXT:    stxvw4x 0, 1, 3
+; 32BIT-NEXT:    li 3, 88
+; 32BIT-NEXT:    xxlxor 39, 39, 39
+; 32BIT-NEXT:    li 4, 256
 ; 32BIT-NEXT:    xxlxor 40, 40, 40
+; 32BIT-NEXT:    stxvw4x 0, 1, 3
+; 32BIT-NEXT:    li 3, 72
 ; 32BIT-NEXT:    xxlxor 41, 41, 41
+; 32BIT-NEXT:    stxvw4x 0, 1, 3
+; 32BIT-NEXT:    li 3, 128
 ; 32BIT-NEXT:    xxlxor 42, 42, 42
+; 32BIT-NEXT:    stxvd2x 32, 1, 5
+; 32BIT-NEXT:    stw 6, 152(1)
 ; 32BIT-NEXT:    xxlxor 43, 43, 43
 ; 32BIT-NEXT:    xxlxor 44, 44, 44
-; 32BIT-NEXT:    stxvw4x 34, 1, 4
-; 32BIT-NEXT:    li 4, 120
 ; 32BIT-NEXT:    xxlxor 45, 45, 45
-; 32BIT-NEXT:    lvx 2, 0, 3
-; 32BIT-NEXT:    li 3, 156
 ; 32BIT-NEXT:    xxlxor 3, 3, 3
 ; 32BIT-NEXT:    xxlxor 4, 4, 4
-; 32BIT-NEXT:    vperm 2, 2, 3, 4
-; 32BIT-NEXT:    xxlxor 35, 35, 35
-; 32BIT-NEXT:    xxlxor 36, 36, 36
 ; 32BIT-NEXT:    xxlxor 5, 5, 5
 ; 32BIT-NEXT:    xxlxor 6, 6, 6
 ; 32BIT-NEXT:    xxlxor 7, 7, 7
-; 32BIT-NEXT:    stxvw4x 34, 1, 3
-; 32BIT-NEXT:    li 3, 136
-; 32BIT-NEXT:    xxlxor 34, 34, 34
-; 32BIT-NEXT:    stxvw4x 0, 1, 3
-; 32BIT-NEXT:    li 3, 104
-; 32BIT-NEXT:    stxvw4x 0, 1, 4
-; 32BIT-NEXT:    li 4, 256
-; 32BIT-NEXT:    stxvw4x 0, 1, 3
-; 32BIT-NEXT:    li 3, 88
 ; 32BIT-NEXT:    xxlxor 8, 8, 8
 ; 32BIT-NEXT:    xxlxor 9, 9, 9
-; 32BIT-NEXT:    stxvw4x 0, 1, 3
-; 32BIT-NEXT:    li 3, 72
 ; 32BIT-NEXT:    xxlxor 10, 10, 10
-; 32BIT-NEXT:    stxvw4x 0, 1, 3
-; 32BIT-NEXT:    li 3, 128
 ; 32BIT-NEXT:    xxlxor 11, 11, 11
-; 32BIT-NEXT:    stxvd2x 32, 1, 5
-; 32BIT-NEXT:    stw 6, 152(1)
 ; 32BIT-NEXT:    xxlxor 12, 12, 12
 ; 32BIT-NEXT:    xxlxor 13, 13, 13
 ; 32BIT-NEXT:    bl .callee[PR]
 ; 32BIT-NEXT:    nop
 ; 32BIT-NEXT:    addi 1, 1, 192
 ; 32BIT-NEXT:    lwz 0, 8(1)
 ; 32BIT-NEXT:    mtlr 0
 ; 32BIT-NEXT:    blr
 ;
 ; 64BIT-LABEL: caller:
 ; 64BIT:       # %bb.0: # %entry
 ; 64BIT-NEXT:    mflr 0
 ; 64BIT-NEXT:    std 0, 16(1)
 ; 64BIT-NEXT:    stdu 1, -224(1)
-; 64BIT-NEXT:    ld 3, L..C0(2) # @__const.caller.t
-; 64BIT-NEXT:    li 4, 16
-; 64BIT-NEXT:    li 5, 144
+; 64BIT-NEXT:    li 3, 2049
+; 64BIT-NEXT:    li 4, 1
+; 64BIT-NEXT:    xxlxor 0, 0, 0
+; 64BIT-NEXT:    li 5, 0
+; 64BIT-NEXT:    rldic 3, 3, 51, 1
+; 64BIT-NEXT:    rldic 4, 4, 62, 1
 ; 64BIT-NEXT:    xxlxor 1, 1, 1
-; 64BIT-NEXT:    li 6, 0
+; 64BIT-NEXT:    li 6, 144
+; 64BIT-NEXT:    std 3, 216(1)
+; 64BIT-NEXT:    li 3, 1023
 ; 64BIT-NEXT:    xxlxor 2, 2, 2
+; 64BIT-NEXT:    rldic 3, 3, 52, 2
+; 64BIT-NEXT:    std 4, 208(1)
+; 64BIT-NEXT:    li 4, 160
 ; 64BIT-NEXT:    xxlxor 34, 34, 34
-; 64BIT-NEXT:    lxvd2x 0, 3, 4
-; 64BIT-NEXT:    li 4, 208
+; 64BIT-NEXT:    std 3, 200(1)
+; 64BIT-NEXT:    ld 3, L..C0(2) # %const.0
+; 64BIT-NEXT:    std 5, 192(1)
 ; 64BIT-NEXT:    xxlxor 35, 35, 35
 ; 64BIT-NEXT:    xxlxor 36, 36, 36
+; 64BIT-NEXT:    stxvw4x 0, 1, 4
+; 64BIT-NEXT:    li 4, 80
 ; 64BIT-NEXT:    xxlxor 37, 37, 37
-; 64BIT-NEXT:    stxvd2x 0, 1, 4
-; 64BIT-NEXT:    li 4, 160
+; 64BIT-NEXT:    stxvw4x 0, 1, 6
+; 64BIT-NEXT:    li 6, 512
+; 64BIT-NEXT:    lxvd2x 32, 0, 3
 ; 64BIT-NEXT:    xxlxor 38, 38, 38
-; 64BIT-NEXT:    lxvd2x 0, 0, 3
-; 64BIT-NEXT:    li 3, 192
+; 64BIT-NEXT:    li 3, 128
 ; 64BIT-NEXT:    xxlxor 39, 39, 39
+; 64BIT-NEXT:    stxvw4x 0, 1, 3
 ; 64BIT-NEXT:    xxlxor 40, 40, 40
 ; 64BIT-NEXT:    xxlxor 41, 41, 41
-; 64BIT-NEXT:    stxvd2x 0, 1, 3
-; 64BIT-NEXT:    ld 3, L..C1(2) # %const.0
-; 64BIT-NEXT:    xxlxor 0, 0, 0
+; 64BIT-NEXT:    stxvd2x 32, 1, 4
+; 64BIT-NEXT:    li 4, 256
+; 64BIT-NEXT:    std 6, 184(1)
 ; 64BIT-NEXT:    xxlxor 42, 42, 42
-; 64BIT-NEXT:    stxvw4x 0, 1, 4
-; 64BIT-NEXT:    li 4, 80
+; 64BIT-NEXT:    std 5, 176(1)
 ; 64BIT-NEXT:    xxlxor 43, 43, 43
-; 64BIT-NEXT:    lxvd2x 13, 0, 3
-; 64BIT-NEXT:    li 3, 128
 ; 64BIT-NEXT:    xxlxor 44, 44, 44
-; 64BIT-NEXT:    stxvw4x 0, 1, 5
 ; 64BIT-NEXT:    xxlxor 45, 45, 45
-; 64BIT-NEXT:    stxvw4x 0, 1, 3
-; 64BIT-NEXT:    li 5, 512
 ; 64BIT-NEXT:    xxlxor 3, 3, 3
 ; 64BIT-NEXT:    xxlxor 4, 4, 4
-; 64BIT-NEXT:    stxvd2x 13, 1, 4
-; 64BIT-NEXT:    li 4, 256
-; 64BIT-NEXT:    std 5, 184(1)
 ; 64BIT-NEXT:    xxlxor 5, 5, 5
-; 64BIT-NEXT:    std 6, 176(1)
 ; 64BIT-NEXT:    xxlxor 6, 6, 6
 ; 64BIT-NEXT:    xxlxor 7, 7, 7
 ; 64BIT-NEXT:    xxlxor 8, 8, 8
 ; 64BIT-NEXT:    xxlxor 9, 9, 9
 ; 64BIT-NEXT:    xxlxor 10, 10, 10
 ; 64BIT-NEXT:    xxlxor 11, 11, 11
 ; 64BIT-NEXT:    xxlxor 12, 12, 12
 ; 64BIT-NEXT:    xxlxor 13, 13, 13

llvm/test/DebugInfo/COFF/types-array.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s
 ; RUN: llc < %s | llvm-mc -filetype=obj --triple=i686-windows | llvm-readobj - --codeview | FileCheck %s
 
 ; C++ source to regenerate:
 ; $ cat t.cpp
 ; void usevars(int, ...);
 ; void f() {
 ;   int a[5] = {9, 4, 5, 4, 2};

 ; CHECK:       Type: 0x1003
 ; CHECK:       Flags [ (0x0)
 ; CHECK:       ]
 ; CHECK:       VarName: a
 ; CHECK:     }
 ; CHECK:     DefRangeFramePointerRelSym {
 ; CHECK:       Offset: -20
 ; CHECK:       LocalVariableAddrRange {
-; CHECK:         OffsetStart: .text+0x6
+; CHECK:         OffsetStart: .text+0x9
 ; CHECK:         ISectStart: 0x0
-; CHECK:         Range: 0x33
+; CHECK:         Range: 0x30
 ; CHECK:       }
 ; CHECK:     }
 ; CHECK:     ProcEnd {
 ; CHECK:     }
 ; CHECK:   ]
 
 ; ModuleID = 't.cpp'
 source_filename = "t.cpp"

llvm/test/Transforms/InstCombine/memchr-5.ll

 ; LE representation: { 'd', 'c', 'b', 'a', 'h', ..., 'm' }
 @a = constant [4 x i32] [i32 1633837924, i32 1701209960, i32 1768581996, i32 1835954032]
 
 
 ; Fold memchr(a, C, 16) for C in ['a', 'd'] U ['o', 'q'].
 
 define void @fold_memchr_a(i64* %pcmp) {
 ; BE-LABEL: @fold_memchr_a(
-; BE-NEXT:    [[PA:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast ([4 x i32]* @a to i8*), i32 97, i64 16)
-; BE-NEXT:    [[IPA:%.*]] = ptrtoint i8* [[PA]] to i64
-; BE-NEXT:    [[OFFA:%.*]] = sub i64 [[IPA]], ptrtoint ([4 x i32]* @a to i64)
-; BE-NEXT:    store i64 [[OFFA]], i64* [[PCMP:%.*]], align 4
-; BE-NEXT:    [[PB:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast ([4 x i32]* @a to i8*), i32 98, i64 16)
-; BE-NEXT:    [[IPB:%.*]] = ptrtoint i8* [[PB]] to i64
-; BE-NEXT:    [[OFFB:%.*]] = sub i64 [[IPB]], ptrtoint ([4 x i32]* @a to i64)
+; BE-NEXT:    store i64 0, i64* [[PCMP:%.*]], align 4
 ; BE-NEXT:    [[PSTOR1:%.*]] = getelementptr i64, i64* [[PCMP]], i64 1
-; BE-NEXT:    store i64 [[OFFB]], i64* [[PSTOR1]], align 4
-; BE-NEXT:    [[PC:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast ([4 x i32]* @a to i8*), i32 99, i64 16)
-; BE-NEXT:    [[IPC:%.*]] = ptrtoint i8* [[PC]] to i64
-; BE-NEXT:    [[OFFC:%.*]] = sub i64 [[IPC]], ptrtoint ([4 x i32]* @a to i64)
+; BE-NEXT:    store i64 1, i64* [[PSTOR1]], align 4
 ; BE-NEXT:    [[PSTOR2:%.*]] = getelementptr i64, i64* [[PCMP]], i64 2
-; BE-NEXT:    store i64 [[OFFC]], i64* [[PSTOR2]], align 4
-; BE-NEXT:    [[PD:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast ([4 x i32]* @a to i8*), i32 100, i64 16)
-; BE-NEXT:    [[IPD:%.*]] = ptrtoint i8* [[PD]] to i64
-; BE-NEXT:    [[OFFD:%.*]] = sub i64 [[IPD]], ptrtoint ([4 x i32]* @a to i64)
+; BE-NEXT:    store i64 2, i64* [[PSTOR2]], align 4
 ; BE-NEXT:    [[PSTOR3:%.*]] = getelementptr i64, i64* [[PCMP]], i64 3
-; BE-NEXT:    store i64 [[OFFD]], i64* [[PSTOR3]], align 4
-; BE-NEXT:    [[PN:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast ([4 x i32]* @a to i8*), i32 110, i64 16)
-; BE-NEXT:    [[IPN:%.*]] = ptrtoint i8* [[PN]] to i64
-; BE-NEXT:    [[OFFN:%.*]] = sub i64 [[IPN]], ptrtoint ([4 x i32]* @a to i64)
+; BE-NEXT:    store i64 3, i64* [[PSTOR3]], align 4
 ; BE-NEXT:    [[PSTOR4:%.*]] = getelementptr i64, i64* [[PCMP]], i64 4
-; BE-NEXT:    store i64 [[OFFN]], i64* [[PSTOR4]], align 4
-; BE-NEXT:    [[PO:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast ([4 x i32]* @a to i8*), i32 111, i64 16)
-; BE-NEXT:    [[IPO:%.*]] = ptrtoint i8* [[PO]] to i64
-; BE-NEXT:    [[OFFO:%.*]] = sub i64 [[IPO]], ptrtoint ([4 x i32]* @a to i64)
+; BE-NEXT:    store i64 13, i64* [[PSTOR4]], align 4
 ; BE-NEXT:    [[PSTOR6:%.*]] = getelementptr i64, i64* [[PCMP]], i64 6
-; BE-NEXT:    store i64 [[OFFO]], i64* [[PSTOR6]], align 4
-; BE-NEXT:    [[PP:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast ([4 x i32]* @a to i8*), i32 112, i64 16)
-; BE-NEXT:    [[IPP:%.*]] = ptrtoint i8* [[PP]] to i64
-; BE-NEXT:    [[OFFP:%.*]] = sub i64 [[IPP]], ptrtoint ([4 x i32]* @a to i64)
+; BE-NEXT:    store i64 14, i64* [[PSTOR6]], align 4
 ; BE-NEXT:    [[PSTOR7:%.*]] = getelementptr i64, i64* [[PCMP]], i64 7
-; BE-NEXT:    store i64 [[OFFP]], i64* [[PSTOR7]], align 4
-; BE-NEXT:    [[PQ:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast ([4 x i32]* @a to i8*), i32 113, i64 16)
-; BE-NEXT:    [[IPQ:%.*]] = ptrtoint i8* [[PQ]] to i64
+; BE-NEXT:    store i64 15, i64* [[PSTOR7]], align 4
 ; BE-NEXT:    [[PSTOR8:%.*]] = getelementptr i64, i64* [[PCMP]], i64 8
-; BE-NEXT:    store i64 [[IPQ]], i64* [[PSTOR8]], align 4
+; BE-NEXT:    store i64 0, i64* [[PSTOR8]], align 4
 ; BE-NEXT:    ret void
 ;
 ; LE-LABEL: @fold_memchr_a(
-; LE-NEXT:    [[PA:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast ([4 x i32]* @a to i8*), i32 97, i64 16)
-; LE-NEXT:    [[IPA:%.*]] = ptrtoint i8* [[PA]] to i64
-; LE-NEXT:    [[OFFA:%.*]] = sub i64 [[IPA]], ptrtoint ([4 x i32]* @a to i64)
-; LE-NEXT:    store i64 [[OFFA]], i64* [[PCMP:%.*]], align 4
-; LE-NEXT:    [[PB:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast ([4 x i32]* @a to i8*), i32 98, i64 16)
-; LE-NEXT:    [[IPB:%.*]] = ptrtoint i8* [[PB]] to i64
-; LE-NEXT:    [[OFFB:%.*]] = sub i64 [[IPB]], ptrtoint ([4 x i32]* @a to i64)
+; LE-NEXT:    store i64 3, i64* [[PCMP:%.*]], align 4
 ; LE-NEXT:    [[PSTOR1:%.*]] = getelementptr i64, i64* [[PCMP]], i64 1
-; LE-NEXT:    store i64 [[OFFB]], i64* [[PSTOR1]], align 4
-; LE-NEXT:    [[PC:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast ([4 x i32]* @a to i8*), i32 99, i64 16)
-; LE-NEXT:    [[IPC:%.*]] = ptrtoint i8* [[PC]] to i64
-; LE-NEXT:    [[OFFC:%.*]] = sub i64 [[IPC]], ptrtoint ([4 x i32]* @a to i64)
+; LE-NEXT:    store i64 2, i64* [[PSTOR1]], align 4
 ; LE-NEXT:    [[PSTOR2:%.*]] = getelementptr i64, i64* [[PCMP]], i64 2
-; LE-NEXT:    store i64 [[OFFC]], i64* [[PSTOR2]], align 4
-; LE-NEXT:    [[PD:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast ([4 x i32]* @a to i8*), i32 100, i64 16)
-; LE-NEXT:    [[IPD:%.*]] = ptrtoint i8* [[PD]] to i64
-; LE-NEXT:    [[OFFD:%.*]] = sub i64 [[IPD]], ptrtoint ([4 x i32]* @a to i64)
+; LE-NEXT:    store i64 1, i64* [[PSTOR2]], align 4
 ; LE-NEXT:    [[PSTOR3:%.*]] = getelementptr i64, i64* [[PCMP]], i64 3
-; LE-NEXT:    store i64 [[OFFD]], i64* [[PSTOR3]], align 4
-; LE-NEXT:    [[PN:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast ([4 x i32]* @a to i8*), i32 110, i64 16)
-; LE-NEXT:    [[IPN:%.*]] = ptrtoint i8* [[PN]] to i64
-; LE-NEXT:    [[OFFN:%.*]] = sub i64 [[IPN]], ptrtoint ([4 x i32]* @a to i64)
+; LE-NEXT:    store i64 0, i64* [[PSTOR3]], align 4
 ; LE-NEXT:    [[PSTOR4:%.*]] = getelementptr i64, i64* [[PCMP]], i64 4
-; LE-NEXT:    store i64 [[OFFN]], i64* [[PSTOR4]], align 4
-; LE-NEXT:    [[PO:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast ([4 x i32]* @a to i8*), i32 111, i64 16)
-; LE-NEXT:    [[IPO:%.*]] = ptrtoint i8* [[PO]] to i64
-; LE-NEXT:    [[OFFO:%.*]] = sub i64 [[IPO]], ptrtoint ([4 x i32]* @a to i64)
+; LE-NEXT:    store i64 14, i64* [[PSTOR4]], align 4
 ; LE-NEXT:    [[PSTOR6:%.*]] = getelementptr i64, i64* [[PCMP]], i64 6
-; LE-NEXT:    store i64 [[OFFO]], i64* [[PSTOR6]], align 4
-; LE-NEXT:    [[PP:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast ([4 x i32]* @a to i8*), i32 112, i64 16)
-; LE-NEXT:    [[IPP:%.*]] = ptrtoint i8* [[PP]] to i64
-; LE-NEXT:    [[OFFP:%.*]] = sub i64 [[IPP]], ptrtoint ([4 x i32]* @a to i64)
+; LE-NEXT:    store i64 13, i64* [[PSTOR6]], align 4
 ; LE-NEXT:    [[PSTOR7:%.*]] = getelementptr i64, i64* [[PCMP]], i64 7
-; LE-NEXT:    store i64 [[OFFP]], i64* [[PSTOR7]], align 4
-; LE-NEXT:    [[PQ:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast ([4 x i32]* @a to i8*), i32 113, i64 16)
-; LE-NEXT:    [[IPQ:%.*]] = ptrtoint i8* [[PQ]] to i64
+; LE-NEXT:    store i64 12, i64* [[PSTOR7]], align 4
 ; LE-NEXT:    [[PSTOR8:%.*]] = getelementptr i64, i64* [[PCMP]], i64 8
-; LE-NEXT:    store i64 [[IPQ]], i64* [[PSTOR8]], align 4
+; LE-NEXT:    store i64 0, i64* [[PSTOR8]], align 4
 ; LE-NEXT:    ret void
 ;
   %p0 = getelementptr [4 x i32], [4 x i32]* @a, i64 0, i64 0
   %p1 = bitcast i32* %p0 to i8*
   %ip0 = ptrtoint [4 x i32]* @a to i64
 
 ; Fold memchr(a, 'a', 16) - a to 0 (3 in LE).
 
; Fold memchr(a, 'q', 16) to null in both BE and LE.
   ret void
 }
 
 
 ; Fold memchr(a + 1, C, 12) for C in ['e', 'h'] U ['a', 'd'].
 
 define void @fold_memchr_a_p1(i64* %pcmp) {
 ; BE-LABEL: @fold_memchr_a_p1(
-; BE-NEXT:    [[PE:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast (i32* getelementptr inbounds ([4 x i32], [4 x i32]* @a, i64 0, i64 1) to i8*), i32 101, i64 12)
-; BE-NEXT:    [[IPE:%.*]] = ptrtoint i8* [[PE]] to i64
-; BE-NEXT:    [[OFFE:%.*]] = sub i64 [[IPE]], ptrtoint (i32* getelementptr inbounds ([4 x i32], [4 x i32]* @a, i64 0, i64 1) to i64)
-; BE-NEXT:    store i64 [[OFFE]], i64* [[PCMP:%.*]], align 4
-; BE-NEXT:    [[PF:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast (i32* getelementptr inbounds ([4 x i32], [4 x i32]* @a, i64 0, i64 1) to i8*), i32 102, i64 12)
-; BE-NEXT:    [[IPF:%.*]] = ptrtoint i8* [[PF]] to i64
-; BE-NEXT:    [[OFFF:%.*]] = sub i64 [[IPF]], ptrtoint (i32* getelementptr inbounds ([4 x i32], [4 x i32]* @a, i64 0, i64 1) to i64)
+; BE-NEXT:    store i64 0, i64* [[PCMP:%.*]], align 4
 ; BE-NEXT:    [[PSTOR1:%.*]] = getelementptr i64, i64* [[PCMP]], i64 1
-; BE-NEXT:    store i64 [[OFFF]], i64* [[PSTOR1]], align 4
-; BE-NEXT:    [[PG:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast (i32* getelementptr inbounds ([4 x i32], [4 x i32]* @a, i64 0, i64 1) to i8*), i32 103, i64 12)
-; BE-NEXT:    [[IPG:%.*]] = ptrtoint i8* [[PG]] to i64
-; BE-NEXT:    [[OFFG:%.*]] = sub i64 [[IPG]], ptrtoint (i32* getelementptr inbounds ([4 x i32], [4 x i32]* @a, i64 0, i64 1) to i64)
+; BE-NEXT:    store i64 1, i64* [[PSTOR1]], align 4
 ; BE-NEXT:    [[PSTOR2:%.*]] = getelementptr i64, i64* [[PCMP]], i64 2
-; BE-NEXT:    store i64 [[OFFG]], i64* [[PSTOR2]], align 4
-; BE-NEXT:    [[PH:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast (i32* getelementptr inbounds ([4 x i32], [4 x i32]* @a, i64 0, i64 1) to i8*), i32 104, i64 12)
-; BE-NEXT:    [[IPH:%.*]] = ptrtoint i8* [[PH]] to i64
-; BE-NEXT:    [[OFFH:%.*]] = sub i64 [[IPH]], ptrtoint (i32* getelementptr inbounds ([4 x i32], [4 x i32]* @a, i64 0, i64 1) to i64)
+; BE-NEXT:    store i64 2, i64* [[PSTOR2]], align 4
 ; BE-NEXT:    [[PSTOR3:%.*]] = getelementptr i64, i64* [[PCMP]], i64 3
-; BE-NEXT:    store i64 [[OFFH]], i64* [[PSTOR3]], align 4
-; BE-NEXT:    [[PA:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast (i32* getelementptr inbounds ([4 x i32], [4 x i32]* @a, i64 0, i64 1) to i8*), i32 97, i64 12)
-; BE-NEXT:    [[IPA:%.*]] = ptrtoint i8* [[PA]] to i64
+; BE-NEXT:    store i64 3, i64* [[PSTOR3]], align 4
 ; BE-NEXT:    [[PSTOR4:%.*]] = getelementptr i64, i64* [[PCMP]], i64 4
-; BE-NEXT:    store i64 [[IPA]], i64* [[PSTOR4]], align 4
-; BE-NEXT:    [[PD:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast (i32* getelementptr inbounds ([4 x i32], [4 x i32]* @a, i64 0, i64 1) to i8*), i32 100, i64 12)
-; BE-NEXT:    [[IPD:%.*]] = ptrtoint i8* [[PD]] to i64
+; BE-NEXT:    store i64 0, i64* [[PSTOR4]], align 4
 ; BE-NEXT:    [[PSTOR5:%.*]] = getelementptr i64, i64* [[PCMP]], i64 5
-; BE-NEXT:    store i64 [[IPD]], i64* [[PSTOR5]], align 4
+; BE-NEXT:    store i64 0, i64* [[PSTOR5]], align 4
 ; BE-NEXT:    ret void
 ;
 ; LE-LABEL: @fold_memchr_a_p1(
-; LE-NEXT:    [[PE:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast (i32* getelementptr inbounds ([4 x i32], [4 x i32]* @a, i64 0, i64 1) to i8*), i32 101, i64 12)
-; LE-NEXT:    [[IPE:%.*]] = ptrtoint i8* [[PE]] to i64
-; LE-NEXT:    [[OFFE:%.*]] = sub i64 [[IPE]], ptrtoint (i32* getelementptr inbounds ([4 x i32], [4 x i32]* @a, i64 0, i64 1) to i64)
-; LE-NEXT:    store i64 [[OFFE]], i64* [[PCMP:%.*]], align 4
-; LE-NEXT:    [[PF:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast (i32* getelementptr inbounds ([4 x i32], [4 x i32]* @a, i64 0, i64 1) to i8*), i32 102, i64 12)
-; LE-NEXT:    [[IPF:%.*]] = ptrtoint i8* [[PF]] to i64
-; LE-NEXT:    [[OFFF:%.*]] = sub i64 [[IPF]], ptrtoint (i32* getelementptr inbounds ([4 x i32], [4 x i32]* @a, i64 0, i64 1) to i64)
+; LE-NEXT:    store i64 3, i64* [[PCMP:%.*]], align 4
 ; LE-NEXT:    [[PSTOR1:%.*]] = getelementptr i64, i64* [[PCMP]], i64 1
-; LE-NEXT:    store i64 [[OFFF]], i64* [[PSTOR1]], align 4
-; LE-NEXT:    [[PG:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast (i32* getelementptr inbounds ([4 x i32], [4 x i32]* @a, i64 0, i64 1) to i8*), i32 103, i64 12)
-; LE-NEXT:    [[IPG:%.*]] = ptrtoint i8* [[PG]] to i64
-; LE-NEXT:    [[OFFG:%.*]] = sub i64 [[IPG]], ptrtoint (i32* getelementptr inbounds ([4 x i32], [4 x i32]* @a, i64 0, i64 1) to i64)
+; LE-NEXT:    store i64 2, i64* [[PSTOR1]], align 4
 ; LE-NEXT:    [[PSTOR2:%.*]] = getelementptr i64, i64* [[PCMP]], i64 2
-; LE-NEXT:    store i64 [[OFFG]], i64* [[PSTOR2]], align 4
-; LE-NEXT:    [[PH:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast (i32* getelementptr inbounds ([4 x i32], [4 x i32]* @a, i64 0, i64 1) to i8*), i32 104, i64 12)
-; LE-NEXT:    [[IPH:%.*]] = ptrtoint i8* [[PH]] to i64
-; LE-NEXT:    [[OFFH:%.*]] = sub i64 [[IPH]], ptrtoint (i32* getelementptr inbounds ([4 x i32], [4 x i32]* @a, i64 0, i64 1) to i64)
+; LE-NEXT:    store i64 1, i64* [[PSTOR2]], align 4
 ; LE-NEXT:    [[PSTOR3:%.*]] = getelementptr i64, i64* [[PCMP]], i64 3
-; LE-NEXT:    store i64 [[OFFH]], i64* [[PSTOR3]], align 4
-; LE-NEXT:    [[PA:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast (i32* getelementptr inbounds ([4 x i32], [4 x i32]* @a, i64 0, i64 1) to i8*), i32 97, i64 12)
-; LE-NEXT:    [[IPA:%.*]] = ptrtoint i8* [[PA]] to i64
+; LE-NEXT:    store i64 0, i64* [[PSTOR3]], align 4
 ; LE-NEXT:    [[PSTOR4:%.*]] = getelementptr i64, i64* [[PCMP]], i64 4
-; LE-NEXT:    store i64 [[IPA]], i64* [[PSTOR4]], align 4
-; LE-NEXT:    [[PD:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) bitcast (i32* getelementptr inbounds ([4 x i32], [4 x i32]* @a, i64 0, i64 1) to i8*), i32 100, i64 12)
-; LE-NEXT:    [[IPD:%.*]] = ptrtoint i8* [[PD]] to i64
+; LE-NEXT:    store i64 0, i64* [[PSTOR4]], align 4
 ; LE-NEXT:    [[PSTOR5:%.*]] = getelementptr i64, i64* [[PCMP]], i64 5
-; LE-NEXT:    store i64 [[IPD]], i64* [[PSTOR5]], align 4
+; LE-NEXT:    store i64 0, i64* [[PSTOR5]], align 4
 ; LE-NEXT:    ret void
 ;
   %p0 = getelementptr [4 x i32], [4 x i32]* @a, i64 0, i64 1
   %p1 = bitcast i32* %p0 to i8*
   %ip0 = ptrtoint i8* %p1 to i64
 
 ; Fold memchr(a + 1, 'e', 12) - a to 0 (3 in LE).
 

llvm/test/Transforms/InstCombine/memchr-8.ll

+; RUN: opt < %s -passes=instcombine -S | FileCheck %s
+;
+; Verify that a constant with size in excess of 32-bit SIZE_MAX doesn't
+; cause trouble.  This test exercises an internal limit set arbitrarily
+; at 64K for the largest supported zeroinitiazer. If the limit changes
+; the test might need to be adjusted.
+
+declare i8* @memrchr(i8*, i32, i64)
+
+@a = constant <{ i8, [4294967295 x i8] }> <{ i8 1, [4294967295 x i8] zeroinitializer }>
+
+; Verify reading an initializer INT32_MAX + 1 bytes large (starting at
+; offset 2147483647 into a which is UINT32_MAX bytes in size).
+
+define i8* @call_a_pi32max_p1() {
+; CHECK-LABEL: @call_a_pi32max_p1(
+; CHECK-NEXT:    [[CHR:%.*]] = tail call i8* @memrchr(i8* noundef nonnull dereferenceable(2147483647) getelementptr inbounds (<{ i8, [4294967295 x i8] }>, <{ i8, [4294967295 x i8] }>* @a, i64 0, i32 1, i64 2147483647), i32 0, i64 2147483647)
+; CHECK-NEXT:    ret i8* [[CHR]]
+;
+  %ptr = getelementptr <{ i8, [4294967295 x i8] }>, <{ i8, [4294967295 x i8] }>* @a, i32 0, i32 1, i32 2147483647
+  %chr = tail call i8* @memrchr(i8* %ptr, i32 0, i64 2147483647)
+  ret i8* %chr
+}
+
+; Verify reading an initializer INT32_MAX bytes large (starting at offset
+; 2147483648 into a which is UINT32_MAX bytes in size).
+
+define i8* @call_a_pi32max() {
+; CHECK-LABEL: @call_a_pi32max(
+; CHECK-NEXT:    [[CHR:%.*]] = tail call i8* @memrchr(i8* noundef nonnull dereferenceable(2147483647) getelementptr inbounds (<{ i8, [4294967295 x i8] }>, <{ i8, [4294967295 x i8] }>* @a, i64 0, i32 1, i64 2147483648), i32 0, i64 2147483647)
+; CHECK-NEXT:    ret i8* [[CHR]]
+;
+  %ptr = getelementptr <{ i8, [4294967295 x i8] }>, <{ i8, [4294967295 x i8] }>* @a, i32 0, i32 1, i64 2147483648
+  %chr = tail call i8* @memrchr(i8* %ptr, i32 0, i64 2147483647)
+  ret i8* %chr
+}
+
+
+; Verify reading an initializer UINT32_MAX bytes large (starting at offset
+; 1 into a).
+
+define i8* @call_a_pui32max() {
+; CHECK-LABEL: @call_a_pui32max(
+; CHECK-NEXT:    [[CHR:%.*]] = tail call i8* @memrchr(i8* noundef nonnull dereferenceable(4294967295) getelementptr inbounds (<{ i8, [4294967295 x i8] }>, <{ i8, [4294967295 x i8] }>* @a, i64 0, i32 1, i64 0), i32 0, i64 4294967295)
+; CHECK-NEXT:    ret i8* [[CHR]]
+;
+  %ptr = getelementptr <{ i8, [4294967295 x i8] }>, <{ i8, [4294967295 x i8] }>* @a, i32 0, i32 1, i32 0
+  %chr = tail call i8* @memrchr(i8* %ptr, i32 0, i64 4294967295)
+  ret i8* %chr
+}
+
+; Verify reading an initializer UINT32_MAX + 1 bytes large (all of a).
+
+define i8* @call_a_puimax_p1() {
+; CHECK-LABEL: @call_a_puimax_p1(
+; CHECK-NEXT:    [[CHR:%.*]] = tail call i8* @memrchr(i8* noundef nonnull dereferenceable(4294967296) getelementptr inbounds (<{ i8, [4294967295 x i8] }>, <{ i8, [4294967295 x i8] }>* @a, i64 0, i32 0), i32 0, i64 4294967296)
+; CHECK-NEXT:    ret i8* [[CHR]]
+;
+  %ptr = getelementptr <{ i8, [4294967295 x i8] }>, <{ i8, [4294967295 x i8] }>* @a, i32 0, i32 0
+  %chr = tail call i8* @memrchr(i8* %ptr, i32 0, i64 4294967296)
+  ret i8* %chr
+}
 No newline at end of file

llvm/test/Transforms/InstCombine/memcmp-3.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; Verify that calls to memcmp with arrays of elements larger than char
 ; are folded correctly.
 ; RUN: opt < %s -passes=instcombine -S -data-layout="E" | FileCheck %s --check-prefixes=BE
 ; RUN: opt < %s -passes=instcombine -S -data-layout="e" | FileCheck %s --check-prefixes=LE
 
 declare i32 @memcmp(i8*, i8*, i64)
 
 ; BE representation: { 'a', 'b', 'c', ..., 'f', 'g', 'h' }
 ; LE representation: { 'b', 'a', 'd', ..., 'e', 'h', 'g' }
-@ia6a = constant [4 x i16] [i16 24930, i16 25444, i16 25958, i16 26472]
+@ia16a = constant [4 x i16] [i16 24930, i16 25444, i16 25958, i16 26472]
 
 ; Same as the BE representation above except ending in "gg".
 @i8a = constant [8 x i8] c"abcdefgg"
 
-; Fold memcmp(ia6a, i8a, N) for N in [0, 8].
+; Fold memcmp(ia16a, i8a, N) for N in [0, 8].
 
-define void @fold_memcmp_ia6a_i8a(i32* %pcmp) {
-; BE-LABEL: @fold_memcmp_ia6a_i8a(
+define void @fold_memcmp_ia16a_i8a(i32* %pcmp) {
+; BE-LABEL: @fold_memcmp_ia16a_i8a(
 ; BE-NEXT:    store i32 0, i32* [[PCMP:%.*]], align 4
 ; BE-NEXT:    [[PSTOR1:%.*]] = getelementptr i32, i32* [[PCMP]], i64 1
 ; BE-NEXT:    store i32 0, i32* [[PSTOR1]], align 4
-; BE-NEXT:    [[CMP2:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(2) bitcast ([4 x i16]* @ia6a to i8*), i8* noundef nonnull dereferenceable(2) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 0), i64 2)
 ; BE-NEXT:    [[PSTOR2:%.*]] = getelementptr i32, i32* [[PCMP]], i64 2
-; BE-NEXT:    store i32 [[CMP2]], i32* [[PSTOR2]], align 4
-; BE-NEXT:    [[CMP3:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(3) bitcast ([4 x i16]* @ia6a to i8*), i8* noundef nonnull dereferenceable(3) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 0), i64 3)
+; BE-NEXT:    store i32 0, i32* [[PSTOR2]], align 4
 ; BE-NEXT:    [[PSTOR3:%.*]] = getelementptr i32, i32* [[PCMP]], i64 3
-; BE-NEXT:    store i32 [[CMP3]], i32* [[PSTOR3]], align 4
-; BE-NEXT:    [[CMP4:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(4) bitcast ([4 x i16]* @ia6a to i8*), i8* noundef nonnull dereferenceable(4) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 0), i64 4)
+; BE-NEXT:    store i32 0, i32* [[PSTOR3]], align 4
 ; BE-NEXT:    [[PSTOR4:%.*]] = getelementptr i32, i32* [[PCMP]], i64 4
-; BE-NEXT:    store i32 [[CMP4]], i32* [[PSTOR4]], align 4
-; BE-NEXT:    [[CMP5:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(5) bitcast ([4 x i16]* @ia6a to i8*), i8* noundef nonnull dereferenceable(5) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 0), i64 5)
+; BE-NEXT:    store i32 0, i32* [[PSTOR4]], align 4
 ; BE-NEXT:    [[PSTOR5:%.*]] = getelementptr i32, i32* [[PCMP]], i64 5
-; BE-NEXT:    store i32 [[CMP5]], i32* [[PSTOR5]], align 4
-; BE-NEXT:    [[CMP6:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(6) bitcast ([4 x i16]* @ia6a to i8*), i8* noundef nonnull dereferenceable(6) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 0), i64 6)
+; BE-NEXT:    store i32 0, i32* [[PSTOR5]], align 4
 ; BE-NEXT:    [[PSTOR6:%.*]] = getelementptr i32, i32* [[PCMP]], i64 6
-; BE-NEXT:    store i32 [[CMP6]], i32* [[PSTOR6]], align 4
-; BE-NEXT:    [[CMP7:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(7) bitcast ([4 x i16]* @ia6a to i8*), i8* noundef nonnull dereferenceable(7) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 0), i64 7)
+; BE-NEXT:    store i32 0, i32* [[PSTOR6]], align 4
 ; BE-NEXT:    [[PSTOR7:%.*]] = getelementptr i32, i32* [[PCMP]], i64 7
-; BE-NEXT:    store i32 [[CMP7]], i32* [[PSTOR7]], align 4
-; BE-NEXT:    [[CMP8:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(8) bitcast ([4 x i16]* @ia6a to i8*), i8* noundef nonnull dereferenceable(8) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 0), i64 8)
+; BE-NEXT:    store i32 0, i32* [[PSTOR7]], align 4
 ; BE-NEXT:    [[PSTOR8:%.*]] = getelementptr i32, i32* [[PCMP]], i64 8
-; BE-NEXT:    store i32 [[CMP8]], i32* [[PSTOR8]], align 4
+; BE-NEXT:    store i32 1, i32* [[PSTOR8]], align 4
 ; BE-NEXT:    ret void
 ;
-; LE-LABEL: @fold_memcmp_ia6a_i8a(
+; LE-LABEL: @fold_memcmp_ia16a_i8a(
 ; LE-NEXT:    store i32 0, i32* [[PCMP:%.*]], align 4
 ; LE-NEXT:    [[PSTOR1:%.*]] = getelementptr i32, i32* [[PCMP]], i64 1
 ; LE-NEXT:    store i32 1, i32* [[PSTOR1]], align 4
-; LE-NEXT:    [[CMP2:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(2) bitcast ([4 x i16]* @ia6a to i8*), i8* noundef nonnull dereferenceable(2) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 0), i64 2)
 ; LE-NEXT:    [[PSTOR2:%.*]] = getelementptr i32, i32* [[PCMP]], i64 2
-; LE-NEXT:    store i32 [[CMP2]], i32* [[PSTOR2]], align 4
-; LE-NEXT:    [[CMP3:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(3) bitcast ([4 x i16]* @ia6a to i8*), i8* noundef nonnull dereferenceable(3) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 0), i64 3)
+; LE-NEXT:    store i32 1, i32* [[PSTOR2]], align 4
 ; LE-NEXT:    [[PSTOR3:%.*]] = getelementptr i32, i32* [[PCMP]], i64 3
-; LE-NEXT:    store i32 [[CMP3]], i32* [[PSTOR3]], align 4
-; LE-NEXT:    [[CMP4:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(4) bitcast ([4 x i16]* @ia6a to i8*), i8* noundef nonnull dereferenceable(4) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 0), i64 4)
+; LE-NEXT:    store i32 1, i32* [[PSTOR3]], align 4
 ; LE-NEXT:    [[PSTOR4:%.*]] = getelementptr i32, i32* [[PCMP]], i64 4
-; LE-NEXT:    store i32 [[CMP4]], i32* [[PSTOR4]], align 4
-; LE-NEXT:    [[CMP5:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(5) bitcast ([4 x i16]* @ia6a to i8*), i8* noundef nonnull dereferenceable(5) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 0), i64 5)
+; LE-NEXT:    store i32 1, i32* [[PSTOR4]], align 4
 ; LE-NEXT:    [[PSTOR5:%.*]] = getelementptr i32, i32* [[PCMP]], i64 5
-; LE-NEXT:    store i32 [[CMP5]], i32* [[PSTOR5]], align 4
-; LE-NEXT:    [[CMP6:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(6) bitcast ([4 x i16]* @ia6a to i8*), i8* noundef nonnull dereferenceable(6) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 0), i64 6)
+; LE-NEXT:    store i32 1, i32* [[PSTOR5]], align 4
 ; LE-NEXT:    [[PSTOR6:%.*]] = getelementptr i32, i32* [[PCMP]], i64 6
-; LE-NEXT:    store i32 [[CMP6]], i32* [[PSTOR6]], align 4
-; LE-NEXT:    [[CMP7:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(7) bitcast ([4 x i16]* @ia6a to i8*), i8* noundef nonnull dereferenceable(7) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 0), i64 7)
+; LE-NEXT:    store i32 1, i32* [[PSTOR6]], align 4
 ; LE-NEXT:    [[PSTOR7:%.*]] = getelementptr i32, i32* [[PCMP]], i64 7
-; LE-NEXT:    store i32 [[CMP7]], i32* [[PSTOR7]], align 4
-; LE-NEXT:    [[CMP8:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(8) bitcast ([4 x i16]* @ia6a to i8*), i8* noundef nonnull dereferenceable(8) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 0), i64 8)
+; LE-NEXT:    store i32 1, i32* [[PSTOR7]], align 4
 ; LE-NEXT:    [[PSTOR8:%.*]] = getelementptr i32, i32* [[PCMP]], i64 8
-; LE-NEXT:    store i32 [[CMP8]], i32* [[PSTOR8]], align 4
+; LE-NEXT:    store i32 1, i32* [[PSTOR8]], align 4
 ; LE-NEXT:    ret void
 ;
-  %p0 = getelementptr [4 x i16], [4 x i16]* @ia6a, i64 0, i64 0
+  %p0 = getelementptr [4 x i16], [4 x i16]* @ia16a, i64 0, i64 0
   %p1 = bitcast i16* %p0 to i8*
   %q = getelementptr [8 x i8], [8 x i8]* @i8a, i64 0, i64 0
 
   %cmp0 = call i32 @memcmp(i8* %p1, i8* %q, i64 0)
   %pstor0 = getelementptr i32, i32* %pcmp, i64 0
   store i32 %cmp0, i32* %pstor0
 
   %cmp1 = call i32 @memcmp(i8* %p1, i8* %q, i64 1)
;
   %cmp8 = call i32 @memcmp(i8* %p1, i8* %q, i64 8)
   %pstor8 = getelementptr i32, i32* %pcmp, i64 8
   store i32 %cmp8, i32* %pstor8
 
   ret void
 }
 
 
-; Fold memcmp(ia6a + 1, i8a + 2, N) for N in [0, 6].
+; Fold memcmp(ia16a + 1, i8a + 2, N) for N in [0, 6].
 
-define void @fold_memcmp_ia6a_p1_i8a_p1(i32* %pcmp) {
-; BE-LABEL: @fold_memcmp_ia6a_p1_i8a_p1(
+define void @fold_memcmp_ia16a_p1_i8a_p1(i32* %pcmp) {
+; BE-LABEL: @fold_memcmp_ia16a_p1_i8a_p1(
 ; BE-NEXT:    store i32 0, i32* [[PCMP:%.*]], align 4
 ; BE-NEXT:    [[PSTOR1:%.*]] = getelementptr i32, i32* [[PCMP]], i64 1
 ; BE-NEXT:    store i32 1, i32* [[PSTOR1]], align 4
-; BE-NEXT:    [[CMP2:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(2) bitcast (i16* getelementptr inbounds ([4 x i16], [4 x i16]* @ia6a, i64 0, i64 1) to i8*), i8* noundef nonnull dereferenceable(2) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 1), i64 2)
 ; BE-NEXT:    [[PSTOR2:%.*]] = getelementptr i32, i32* [[PCMP]], i64 2
-; BE-NEXT:    store i32 [[CMP2]], i32* [[PSTOR2]], align 4
-; BE-NEXT:    [[CMP3:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(3) bitcast (i16* getelementptr inbounds ([4 x i16], [4 x i16]* @ia6a, i64 0, i64 1) to i8*), i8* noundef nonnull dereferenceable(3) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 1), i64 3)
+; BE-NEXT:    store i32 1, i32* [[PSTOR2]], align 4
 ; BE-NEXT:    [[PSTOR3:%.*]] = getelementptr i32, i32* [[PCMP]], i64 3
-; BE-NEXT:    store i32 [[CMP3]], i32* [[PSTOR3]], align 4
-; BE-NEXT:    [[CMP4:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(4) bitcast (i16* getelementptr inbounds ([4 x i16], [4 x i16]* @ia6a, i64 0, i64 1) to i8*), i8* noundef nonnull dereferenceable(4) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 1), i64 4)
+; BE-NEXT:    store i32 1, i32* [[PSTOR3]], align 4
 ; BE-NEXT:    [[PSTOR4:%.*]] = getelementptr i32, i32* [[PCMP]], i64 4
-; BE-NEXT:    store i32 [[CMP4]], i32* [[PSTOR4]], align 4
-; BE-NEXT:    [[CMP5:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(5) bitcast (i16* getelementptr inbounds ([4 x i16], [4 x i16]* @ia6a, i64 0, i64 1) to i8*), i8* noundef nonnull dereferenceable(5) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 1), i64 5)
+; BE-NEXT:    store i32 1, i32* [[PSTOR4]], align 4
 ; BE-NEXT:    [[PSTOR5:%.*]] = getelementptr i32, i32* [[PCMP]], i64 5
-; BE-NEXT:    store i32 [[CMP5]], i32* [[PSTOR5]], align 4
-; BE-NEXT:    [[CMP6:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(6) bitcast (i16* getelementptr inbounds ([4 x i16], [4 x i16]* @ia6a, i64 0, i64 1) to i8*), i8* noundef nonnull dereferenceable(6) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 1), i64 6)
+; BE-NEXT:    store i32 1, i32* [[PSTOR5]], align 4
 ; BE-NEXT:    [[PSTOR6:%.*]] = getelementptr i32, i32* [[PCMP]], i64 6
-; BE-NEXT:    store i32 [[CMP6]], i32* [[PSTOR6]], align 4
+; BE-NEXT:    store i32 1, i32* [[PSTOR6]], align 4
 ; BE-NEXT:    ret void
 ;
-; LE-LABEL: @fold_memcmp_ia6a_p1_i8a_p1(
+; LE-LABEL: @fold_memcmp_ia16a_p1_i8a_p1(
 ; LE-NEXT:    store i32 0, i32* [[PCMP:%.*]], align 4
 ; LE-NEXT:    [[PSTOR1:%.*]] = getelementptr i32, i32* [[PCMP]], i64 1
-; LE-NEXT:    store i32 2, i32* [[PSTOR1]], align 4
-; LE-NEXT:    [[CMP2:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(2) bitcast (i16* getelementptr inbounds ([4 x i16], [4 x i16]* @ia6a, i64 0, i64 1) to i8*), i8* noundef nonnull dereferenceable(2) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 1), i64 2)
+; LE-NEXT:    store i32 1, i32* [[PSTOR1]], align 4
 ; LE-NEXT:    [[PSTOR2:%.*]] = getelementptr i32, i32* [[PCMP]], i64 2
-; LE-NEXT:    store i32 [[CMP2]], i32* [[PSTOR2]], align 4
-; LE-NEXT:    [[CMP3:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(3) bitcast (i16* getelementptr inbounds ([4 x i16], [4 x i16]* @ia6a, i64 0, i64 1) to i8*), i8* noundef nonnull dereferenceable(3) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 1), i64 3)
+; LE-NEXT:    store i32 1, i32* [[PSTOR2]], align 4
 ; LE-NEXT:    [[PSTOR3:%.*]] = getelementptr i32, i32* [[PCMP]], i64 3
-; LE-NEXT:    store i32 [[CMP3]], i32* [[PSTOR3]], align 4
-; LE-NEXT:    [[CMP4:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(4) bitcast (i16* getelementptr inbounds ([4 x i16], [4 x i16]* @ia6a, i64 0, i64 1) to i8*), i8* noundef nonnull dereferenceable(4) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 1), i64 4)
+; LE-NEXT:    store i32 1, i32* [[PSTOR3]], align 4
 ; LE-NEXT:    [[PSTOR4:%.*]] = getelementptr i32, i32* [[PCMP]], i64 4
-; LE-NEXT:    store i32 [[CMP4]], i32* [[PSTOR4]], align 4
-; LE-NEXT:    [[CMP5:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(5) bitcast (i16* getelementptr inbounds ([4 x i16], [4 x i16]* @ia6a, i64 0, i64 1) to i8*), i8* noundef nonnull dereferenceable(5) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 1), i64 5)
+; LE-NEXT:    store i32 1, i32* [[PSTOR4]], align 4
 ; LE-NEXT:    [[PSTOR5:%.*]] = getelementptr i32, i32* [[PCMP]], i64 5
-; LE-NEXT:    store i32 [[CMP5]], i32* [[PSTOR5]], align 4
-; LE-NEXT:    [[CMP6:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(6) bitcast (i16* getelementptr inbounds ([4 x i16], [4 x i16]* @ia6a, i64 0, i64 1) to i8*), i8* noundef nonnull dereferenceable(6) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 1), i64 6)
+; LE-NEXT:    store i32 1, i32* [[PSTOR5]], align 4
 ; LE-NEXT:    [[PSTOR6:%.*]] = getelementptr i32, i32* [[PCMP]], i64 6
-; LE-NEXT:    store i32 [[CMP6]], i32* [[PSTOR6]], align 4
+; LE-NEXT:    store i32 1, i32* [[PSTOR6]], align 4
 ; LE-NEXT:    ret void
 ;
-  %p0 = getelementptr [4 x i16], [4 x i16]* @ia6a, i64 0, i64 1
+  %p0 = getelementptr [4 x i16], [4 x i16]* @ia16a, i64 0, i64 1
   %p1 = bitcast i16* %p0 to i8*
   %q = getelementptr [8 x i8], [8 x i8]* @i8a, i64 0, i64 1
 
   %cmp0 = call i32 @memcmp(i8* %p1, i8* %q, i64 0)
   %pstor0 = getelementptr i32, i32* %pcmp, i64 0
   store i32 %cmp0, i32* %pstor0
 
   %cmp1 = call i32 @memcmp(i8* %p1, i8* %q, i64 1)
;
   store i32 %cmp5, i32* %pstor5
 
   %cmp6 = call i32 @memcmp(i8* %p1, i8* %q, i64 6)
   %pstor6 = getelementptr i32, i32* %pcmp, i64 6
   store i32 %cmp6, i32* %pstor6
 
   ret void
 }
-
-
-; Don't fold calls with excessive sizes.
-
-define void @call_memcmp_too_big(i32* %pcmp) {
-; BE-LABEL: @call_memcmp_too_big(
-; BE-NEXT:    [[CMP9:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(9) bitcast ([4 x i16]* @ia6a to i8*), i8* noundef nonnull dereferenceable(9) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 0), i64 9)
-; BE-NEXT:    store i32 [[CMP9]], i32* [[PCMP:%.*]], align 4
-; BE-NEXT:    [[CMPM1:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(18446744073709551615) bitcast ([4 x i16]* @ia6a to i8*), i8* noundef nonnull dereferenceable(18446744073709551615) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 0), i64 -1)
-; BE-NEXT:    [[PSTORM1:%.*]] = getelementptr i32, i32* [[PCMP]], i64 1
-; BE-NEXT:    store i32 [[CMPM1]], i32* [[PSTORM1]], align 4
-; BE-NEXT:    [[CMPX2:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(8) bitcast ([4 x i16]* @ia6a to i8*), i8* noundef nonnull dereferenceable(8) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 1), i64 8)
-; BE-NEXT:    [[PSTORX2:%.*]] = getelementptr i32, i32* [[PCMP]], i64 2
-; BE-NEXT:    store i32 [[CMPX2]], i32* [[PSTORX2]], align 4
-; BE-NEXT:    [[CMPX1:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(8) getelementptr (i8, i8* bitcast ([4 x i16]* @ia6a to i8*), i64 1), i8* noundef nonnull dereferenceable(8) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 0), i64 8)
-; BE-NEXT:    [[PSTORX1:%.*]] = getelementptr i32, i32* [[PCMP]], i64 2
-; BE-NEXT:    store i32 [[CMPX1]], i32* [[PSTORX1]], align 4
-; BE-NEXT:    ret void
-;
-; LE-LABEL: @call_memcmp_too_big(
-; LE-NEXT:    [[CMP9:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(9) bitcast ([4 x i16]* @ia6a to i8*), i8* noundef nonnull dereferenceable(9) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 0), i64 9)
-; LE-NEXT:    store i32 [[CMP9]], i32* [[PCMP:%.*]], align 4
-; LE-NEXT:    [[CMPM1:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(18446744073709551615) bitcast ([4 x i16]* @ia6a to i8*), i8* noundef nonnull dereferenceable(18446744073709551615) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 0), i64 -1)
-; LE-NEXT:    [[PSTORM1:%.*]] = getelementptr i32, i32* [[PCMP]], i64 1
-; LE-NEXT:    store i32 [[CMPM1]], i32* [[PSTORM1]], align 4
-; LE-NEXT:    [[CMPX2:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(8) bitcast ([4 x i16]* @ia6a to i8*), i8* noundef nonnull dereferenceable(8) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 1), i64 8)
-; LE-NEXT:    [[PSTORX2:%.*]] = getelementptr i32, i32* [[PCMP]], i64 2
-; LE-NEXT:    store i32 [[CMPX2]], i32* [[PSTORX2]], align 4
-; LE-NEXT:    [[CMPX1:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(8) getelementptr (i8, i8* bitcast ([4 x i16]* @ia6a to i8*), i64 1), i8* noundef nonnull dereferenceable(8) getelementptr inbounds ([8 x i8], [8 x i8]* @i8a, i64 0, i64 0), i64 8)
-; LE-NEXT:    [[PSTORX1:%.*]] = getelementptr i32, i32* [[PCMP]], i64 2
-; LE-NEXT:    store i32 [[CMPX1]], i32* [[PSTORX1]], align 4
-; LE-NEXT:    ret void
-;
-  %p0 = getelementptr [4 x i16], [4 x i16]* @ia6a, i64 0, i64 0
-  %p1 = bitcast i16* %p0 to i8*
-  %q = getelementptr [8 x i8], [8 x i8]* @i8a, i64 0, i64 0
-
-  %cmp9 = call i32 @memcmp(i8* %p1, i8* %q, i64 9)
-  %pstor9 = getelementptr i32, i32* %pcmp, i64 0
-  store i32 %cmp9, i32* %pstor9
-
-  %cmpm1 = call i32 @memcmp(i8* %p1, i8* %q, i64 -1)
-  %pstorm1 = getelementptr i32, i32* %pcmp, i64 1
-  store i32 %cmpm1, i32* %pstorm1
-
-  ; Exercise size that's greater than just one of the arrays.
-  %q2 = getelementptr [8 x i8], [8 x i8]* @i8a, i64 0, i64 1
-  %cmpx2 = call i32 @memcmp(i8* %p1, i8* %q2, i64 8)
-  %pstorx2 = getelementptr i32, i32* %pcmp, i64 2
-  store i32 %cmpx2, i32* %pstorx2
-
-  %p2 = getelementptr i8, i8* %p1, i64 1
-  %cmpx1 = call i32 @memcmp(i8* %p2, i8* %q, i64 8)
-  %pstorx1 = getelementptr i32, i32* %pcmp, i64 2
-  store i32 %cmpx1, i32* %pstorx1
-
-  ret void
-}

llvm/test/Transforms/InstCombine/memcmp-4.ll

 
 ; Fold calls with a count in excess of the size of one of the arrays that
 ; differ.  They're strictly undefined but folding the result to the expected
 ; value (analogous to strncmp) is safer than letting a SIMD library
 ; implementation return a bogus value.
 
 define void @fold_memcmp_too_big(i32* %pcmp) {
 ; BE-LABEL: @fold_memcmp_too_big(
-; BE-NEXT:    [[CMP_BC:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(12) bitcast ([5 x i16]* @ia16b to i8*), i8* noundef nonnull dereferenceable(12) bitcast ([6 x i16]* @ia16c to i8*), i64 12)
-; BE-NEXT:    store i32 [[CMP_BC]], i32* [[PCMP:%.*]], align 4
-; BE-NEXT:    [[CMP_CB:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(12) bitcast ([6 x i16]* @ia16c to i8*), i8* noundef nonnull dereferenceable(12) bitcast ([5 x i16]* @ia16b to i8*), i64 12)
+; BE-NEXT:    store i32 -1, i32* [[PCMP:%.*]], align 4
 ; BE-NEXT:    [[PSTOR_CB:%.*]] = getelementptr i32, i32* [[PCMP]], i64 1
-; BE-NEXT:    store i32 [[CMP_CB]], i32* [[PSTOR_CB]], align 4
+; BE-NEXT:    store i32 1, i32* [[PSTOR_CB]], align 4
 ; BE-NEXT:    ret void
 ;
 ; LE-LABEL: @fold_memcmp_too_big(
-; LE-NEXT:    [[CMP_BC:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(12) bitcast ([5 x i16]* @ia16b to i8*), i8* noundef nonnull dereferenceable(12) bitcast ([6 x i16]* @ia16c to i8*), i64 12)
-; LE-NEXT:    store i32 [[CMP_BC]], i32* [[PCMP:%.*]], align 4
-; LE-NEXT:    [[CMP_CB:%.*]] = call i32 @memcmp(i8* noundef nonnull dereferenceable(12) bitcast ([6 x i16]* @ia16c to i8*), i8* noundef nonnull dereferenceable(12) bitcast ([5 x i16]* @ia16b to i8*), i64 12)
+; LE-NEXT:    store i32 -1, i32* [[PCMP:%.*]], align 4
 ; LE-NEXT:    [[PSTOR_CB:%.*]] = getelementptr i32, i32* [[PCMP]], i64 1
-; LE-NEXT:    store i32 [[CMP_CB]], i32* [[PSTOR_CB]], align 4
+; LE-NEXT:    store i32 1, i32* [[PSTOR_CB]], align 4
 ; LE-NEXT:    ret void
 ;
   %p0 = getelementptr [5 x i16], [5 x i16]* @ia16b, i64 0, i64 0
   %p1 = bitcast i16* %p0 to i8*
   %q0 = getelementptr [6 x i16], [6 x i16]* @ia16c, i64 0, i64 0
   %q1 = bitcast i16* %q0 to i8*
 
   %cmp_bc = call i32 @memcmp(i8* %p1, i8* %q1, i64 12)

llvm/test/Transforms/InstCombine/memcmp-constant-fold.ll

 ; BE-NEXT:    [[DOTNOT:%.*]] = icmp eq i32 [[RHSV]], 65538
 ; BE-NEXT:    ret i1 [[DOTNOT]]
 ;
   %call = tail call i32 @memcmp(i8* bitcast (i16* getelementptr inbounds ([4 x i16], [4 x i16]* @intbuf_unaligned, i64 0, i64 0) to i8*), i8* %x, i64 4)
   %cmpeq0 = icmp eq i32 %call, 0
   ret i1 %cmpeq0
 }
 
-; TODO: Any memcmp where all arguments are constants should be constant folded. Currently, we only handle i8 array constants.
+; Verif that a memcmp call where all arguments are constants is constant
+; folded even for arrays of other types than i8.
 
 @intbuf = private unnamed_addr constant [2 x i32] [i32 0, i32 1], align 4
 
 define i1 @memcmp_3bytes_aligned_constant_i32(i8* align 4 %x) {
-; ALL-LABEL: @memcmp_3bytes_aligned_constant_i32(
-; ALL-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(i8* noundef nonnull dereferenceable(3) bitcast (i32* getelementptr inbounds ([2 x i32], [2 x i32]* @intbuf, i64 0, i64 1) to i8*), i8* noundef nonnull dereferenceable(3) bitcast ([2 x i32]* @intbuf to i8*), i64 3)
-; ALL-NEXT:    [[CMPEQ0:%.*]] = icmp eq i32 [[CALL]], 0
-; ALL-NEXT:    ret i1 [[CMPEQ0]]
+; LE-LABEL: @memcmp_3bytes_aligned_constant_i32(
+; LE-NEXT:    ret i1 false
+;
+; BE-LABEL: @memcmp_3bytes_aligned_constant_i32(
+; BE-NEXT:    ret i1 true
 ;
   %call = tail call i32 @memcmp(i8* bitcast (i32* getelementptr inbounds ([2 x i32], [2 x i32]* @intbuf, i64 0, i64 1) to i8*), i8* bitcast (i32* getelementptr inbounds ([2 x i32], [2 x i32]* @intbuf, i64 0, i64 0) to i8*), i64 3)
   %cmpeq0 = icmp eq i32 %call, 0
   ret i1 %cmpeq0
 }
 
 ; A sloppy implementation would infinite loop by recreating the unused instructions.
 

llvm/test/Transforms/InstCombine/memrchr-5.ll

 ; LE representation: { 'd', 'c', 'b', 'a', 'h', ..., 'm', 'd', 'c', 'b', 'a' }
 @a = constant [5 x i32] [i32 1633837924, i32 1701209960, i32 1768581996, i32 1835954032, i32 1633837924]
 
 
 ; Fold memrchr(a, C, 16) for C in ['a', 'd'] U ['o', 'q'].
 
 define void @fold_memrchr_a_16(i64* %pcmp) {
 ; BE-LABEL: @fold_memrchr_a_16(
-; BE-NEXT:    [[PA:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(16) bitcast ([5 x i32]* @a to i8*), i32 97, i64 16)
-; BE-NEXT:    [[IPA:%.*]] = ptrtoint i8* [[PA]] to i64
-; BE-NEXT:    [[OFFA:%.*]] = sub i64 [[IPA]], ptrtoint ([5 x i32]* @a to i64)
-; BE-NEXT:    store i64 [[OFFA]], i64* [[PCMP:%.*]], align 4
-; BE-NEXT:    [[PB:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(16) bitcast ([5 x i32]* @a to i8*), i32 98, i64 16)
-; BE-NEXT:    [[IPB:%.*]] = ptrtoint i8* [[PB]] to i64
-; BE-NEXT:    [[OFFB:%.*]] = sub i64 [[IPB]], ptrtoint ([5 x i32]* @a to i64)
+; BE-NEXT:    store i64 0, i64* [[PCMP:%.*]], align 4
 ; BE-NEXT:    [[PSTOR1:%.*]] = getelementptr i64, i64* [[PCMP]], i64 1
-; BE-NEXT:    store i64 [[OFFB]], i64* [[PSTOR1]], align 4
-; BE-NEXT:    [[PC:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(16) bitcast ([5 x i32]* @a to i8*), i32 99, i64 16)
-; BE-NEXT:    [[IPC:%.*]] = ptrtoint i8* [[PC]] to i64
-; BE-NEXT:    [[OFFC:%.*]] = sub i64 [[IPC]], ptrtoint ([5 x i32]* @a to i64)
+; BE-NEXT:    store i64 1, i64* [[PSTOR1]], align 4
 ; BE-NEXT:    [[PSTOR2:%.*]] = getelementptr i64, i64* [[PCMP]], i64 2
-; BE-NEXT:    store i64 [[OFFC]], i64* [[PSTOR2]], align 4
-; BE-NEXT:    [[PD:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(16) bitcast ([5 x i32]* @a to i8*), i32 100, i64 16)
-; BE-NEXT:    [[IPD:%.*]] = ptrtoint i8* [[PD]] to i64
-; BE-NEXT:    [[OFFD:%.*]] = sub i64 [[IPD]], ptrtoint ([5 x i32]* @a to i64)
+; BE-NEXT:    store i64 2, i64* [[PSTOR2]], align 4
 ; BE-NEXT:    [[PSTOR3:%.*]] = getelementptr i64, i64* [[PCMP]], i64 3
-; BE-NEXT:    store i64 [[OFFD]], i64* [[PSTOR3]], align 4
-; BE-NEXT:    [[PN:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(16) bitcast ([5 x i32]* @a to i8*), i32 110, i64 16)
-; BE-NEXT:    [[IPN:%.*]] = ptrtoint i8* [[PN]] to i64
-; BE-NEXT:    [[OFFN:%.*]] = sub i64 [[IPN]], ptrtoint ([5 x i32]* @a to i64)
+; BE-NEXT:    store i64 3, i64* [[PSTOR3]], align 4
 ; BE-NEXT:    [[PSTOR4:%.*]] = getelementptr i64, i64* [[PCMP]], i64 4
-; BE-NEXT:    store i64 [[OFFN]], i64* [[PSTOR4]], align 4
-; BE-NEXT:    [[PO:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(16) bitcast ([5 x i32]* @a to i8*), i32 111, i64 16)
-; BE-NEXT:    [[IPO:%.*]] = ptrtoint i8* [[PO]] to i64
-; BE-NEXT:    [[OFFO:%.*]] = sub i64 [[IPO]], ptrtoint ([5 x i32]* @a to i64)
+; BE-NEXT:    store i64 13, i64* [[PSTOR4]], align 4
 ; BE-NEXT:    [[PSTOR6:%.*]] = getelementptr i64, i64* [[PCMP]], i64 6
-; BE-NEXT:    store i64 [[OFFO]], i64* [[PSTOR6]], align 4
-; BE-NEXT:    [[PP:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(16) bitcast ([5 x i32]* @a to i8*), i32 112, i64 16)
-; BE-NEXT:    [[IPP:%.*]] = ptrtoint i8* [[PP]] to i64
-; BE-NEXT:    [[OFFP:%.*]] = sub i64 [[IPP]], ptrtoint ([5 x i32]* @a to i64)
+; BE-NEXT:    store i64 14, i64* [[PSTOR6]], align 4
 ; BE-NEXT:    [[PSTOR7:%.*]] = getelementptr i64, i64* [[PCMP]], i64 7
-; BE-NEXT:    store i64 [[OFFP]], i64* [[PSTOR7]], align 4
-; BE-NEXT:    [[PQ:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(16) bitcast ([5 x i32]* @a to i8*), i32 113, i64 16)
-; BE-NEXT:    [[IPQ:%.*]] = ptrtoint i8* [[PQ]] to i64
+; BE-NEXT:    store i64 15, i64* [[PSTOR7]], align 4
 ; BE-NEXT:    [[PSTOR8:%.*]] = getelementptr i64, i64* [[PCMP]], i64 8
-; BE-NEXT:    store i64 [[IPQ]], i64* [[PSTOR8]], align 4
+; BE-NEXT:    store i64 0, i64* [[PSTOR8]], align 4
 ; BE-NEXT:    ret void
 ;
 ; LE-LABEL: @fold_memrchr_a_16(
-; LE-NEXT:    [[PA:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(16) bitcast ([5 x i32]* @a to i8*), i32 97, i64 16)
-; LE-NEXT:    [[IPA:%.*]] = ptrtoint i8* [[PA]] to i64
-; LE-NEXT:    [[OFFA:%.*]] = sub i64 [[IPA]], ptrtoint ([5 x i32]* @a to i64)
-; LE-NEXT:    store i64 [[OFFA]], i64* [[PCMP:%.*]], align 4
-; LE-NEXT:    [[PB:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(16) bitcast ([5 x i32]* @a to i8*), i32 98, i64 16)
-; LE-NEXT:    [[IPB:%.*]] = ptrtoint i8* [[PB]] to i64
-; LE-NEXT:    [[OFFB:%.*]] = sub i64 [[IPB]], ptrtoint ([5 x i32]* @a to i64)
+; LE-NEXT:    store i64 3, i64* [[PCMP:%.*]], align 4
 ; LE-NEXT:    [[PSTOR1:%.*]] = getelementptr i64, i64* [[PCMP]], i64 1
-; LE-NEXT:    store i64 [[OFFB]], i64* [[PSTOR1]], align 4
-; LE-NEXT:    [[PC:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(16) bitcast ([5 x i32]* @a to i8*), i32 99, i64 16)
-; LE-NEXT:    [[IPC:%.*]] = ptrtoint i8* [[PC]] to i64
-; LE-NEXT:    [[OFFC:%.*]] = sub i64 [[IPC]], ptrtoint ([5 x i32]* @a to i64)
+; LE-NEXT:    store i64 2, i64* [[PSTOR1]], align 4
 ; LE-NEXT:    [[PSTOR2:%.*]] = getelementptr i64, i64* [[PCMP]], i64 2
-; LE-NEXT:    store i64 [[OFFC]], i64* [[PSTOR2]], align 4
-; LE-NEXT:    [[PD:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(16) bitcast ([5 x i32]* @a to i8*), i32 100, i64 16)
-; LE-NEXT:    [[IPD:%.*]] = ptrtoint i8* [[PD]] to i64
-; LE-NEXT:    [[OFFD:%.*]] = sub i64 [[IPD]], ptrtoint ([5 x i32]* @a to i64)
+; LE-NEXT:    store i64 1, i64* [[PSTOR2]], align 4
 ; LE-NEXT:    [[PSTOR3:%.*]] = getelementptr i64, i64* [[PCMP]], i64 3
-; LE-NEXT:    store i64 [[OFFD]], i64* [[PSTOR3]], align 4
-; LE-NEXT:    [[PN:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(16) bitcast ([5 x i32]* @a to i8*), i32 110, i64 16)
-; LE-NEXT:    [[IPN:%.*]] = ptrtoint i8* [[PN]] to i64
-; LE-NEXT:    [[OFFN:%.*]] = sub i64 [[IPN]], ptrtoint ([5 x i32]* @a to i64)
+; LE-NEXT:    store i64 0, i64* [[PSTOR3]], align 4
 ; LE-NEXT:    [[PSTOR4:%.*]] = getelementptr i64, i64* [[PCMP]], i64 4
-; LE-NEXT:    store i64 [[OFFN]], i64* [[PSTOR4]], align 4
-; LE-NEXT:    [[PO:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(16) bitcast ([5 x i32]* @a to i8*), i32 111, i64 16)
-; LE-NEXT:    [[IPO:%.*]] = ptrtoint i8* [[PO]] to i64
-; LE-NEXT:    [[OFFO:%.*]] = sub i64 [[IPO]], ptrtoint ([5 x i32]* @a to i64)
+; LE-NEXT:    store i64 14, i64* [[PSTOR4]], align 4
 ; LE-NEXT:    [[PSTOR6:%.*]] = getelementptr i64, i64* [[PCMP]], i64 6
-; LE-NEXT:    store i64 [[OFFO]], i64* [[PSTOR6]], align 4
-; LE-NEXT:    [[PP:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(16) bitcast ([5 x i32]* @a to i8*), i32 112, i64 16)
-; LE-NEXT:    [[IPP:%.*]] = ptrtoint i8* [[PP]] to i64
-; LE-NEXT:    [[OFFP:%.*]] = sub i64 [[IPP]], ptrtoint ([5 x i32]* @a to i64)
+; LE-NEXT:    store i64 13, i64* [[PSTOR6]], align 4
 ; LE-NEXT:    [[PSTOR7:%.*]] = getelementptr i64, i64* [[PCMP]], i64 7
-; LE-NEXT:    store i64 [[OFFP]], i64* [[PSTOR7]], align 4
-; LE-NEXT:    [[PQ:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(16) bitcast ([5 x i32]* @a to i8*), i32 113, i64 16)
-; LE-NEXT:    [[IPQ:%.*]] = ptrtoint i8* [[PQ]] to i64
+; LE-NEXT:    store i64 12, i64* [[PSTOR7]], align 4
 ; LE-NEXT:    [[PSTOR8:%.*]] = getelementptr i64, i64* [[PCMP]], i64 8
-; LE-NEXT:    store i64 [[IPQ]], i64* [[PSTOR8]], align 4
+; LE-NEXT:    store i64 0, i64* [[PSTOR8]], align 4
 ; LE-NEXT:    ret void
 ;
   %p0 = getelementptr [5 x i32], [5 x i32]* @a, i64 0, i64 0
   %p1 = bitcast i32* %p0 to i8*
   %ip0 = ptrtoint [5 x i32]* @a to i64
 
 ; Fold memrchr(a, 'a', 16) - a to 0 (3 in LE).
 
; Fold memrchr(a, 'q', 16) to null in both BE and LE.
   ret void
 }
 
 
 ; Fold memrchr(a + 1, C, 12) for C in ['e', 'h'] U ['a', 'd'].
 
 define void @fold_memrchr_a_p1_16(i64* %pcmp) {
 ; BE-LABEL: @fold_memrchr_a_p1_16(
-; BE-NEXT:    [[PE:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(12) bitcast (i32* getelementptr inbounds ([5 x i32], [5 x i32]* @a, i64 0, i64 1) to i8*), i32 101, i64 12)
-; BE-NEXT:    [[IPE:%.*]] = ptrtoint i8* [[PE]] to i64
-; BE-NEXT:    [[OFFE:%.*]] = sub i64 [[IPE]], ptrtoint (i32* getelementptr inbounds ([5 x i32], [5 x i32]* @a, i64 0, i64 1) to i64)
-; BE-NEXT:    store i64 [[OFFE]], i64* [[PCMP:%.*]], align 4
-; BE-NEXT:    [[PF:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(12) bitcast (i32* getelementptr inbounds ([5 x i32], [5 x i32]* @a, i64 0, i64 1) to i8*), i32 102, i64 12)
-; BE-NEXT:    [[IPF:%.*]] = ptrtoint i8* [[PF]] to i64
-; BE-NEXT:    [[OFFF:%.*]] = sub i64 [[IPF]], ptrtoint (i32* getelementptr inbounds ([5 x i32], [5 x i32]* @a, i64 0, i64 1) to i64)
+; BE-NEXT:    store i64 0, i64* [[PCMP:%.*]], align 4
 ; BE-NEXT:    [[PSTOR1:%.*]] = getelementptr i64, i64* [[PCMP]], i64 1
-; BE-NEXT:    store i64 [[OFFF]], i64* [[PSTOR1]], align 4
-; BE-NEXT:    [[PG:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(12) bitcast (i32* getelementptr inbounds ([5 x i32], [5 x i32]* @a, i64 0, i64 1) to i8*), i32 103, i64 12)
-; BE-NEXT:    [[IPG:%.*]] = ptrtoint i8* [[PG]] to i64
-; BE-NEXT:    [[OFFG:%.*]] = sub i64 [[IPG]], ptrtoint (i32* getelementptr inbounds ([5 x i32], [5 x i32]* @a, i64 0, i64 1) to i64)
+; BE-NEXT:    store i64 1, i64* [[PSTOR1]], align 4
 ; BE-NEXT:    [[PSTOR2:%.*]] = getelementptr i64, i64* [[PCMP]], i64 2
-; BE-NEXT:    store i64 [[OFFG]], i64* [[PSTOR2]], align 4
-; BE-NEXT:    [[PH:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(12) bitcast (i32* getelementptr inbounds ([5 x i32], [5 x i32]* @a, i64 0, i64 1) to i8*), i32 104, i64 12)
-; BE-NEXT:    [[IPH:%.*]] = ptrtoint i8* [[PH]] to i64
-; BE-NEXT:    [[OFFH:%.*]] = sub i64 [[IPH]], ptrtoint (i32* getelementptr inbounds ([5 x i32], [5 x i32]* @a, i64 0, i64 1) to i64)
+; BE-NEXT:    store i64 2, i64* [[PSTOR2]], align 4
 ; BE-NEXT:    [[PSTOR3:%.*]] = getelementptr i64, i64* [[PCMP]], i64 3
-; BE-NEXT:    store i64 [[OFFH]], i64* [[PSTOR3]], align 4
-; BE-NEXT:    [[PA:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(12) bitcast (i32* getelementptr inbounds ([5 x i32], [5 x i32]* @a, i64 0, i64 1) to i8*), i32 97, i64 12)
-; BE-NEXT:    [[IPA:%.*]] = ptrtoint i8* [[PA]] to i64
+; BE-NEXT:    store i64 3, i64* [[PSTOR3]], align 4
 ; BE-NEXT:    [[PSTOR4:%.*]] = getelementptr i64, i64* [[PCMP]], i64 4
-; BE-NEXT:    store i64 [[IPA]], i64* [[PSTOR4]], align 4
-; BE-NEXT:    [[PD:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(12) bitcast (i32* getelementptr inbounds ([5 x i32], [5 x i32]* @a, i64 0, i64 1) to i8*), i32 100, i64 12)
-; BE-NEXT:    [[IPD:%.*]] = ptrtoint i8* [[PD]] to i64
+; BE-NEXT:    store i64 0, i64* [[PSTOR4]], align 4
 ; BE-NEXT:    [[PSTOR5:%.*]] = getelementptr i64, i64* [[PCMP]], i64 5
-; BE-NEXT:    store i64 [[IPD]], i64* [[PSTOR5]], align 4
+; BE-NEXT:    store i64 0, i64* [[PSTOR5]], align 4
 ; BE-NEXT:    ret void
 ;
 ; LE-LABEL: @fold_memrchr_a_p1_16(
-; LE-NEXT:    [[PE:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(12) bitcast (i32* getelementptr inbounds ([5 x i32], [5 x i32]* @a, i64 0, i64 1) to i8*), i32 101, i64 12)
-; LE-NEXT:    [[IPE:%.*]] = ptrtoint i8* [[PE]] to i64
-; LE-NEXT:    [[OFFE:%.*]] = sub i64 [[IPE]], ptrtoint (i32* getelementptr inbounds ([5 x i32], [5 x i32]* @a, i64 0, i64 1) to i64)
-; LE-NEXT:    store i64 [[OFFE]], i64* [[PCMP:%.*]], align 4
-; LE-NEXT:    [[PF:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(12) bitcast (i32* getelementptr inbounds ([5 x i32], [5 x i32]* @a, i64 0, i64 1) to i8*), i32 102, i64 12)
-; LE-NEXT:    [[IPF:%.*]] = ptrtoint i8* [[PF]] to i64
-; LE-NEXT:    [[OFFF:%.*]] = sub i64 [[IPF]], ptrtoint (i32* getelementptr inbounds ([5 x i32], [5 x i32]* @a, i64 0, i64 1) to i64)
+; LE-NEXT:    store i64 3, i64* [[PCMP:%.*]], align 4
 ; LE-NEXT:    [[PSTOR1:%.*]] = getelementptr i64, i64* [[PCMP]], i64 1
-; LE-NEXT:    store i64 [[OFFF]], i64* [[PSTOR1]], align 4
-; LE-NEXT:    [[PG:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(12) bitcast (i32* getelementptr inbounds ([5 x i32], [5 x i32]* @a, i64 0, i64 1) to i8*), i32 103, i64 12)
-; LE-NEXT:    [[IPG:%.*]] = ptrtoint i8* [[PG]] to i64
-; LE-NEXT:    [[OFFG:%.*]] = sub i64 [[IPG]], ptrtoint (i32* getelementptr inbounds ([5 x i32], [5 x i32]* @a, i64 0, i64 1) to i64)
+; LE-NEXT:    store i64 2, i64* [[PSTOR1]], align 4
 ; LE-NEXT:    [[PSTOR2:%.*]] = getelementptr i64, i64* [[PCMP]], i64 2
-; LE-NEXT:    store i64 [[OFFG]], i64* [[PSTOR2]], align 4
-; LE-NEXT:    [[PH:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(12) bitcast (i32* getelementptr inbounds ([5 x i32], [5 x i32]* @a, i64 0, i64 1) to i8*), i32 104, i64 12)
-; LE-NEXT:    [[IPH:%.*]] = ptrtoint i8* [[PH]] to i64
-; LE-NEXT:    [[OFFH:%.*]] = sub i64 [[IPH]], ptrtoint (i32* getelementptr inbounds ([5 x i32], [5 x i32]* @a, i64 0, i64 1) to i64)
+; LE-NEXT:    store i64 1, i64* [[PSTOR2]], align 4
 ; LE-NEXT:    [[PSTOR3:%.*]] = getelementptr i64, i64* [[PCMP]], i64 3
-; LE-NEXT:    store i64 [[OFFH]], i64* [[PSTOR3]], align 4
-; LE-NEXT:    [[PA:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(12) bitcast (i32* getelementptr inbounds ([5 x i32], [5 x i32]* @a, i64 0, i64 1) to i8*), i32 97, i64 12)
-; LE-NEXT:    [[IPA:%.*]] = ptrtoint i8* [[PA]] to i64
+; LE-NEXT:    store i64 0, i64* [[PSTOR3]], align 4
 ; LE-NEXT:    [[PSTOR4:%.*]] = getelementptr i64, i64* [[PCMP]], i64 4
-; LE-NEXT:    store i64 [[IPA]], i64* [[PSTOR4]], align 4
-; LE-NEXT:    [[PD:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(12) bitcast (i32* getelementptr inbounds ([5 x i32], [5 x i32]* @a, i64 0, i64 1) to i8*), i32 100, i64 12)
-; LE-NEXT:    [[IPD:%.*]] = ptrtoint i8* [[PD]] to i64
+; LE-NEXT:    store i64 0, i64* [[PSTOR4]], align 4
 ; LE-NEXT:    [[PSTOR5:%.*]] = getelementptr i64, i64* [[PCMP]], i64 5
-; LE-NEXT:    store i64 [[IPD]], i64* [[PSTOR5]], align 4
+; LE-NEXT:    store i64 0, i64* [[PSTOR5]], align 4
 ; LE-NEXT:    ret void
 ;
   %p0 = getelementptr [5 x i32], [5 x i32]* @a, i64 0, i64 1
   %p1 = bitcast i32* %p0 to i8*
   %ip0 = ptrtoint i8* %p1 to i64
 
 ; Fold memrchr(a + 1, 'e', 12) - a to 0 (3 in LE).
 
; Fold memrchr(a + 1, 'd', 12) to null in both BE and LE.
   ret void
 }
 
 
 ; Fold memrchr(a, C, 20) for C in ['a', 'e'].
 
 define void @fold_memrchr_a_20(i64* %pcmp) {
 ; BE-LABEL: @fold_memrchr_a_20(
-; BE-NEXT:    [[PA:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(20) bitcast ([5 x i32]* @a to i8*), i32 97, i64 20)
-; BE-NEXT:    [[IPA:%.*]] = ptrtoint i8* [[PA]] to i64
-; BE-NEXT:    [[OFFA:%.*]] = sub i64 [[IPA]], ptrtoint ([5 x i32]* @a to i64)
-; BE-NEXT:    store i64 [[OFFA]], i64* [[PCMP:%.*]], align 4
-; BE-NEXT:    [[PB:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(20) bitcast ([5 x i32]* @a to i8*), i32 98, i64 20)
-; BE-NEXT:    [[IPB:%.*]] = ptrtoint i8* [[PB]] to i64
-; BE-NEXT:    [[OFFB:%.*]] = sub i64 [[IPB]], ptrtoint ([5 x i32]* @a to i64)
+; BE-NEXT:    store i64 16, i64* [[PCMP:%.*]], align 4
 ; BE-NEXT:    [[PSTOR1:%.*]] = getelementptr i64, i64* [[PCMP]], i64 1
-; BE-NEXT:    store i64 [[OFFB]], i64* [[PSTOR1]], align 4
-; BE-NEXT:    [[PC:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(20) bitcast ([5 x i32]* @a to i8*), i32 99, i64 20)
-; BE-NEXT:    [[IPC:%.*]] = ptrtoint i8* [[PC]] to i64
-; BE-NEXT:    [[OFFC:%.*]] = sub i64 [[IPC]], ptrtoint ([5 x i32]* @a to i64)
+; BE-NEXT:    store i64 17, i64* [[PSTOR1]], align 4
 ; BE-NEXT:    [[PSTOR2:%.*]] = getelementptr i64, i64* [[PCMP]], i64 2
-; BE-NEXT:    store i64 [[OFFC]], i64* [[PSTOR2]], align 4
-; BE-NEXT:    [[PD:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(20) bitcast ([5 x i32]* @a to i8*), i32 100, i64 20)
-; BE-NEXT:    [[IPD:%.*]] = ptrtoint i8* [[PD]] to i64
-; BE-NEXT:    [[OFFD:%.*]] = sub i64 [[IPD]], ptrtoint ([5 x i32]* @a to i64)
+; BE-NEXT:    store i64 18, i64* [[PSTOR2]], align 4
 ; BE-NEXT:    [[PSTOR3:%.*]] = getelementptr i64, i64* [[PCMP]], i64 3
-; BE-NEXT:    store i64 [[OFFD]], i64* [[PSTOR3]], align 4
-; BE-NEXT:    [[PE:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(20) bitcast ([5 x i32]* @a to i8*), i32 101, i64 20)
-; BE-NEXT:    [[IPE:%.*]] = ptrtoint i8* [[PE]] to i64
-; BE-NEXT:    [[OFFE:%.*]] = sub i64 [[IPE]], ptrtoint ([5 x i32]* @a to i64)
+; BE-NEXT:    store i64 19, i64* [[PSTOR3]], align 4
 ; BE-NEXT:    [[PSTOR4:%.*]] = getelementptr i64, i64* [[PCMP]], i64 4
-; BE-NEXT:    store i64 [[OFFE]], i64* [[PSTOR4]], align 4
+; BE-NEXT:    store i64 4, i64* [[PSTOR4]], align 4
 ; BE-NEXT:    ret void
 ;
 ; LE-LABEL: @fold_memrchr_a_20(
-; LE-NEXT:    [[PA:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(20) bitcast ([5 x i32]* @a to i8*), i32 97, i64 20)
-; LE-NEXT:    [[IPA:%.*]] = ptrtoint i8* [[PA]] to i64
-; LE-NEXT:    [[OFFA:%.*]] = sub i64 [[IPA]], ptrtoint ([5 x i32]* @a to i64)
-; LE-NEXT:    store i64 [[OFFA]], i64* [[PCMP:%.*]], align 4
-; LE-NEXT:    [[PB:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(20) bitcast ([5 x i32]* @a to i8*), i32 98, i64 20)
-; LE-NEXT:    [[IPB:%.*]] = ptrtoint i8* [[PB]] to i64
-; LE-NEXT:    [[OFFB:%.*]] = sub i64 [[IPB]], ptrtoint ([5 x i32]* @a to i64)
+; LE-NEXT:    store i64 19, i64* [[PCMP:%.*]], align 4
 ; LE-NEXT:    [[PSTOR1:%.*]] = getelementptr i64, i64* [[PCMP]], i64 1
-; LE-NEXT:    store i64 [[OFFB]], i64* [[PSTOR1]], align 4
-; LE-NEXT:    [[PC:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(20) bitcast ([5 x i32]* @a to i8*), i32 99, i64 20)
-; LE-NEXT:    [[IPC:%.*]] = ptrtoint i8* [[PC]] to i64
-; LE-NEXT:    [[OFFC:%.*]] = sub i64 [[IPC]], ptrtoint ([5 x i32]* @a to i64)
+; LE-NEXT:    store i64 18, i64* [[PSTOR1]], align 4
 ; LE-NEXT:    [[PSTOR2:%.*]] = getelementptr i64, i64* [[PCMP]], i64 2
-; LE-NEXT:    store i64 [[OFFC]], i64* [[PSTOR2]], align 4
-; LE-NEXT:    [[PD:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(20) bitcast ([5 x i32]* @a to i8*), i32 100, i64 20)
-; LE-NEXT:    [[IPD:%.*]] = ptrtoint i8* [[PD]] to i64
-; LE-NEXT:    [[OFFD:%.*]] = sub i64 [[IPD]], ptrtoint ([5 x i32]* @a to i64)
+; LE-NEXT:    store i64 17, i64* [[PSTOR2]], align 4
 ; LE-NEXT:    [[PSTOR3:%.*]] = getelementptr i64, i64* [[PCMP]], i64 3
-; LE-NEXT:    store i64 [[OFFD]], i64* [[PSTOR3]], align 4
-; LE-NEXT:    [[PE:%.*]] = call i8* @memrchr(i8* noundef nonnull dereferenceable(20) bitcast ([5 x i32]* @a to i8*), i32 101, i64 20)
-; LE-NEXT:    [[IPE:%.*]] = ptrtoint i8* [[PE]] to i64
-; LE-NEXT:    [[OFFE:%.*]] = sub i64 [[IPE]], ptrtoint ([5 x i32]* @a to i64)
+; LE-NEXT:    store i64 16, i64* [[PSTOR3]], align 4
 ; LE-NEXT:    [[PSTOR4:%.*]] = getelementptr i64, i64* [[PCMP]], i64 4
-; LE-NEXT:    store i64 [[OFFE]], i64* [[PSTOR4]], align 4
+; LE-NEXT:    store i64 7, i64* [[PSTOR4]], align 4
 ; LE-NEXT:    ret void
 ;
   %p0 = getelementptr [5 x i32], [5 x i32]* @a, i64 0, i64 0
   %p1 = bitcast i32* %p0 to i8*
   %ip0 = ptrtoint i8* %p1 to i64
 
 ; Fold memrchr(a, 'a', 20) - a to 16 (19 in LE).
 

llvm/test/Transforms/InstCombine/sprintf-2.ll

 @pcnt_s = constant [3 x i8] c"%s\00"
 
 
 ; Fold snprintf(0, 0, "%s", a[I].M + C) for constant I in [0, 1],
 ; member M in [a, b, c], and C in a valid range to a constant.
 
 define void @fold_snprintf_member_pC(i32* %pi) {
 ; CHECK-LABEL: @fold_snprintf_member_pC(
-; CHECK-NEXT:    [[IA0A:%.*]] = call i32 (i8*, i64, i8*, ...) @snprintf(i8* null, i64 0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @pcnt_s, i64 0, i64 0), i8* getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 0, i64 0))
-; CHECK-NEXT:    store i32 [[IA0A]], i32* [[PI:%.*]], align 4
-; CHECK-NEXT:    [[IA0AP1:%.*]] = call i32 (i8*, i64, i8*, ...) @snprintf(i8* null, i64 0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @pcnt_s, i64 0, i64 0), i8* getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 0, i64 1))
+; CHECK-NEXT:    store i32 1, i32* [[PI:%.*]], align 4
 ; CHECK-NEXT:    [[PIA0AP1:%.*]] = getelementptr i32, i32* [[PI]], i64 1
-; CHECK-NEXT:    store i32 [[IA0AP1]], i32* [[PIA0AP1]], align 4
-; CHECK-NEXT:    [[IA0B:%.*]] = call i32 (i8*, i64, i8*, ...) @snprintf(i8* null, i64 0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @pcnt_s, i64 0, i64 0), i8* getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 1, i64 0))
+; CHECK-NEXT:    store i32 0, i32* [[PIA0AP1]], align 4
 ; CHECK-NEXT:    [[PIA0B:%.*]] = getelementptr i32, i32* [[PI]], i64 2
-; CHECK-NEXT:    store i32 [[IA0B]], i32* [[PIA0B]], align 4
-; CHECK-NEXT:    [[IA0BP1:%.*]] = call i32 (i8*, i64, i8*, ...) @snprintf(i8* null, i64 0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @pcnt_s, i64 0, i64 0), i8* getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 1, i64 1))
+; CHECK-NEXT:    store i32 2, i32* [[PIA0B]], align 4
 ; CHECK-NEXT:    [[PIA0BP1:%.*]] = getelementptr i32, i32* [[PI]], i64 3
-; CHECK-NEXT:    store i32 [[IA0BP1]], i32* [[PIA0BP1]], align 4
-; CHECK-NEXT:    [[IA0BP2:%.*]] = call i32 (i8*, i64, i8*, ...) @snprintf(i8* null, i64 0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @pcnt_s, i64 0, i64 0), i8* getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 1, i64 2))
+; CHECK-NEXT:    store i32 1, i32* [[PIA0BP1]], align 4
 ; CHECK-NEXT:    [[PIA0BP2:%.*]] = getelementptr i32, i32* [[PI]], i64 4
-; CHECK-NEXT:    store i32 [[IA0BP2]], i32* [[PIA0BP2]], align 4
-; CHECK-NEXT:    [[IA0C:%.*]] = call i32 (i8*, i64, i8*, ...) @snprintf(i8* null, i64 0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @pcnt_s, i64 0, i64 0), i8* getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 2, i64 0))
+; CHECK-NEXT:    store i32 0, i32* [[PIA0BP2]], align 4
 ; CHECK-NEXT:    [[PIA0C:%.*]] = getelementptr i32, i32* [[PI]], i64 5
-; CHECK-NEXT:    store i32 [[IA0C]], i32* [[PIA0C]], align 4
-; CHECK-NEXT:    [[IA1A:%.*]] = call i32 (i8*, i64, i8*, ...) @snprintf(i8* null, i64 0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @pcnt_s, i64 0, i64 0), i8* getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 0, i64 0))
+; CHECK-NEXT:    store i32 3, i32* [[PIA0C]], align 4
 ; CHECK-NEXT:    [[PIA1A:%.*]] = getelementptr i32, i32* [[PI]], i64 6
-; CHECK-NEXT:    store i32 [[IA1A]], i32* [[PIA1A]], align 4
-; CHECK-NEXT:    [[IA1B:%.*]] = call i32 (i8*, i64, i8*, ...) @snprintf(i8* null, i64 0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @pcnt_s, i64 0, i64 0), i8* getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 1, i64 0))
+; CHECK-NEXT:    store i32 4, i32* [[PIA1A]], align 4
 ; CHECK-NEXT:    [[PIA1B:%.*]] = getelementptr i32, i32* [[PI]], i64 7
-; CHECK-NEXT:    store i32 [[IA1B]], i32* [[PIA1B]], align 4
-; CHECK-NEXT:    [[IA1C:%.*]] = call i32 (i8*, i64, i8*, ...) @snprintf(i8* null, i64 0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @pcnt_s, i64 0, i64 0), i8* getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 2, i64 0))
+; CHECK-NEXT:    store i32 5, i32* [[PIA1B]], align 4
 ; CHECK-NEXT:    [[PIA1C:%.*]] = getelementptr i32, i32* [[PI]], i64 8
-; CHECK-NEXT:    store i32 [[IA1C]], i32* [[PIA1C]], align 4
+; CHECK-NEXT:    store i32 6, i32* [[PIA1C]], align 4
 ; CHECK-NEXT:    ret void
 ;
   %fmt = getelementptr [3 x i8], [3 x i8]* @pcnt_s, i32 0, i32 0
 ; Fold snprintf(0, 0, "%s", a[0].a) to 1.
   %pa0a = getelementptr [2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 0, i64 0
   %ia0a = call i32 (i8*, i64, i8*, ...) @snprintf(i8* null, i64 0, i8* %fmt, i8* %pa0a)
   %pia0a = getelementptr i32, i32* %pi, i32 0
   store i32 %ia0a, i32* %pia0a

llvm/test/Transforms/InstCombine/str-int-3.ll

 @a = constant [2 x %struct.A] [%struct.A { [4 x i8] c"1\00\00\00", [5 x i8] c"12\00\00\00", [7 x i8] c"56789\00\00" }, %struct.A { [4 x i8] c"123\00", [5 x i8] c"1234\00", [7 x i8] c"67890\00\00" }]
 
 
 ; Fold atoi(a[I].M) for constant I in [0, 1] and member M in [a, b]
 ; to a constant.
 
 define void @fold_atoi_member(i32* %pi) {
 ; CHECK-LABEL: @fold_atoi_member(
-; CHECK-NEXT:    [[IA0A:%.*]] = call i32 @atoi(i8* getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 0, i64 0))
-; CHECK-NEXT:    store i32 [[IA0A]], i32* [[PI:%.*]], align 4
-; CHECK-NEXT:    [[IA0B:%.*]] = call i32 @atoi(i8* getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 1, i64 0))
+; CHECK-NEXT:    store i32 1, i32* [[PI:%.*]], align 4
 ; CHECK-NEXT:    [[PIA0B:%.*]] = getelementptr i32, i32* [[PI]], i64 1
-; CHECK-NEXT:    store i32 [[IA0B]], i32* [[PIA0B]], align 4
-; CHECK-NEXT:    [[IA1A:%.*]] = call i32 @atoi(i8* getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 0, i64 0))
+; CHECK-NEXT:    store i32 12, i32* [[PIA0B]], align 4
 ; CHECK-NEXT:    [[PIA1A:%.*]] = getelementptr i32, i32* [[PI]], i64 2
-; CHECK-NEXT:    store i32 [[IA1A]], i32* [[PIA1A]], align 4
-; CHECK-NEXT:    [[IA1B:%.*]] = call i32 @atoi(i8* getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 1, i64 0))
+; CHECK-NEXT:    store i32 123, i32* [[PIA1A]], align 4
 ; CHECK-NEXT:    [[PIA1B:%.*]] = getelementptr i32, i32* [[PI]], i64 3
-; CHECK-NEXT:    store i32 [[IA1B]], i32* [[PIA1B]], align 4
+; CHECK-NEXT:    store i32 1234, i32* [[PIA1B]], align 4
 ; CHECK-NEXT:    ret void
 ;
 ; Fold atoi(a[0].a) to 1.
   %pa0a = getelementptr [2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 0, i64 0
   %ia0a = call i32 @atoi(i8* %pa0a)
   %pia0a = getelementptr i32, i32* %pi, i32 0
   store i32 %ia0a, i32* %pia0a
 

 }
 
 
 ; Fold atol(a[I].M) for constant I in [0, 1] and member M in [a, b, c]
 ; to a constant.
 
 define void @fold_atol_member(i64* %pi) {
 ; CHECK-LABEL: @fold_atol_member(
-; CHECK-NEXT:    [[IA0A:%.*]] = call i64 @atol(i8* getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 0, i64 0))
-; CHECK-NEXT:    store i64 [[IA0A]], i64* [[PI:%.*]], align 4
-; CHECK-NEXT:    [[IA0B:%.*]] = call i64 @atol(i8* getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 1, i64 0))
+; CHECK-NEXT:    store i64 1, i64* [[PI:%.*]], align 4
 ; CHECK-NEXT:    [[PIA0B:%.*]] = getelementptr i64, i64* [[PI]], i64 1
-; CHECK-NEXT:    store i64 [[IA0B]], i64* [[PIA0B]], align 4
-; CHECK-NEXT:    [[IA0C:%.*]] = call i64 @atol(i8* getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 2, i64 0))
+; CHECK-NEXT:    store i64 12, i64* [[PIA0B]], align 4
 ; CHECK-NEXT:    [[PIA0C:%.*]] = getelementptr i64, i64* [[PI]], i64 2
-; CHECK-NEXT:    store i64 [[IA0C]], i64* [[PIA0C]], align 4
-; CHECK-NEXT:    [[IA1A:%.*]] = call i64 @atol(i8* getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 0, i64 0))
+; CHECK-NEXT:    store i64 56789, i64* [[PIA0C]], align 4
 ; CHECK-NEXT:    [[PIA1A:%.*]] = getelementptr i64, i64* [[PI]], i64 3
-; CHECK-NEXT:    store i64 [[IA1A]], i64* [[PIA1A]], align 4
-; CHECK-NEXT:    [[IA1B:%.*]] = call i64 @atol(i8* getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 1, i64 0))
+; CHECK-NEXT:    store i64 123, i64* [[PIA1A]], align 4
 ; CHECK-NEXT:    [[PIA1B:%.*]] = getelementptr i64, i64* [[PI]], i64 4
-; CHECK-NEXT:    store i64 [[IA1B]], i64* [[PIA1B]], align 4
-; CHECK-NEXT:    [[IA1C:%.*]] = call i64 @atol(i8* getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 2, i64 0))
+; CHECK-NEXT:    store i64 1234, i64* [[PIA1B]], align 4
 ; CHECK-NEXT:    [[PIA1C:%.*]] = getelementptr i64, i64* [[PI]], i64 5
-; CHECK-NEXT:    store i64 [[IA1C]], i64* [[PIA1C]], align 4
+; CHECK-NEXT:    store i64 67890, i64* [[PIA1C]], align 4
 ; CHECK-NEXT:    ret void
 ;
 ; Fold atol(a[0].a) to 1.
   %pa0a = getelementptr [2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 0, i64 0
   %ia0a = call i64 @atol(i8* %pa0a)
   %pia0a = getelementptr i64, i64* %pi, i32 0
   store i64 %ia0a, i64* %pia0a
 

 }
 
 
 ; Fold atoll(a[I].M + C) for constant I in [0, 1], member M in [a, b, c],
 ; and C in a valid range to a constant.
 
 define void @fold_atoll_member_pC(i64* %pi) {
 ; CHECK-LABEL: @fold_atoll_member_pC(
-; CHECK-NEXT:    [[IA0A:%.*]] = call i64 @atol(i8* getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 0, i64 0))
-; CHECK-NEXT:    store i64 [[IA0A]], i64* [[PI:%.*]], align 4
-; CHECK-NEXT:    [[IA0BP1:%.*]] = call i64 @atol(i8* getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 1, i64 1))
+; CHECK-NEXT:    store i64 1, i64* [[PI:%.*]], align 4
 ; CHECK-NEXT:    [[PIA0BP1:%.*]] = getelementptr i64, i64* [[PI]], i64 1
-; CHECK-NEXT:    store i64 [[IA0BP1]], i64* [[PIA0BP1]], align 4
-; CHECK-NEXT:    [[IA0CP3:%.*]] = call i64 @atol(i8* getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 2, i64 3))
+; CHECK-NEXT:    store i64 2, i64* [[PIA0BP1]], align 4
 ; CHECK-NEXT:    [[PIA0CP3:%.*]] = getelementptr i64, i64* [[PI]], i64 2
-; CHECK-NEXT:    store i64 [[IA0CP3]], i64* [[PIA0CP3]], align 4
-; CHECK-NEXT:    [[IA1AP2:%.*]] = call i64 @atol(i8* getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 0, i64 2))
+; CHECK-NEXT:    store i64 89, i64* [[PIA0CP3]], align 4
 ; CHECK-NEXT:    [[PIA1AP2:%.*]] = getelementptr i64, i64* [[PI]], i64 3
-; CHECK-NEXT:    store i64 [[IA1AP2]], i64* [[PIA1AP2]], align 4
-; CHECK-NEXT:    [[IA1BP3:%.*]] = call i64 @atol(i8* getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 1, i64 3))
+; CHECK-NEXT:    store i64 3, i64* [[PIA1AP2]], align 4
 ; CHECK-NEXT:    [[PIA1BP3:%.*]] = getelementptr i64, i64* [[PI]], i64 4
-; CHECK-NEXT:    store i64 [[IA1BP3]], i64* [[PIA1BP3]], align 4
-; CHECK-NEXT:    [[IA1CP4:%.*]] = call i64 @atol(i8* getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 2, i64 4))
+; CHECK-NEXT:    store i64 4, i64* [[PIA1BP3]], align 4
 ; CHECK-NEXT:    [[PIA1CP4:%.*]] = getelementptr i64, i64* [[PI]], i64 5
-; CHECK-NEXT:    store i64 [[IA1CP4]], i64* [[PIA1CP4]], align 4
+; CHECK-NEXT:    store i64 0, i64* [[PIA1CP4]], align 4
 ; CHECK-NEXT:    ret void
 ;
 ; Fold atoll(a[0].a) to 1.
   %pa0a = getelementptr [2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 0, i64 0
   %ia0a = call i64 @atol(i8* %pa0a)
   %pia0a = getelementptr i64, i64* %pi, i32 0
   store i64 %ia0a, i64* %pia0a
 

 }
 
 
 ; Fold strtol(a[I].M + C, 0, 0) for constant I in [0, 1], member M in [a, b, c],
 ; and C in a valid range to a constant.
 
 define void @fold_strtol_member_pC(i64* %pi) {
 ; CHECK-LABEL: @fold_strtol_member_pC(
-; CHECK-NEXT:    [[IA0A:%.*]] = call i64 @strtol(i8* nocapture getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 0, i64 0), i8** null, i32 0)
-; CHECK-NEXT:    store i64 [[IA0A]], i64* [[PI:%.*]], align 4
-; CHECK-NEXT:    [[IA0BP1:%.*]] = call i64 @strtol(i8* nocapture getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 1, i64 1), i8** null, i32 0)
+; CHECK-NEXT:    store i64 1, i64* [[PI:%.*]], align 4
 ; CHECK-NEXT:    [[PIA0BP1:%.*]] = getelementptr i64, i64* [[PI]], i64 1
-; CHECK-NEXT:    store i64 [[IA0BP1]], i64* [[PIA0BP1]], align 4
-; CHECK-NEXT:    [[IA0CP3:%.*]] = call i64 @strtol(i8* nocapture getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 2, i64 3), i8** null, i32 0)
+; CHECK-NEXT:    store i64 2, i64* [[PIA0BP1]], align 4
 ; CHECK-NEXT:    [[PIA0CP3:%.*]] = getelementptr i64, i64* [[PI]], i64 2
-; CHECK-NEXT:    store i64 [[IA0CP3]], i64* [[PIA0CP3]], align 4
-; CHECK-NEXT:    [[IA1AP2:%.*]] = call i64 @strtol(i8* nocapture getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 0, i64 2), i8** null, i32 0)
+; CHECK-NEXT:    store i64 89, i64* [[PIA0CP3]], align 4
 ; CHECK-NEXT:    [[PIA1AP2:%.*]] = getelementptr i64, i64* [[PI]], i64 3
-; CHECK-NEXT:    store i64 [[IA1AP2]], i64* [[PIA1AP2]], align 4
-; CHECK-NEXT:    [[IA1BP3:%.*]] = call i64 @strtol(i8* nocapture getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 1, i64 3), i8** null, i32 0)
+; CHECK-NEXT:    store i64 3, i64* [[PIA1AP2]], align 4
 ; CHECK-NEXT:    [[PIA1BP3:%.*]] = getelementptr i64, i64* [[PI]], i64 4
-; CHECK-NEXT:    store i64 [[IA1BP3]], i64* [[PIA1BP3]], align 4
-; CHECK-NEXT:    [[IA1CP4:%.*]] = call i64 @strtol(i8* nocapture getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 2, i64 4), i8** null, i32 0)
+; CHECK-NEXT:    store i64 4, i64* [[PIA1BP3]], align 4
 ; CHECK-NEXT:    [[PIA1CP4:%.*]] = getelementptr i64, i64* [[PI]], i64 5
-; CHECK-NEXT:    store i64 [[IA1CP4]], i64* [[PIA1CP4]], align 4
+; CHECK-NEXT:    store i64 0, i64* [[PIA1CP4]], align 4
 ; CHECK-NEXT:    ret void
 ;
 ; Fold strtol(a[0].a, 0, 0) to 1.
   %pa0a = getelementptr [2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 0, i64 0
   %ia0a = call i64 @strtol(i8* %pa0a, i8** null, i32 0)
   %pia0a = getelementptr i64, i64* %pi, i32 0
   store i64 %ia0a, i64* %pia0a
 

 }
 
 
 ; Fold strtoll(a[I].M + C, 0, 0) for constant I in [0, 1], member M
 ; in [a, b, c], and C in a valid range to a constant.
 
 define void @fold_strtoll_member_pC(i64* %pi) {
 ; CHECK-LABEL: @fold_strtoll_member_pC(
-; CHECK-NEXT:    [[IA0A:%.*]] = call i64 @strtoll(i8* nocapture getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 0, i64 0), i8** null, i32 0)
-; CHECK-NEXT:    store i64 [[IA0A]], i64* [[PI:%.*]], align 4
-; CHECK-NEXT:    [[IA0BP1:%.*]] = call i64 @strtoll(i8* nocapture getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 1, i64 1), i8** null, i32 0)
+; CHECK-NEXT:    store i64 1, i64* [[PI:%.*]], align 4
 ; CHECK-NEXT:    [[PIA0BP1:%.*]] = getelementptr i64, i64* [[PI]], i64 1
-; CHECK-NEXT:    store i64 [[IA0BP1]], i64* [[PIA0BP1]], align 4
-; CHECK-NEXT:    [[IA0CP3:%.*]] = call i64 @strtoll(i8* nocapture getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 2, i64 3), i8** null, i32 0)
+; CHECK-NEXT:    store i64 2, i64* [[PIA0BP1]], align 4
 ; CHECK-NEXT:    [[PIA0CP3:%.*]] = getelementptr i64, i64* [[PI]], i64 2
-; CHECK-NEXT:    store i64 [[IA0CP3]], i64* [[PIA0CP3]], align 4
-; CHECK-NEXT:    [[IA1AP2:%.*]] = call i64 @strtoll(i8* nocapture getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 0, i64 2), i8** null, i32 0)
+; CHECK-NEXT:    store i64 89, i64* [[PIA0CP3]], align 4
 ; CHECK-NEXT:    [[PIA1AP2:%.*]] = getelementptr i64, i64* [[PI]], i64 3
-; CHECK-NEXT:    store i64 [[IA1AP2]], i64* [[PIA1AP2]], align 4
-; CHECK-NEXT:    [[IA1BP3:%.*]] = call i64 @strtoll(i8* nocapture getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 1, i64 3), i8** null, i32 0)
+; CHECK-NEXT:    store i64 3, i64* [[PIA1AP2]], align 4
 ; CHECK-NEXT:    [[PIA1BP3:%.*]] = getelementptr i64, i64* [[PI]], i64 4
-; CHECK-NEXT:    store i64 [[IA1BP3]], i64* [[PIA1BP3]], align 4
-; CHECK-NEXT:    [[IA1CP4:%.*]] = call i64 @strtoll(i8* nocapture getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 2, i64 4), i8** null, i32 0)
+; CHECK-NEXT:    store i64 4, i64* [[PIA1BP3]], align 4
 ; CHECK-NEXT:    [[PIA1CP4:%.*]] = getelementptr i64, i64* [[PI]], i64 5
-; CHECK-NEXT:    store i64 [[IA1CP4]], i64* [[PIA1CP4]], align 4
+; CHECK-NEXT:    store i64 0, i64* [[PIA1CP4]], align 4
 ; CHECK-NEXT:    ret void
 ;
 ; Fold strtoll(a[0].a, 0, 0) to 1.
   %pa0a = getelementptr [2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 0, i64 0
   %ia0a = call i64 @strtoll(i8* %pa0a, i8** null, i32 0)
   %pia0a = getelementptr i64, i64* %pi, i32 0
   store i64 %ia0a, i64* %pia0a
 

llvm/test/Transforms/InstCombine/strcmp-3.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; Verify that strlen calls with elements of constant arrays are folded.
 ;
 ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
 
 declare i32 @strcmp(i8*, i8*)
 
 @a5 = constant [5 x [4 x i8]] [[4 x i8] c"123\00", [4 x i8] c"123\00", [4 x i8] c"12\00\00", [4 x i8] zeroinitializer, [4 x i8] zeroinitializer]
 
 
 ; Fold strcmp(a5[0], a5[1]) to '1' - '1'.
 
 define i32 @fold_strcmp_a5i0_a5i1_to_0() {
 ; CHECK-LABEL: @fold_strcmp_a5i0_a5i1_to_0(
-; CHECK-NEXT:    [[CMP:%.*]] = call i32 @strcmp(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 0, i64 0), i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 1, i64 0))
-; CHECK-NEXT:    ret i32 [[CMP]]
+; CHECK-NEXT:    ret i32 0
 ;
   %p = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 0, i64 0
   %q = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 1, i64 0
 
   %cmp = call i32 @strcmp(i8* %p, i8* %q)
   ret i32 %cmp
 }
 
 
 ; Do not fold strcmp(a5[0], a5[I]) where the index I is not constant.
 
 define i32 @call_strcmp_a5i0_a5iI(i64 %I) {
 ; CHECK-LABEL: @call_strcmp_a5i0_a5iI(
 ; CHECK-NEXT:    [[Q:%.*]] = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 [[I:%.*]], i64 0
-; CHECK-NEXT:    [[CMP:%.*]] = call i32 @strcmp(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 0, i64 0), i8* noundef nonnull dereferenceable(1) [[Q]])
+; CHECK-NEXT:    [[CMP:%.*]] = call i32 @strcmp(i8* noundef nonnull dereferenceable(4) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 0, i64 0), i8* noundef nonnull dereferenceable(1) [[Q]])
 ; CHECK-NEXT:    ret i32 [[CMP]]
 ;
   %p = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 0, i64 0
   %q = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 %I, i64 0
 
   %cmp = call i32 @strcmp(i8* %p, i8* %q)
   ret i32 %cmp
 }
 
 
 ; Same as above but for strcmp(a5[I], a5[0]).
 
 define i32 @call_strcmp_a5iI_a5i0(i64 %I) {
 ; CHECK-LABEL: @call_strcmp_a5iI_a5i0(
 ; CHECK-NEXT:    [[P:%.*]] = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 [[I:%.*]], i64 0
-; CHECK-NEXT:    [[CMP:%.*]] = call i32 @strcmp(i8* noundef nonnull dereferenceable(1) [[P]], i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 0, i64 0))
+; CHECK-NEXT:    [[CMP:%.*]] = call i32 @strcmp(i8* noundef nonnull dereferenceable(1) [[P]], i8* noundef nonnull dereferenceable(4) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 0, i64 0))
 ; CHECK-NEXT:    ret i32 [[CMP]]
 ;
   %p = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 %I, i64 0
   %q = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 0, i64 0
 
   %cmp = call i32 @strcmp(i8* %p, i8* %q)
   ret i32 %cmp
 }
 
 
 ; Fold strcmp(a5[0], &a5[1][1]) to '1' - '2'.
 
 define i32 @fold_strcmp_a5i0_a5i1_p1_to_0() {
 ; CHECK-LABEL: @fold_strcmp_a5i0_a5i1_p1_to_0(
-; CHECK-NEXT:    [[CMP:%.*]] = call i32 @strcmp(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 0, i64 0), i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 1, i64 1))
-; CHECK-NEXT:    ret i32 [[CMP]]
+; CHECK-NEXT:    ret i32 -1
 ;
   %p = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 0, i64 0
   %q = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 1, i64 1
 
   %cmp = call i32 @strcmp(i8* %p, i8* %q)
   ret i32 %cmp
 }
 
 
 ; Do not fold strcmp(a5[0], &a5[1][I]) when the index I is not constant.
 
 define i32 @call_strcmp_a5i0_a5i1_pI(i64 %I) {
 ; CHECK-LABEL: @call_strcmp_a5i0_a5i1_pI(
 ; CHECK-NEXT:    [[Q:%.*]] = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 1, i64 [[I:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = call i32 @strcmp(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 0, i64 0), i8* noundef nonnull dereferenceable(1) [[Q]])
+; CHECK-NEXT:    [[CMP:%.*]] = call i32 @strcmp(i8* noundef nonnull dereferenceable(4) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 0, i64 0), i8* noundef nonnull dereferenceable(1) [[Q]])
 ; CHECK-NEXT:    ret i32 [[CMP]]
 ;
   %p = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 0, i64 0
   %q = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 1, i64 %I
 
   %cmp = call i32 @strcmp(i8* %p, i8* %q)
   ret i32 %cmp
 }
 
 
 ; Fold strcmp(&a5[0][1], a5[1]) to '2' - '1'.
 
 define i32 @fold_strcmp_a5i0_p1_a5i1_to_0() {
 ; CHECK-LABEL: @fold_strcmp_a5i0_p1_a5i1_to_0(
-; CHECK-NEXT:    [[CMP:%.*]] = call i32 @strcmp(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 0, i64 1), i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 1, i64 0))
-; CHECK-NEXT:    ret i32 [[CMP]]
+; CHECK-NEXT:    ret i32 1
 ;
   %p = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 0, i64 1
   %q = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 1, i64 0
 
   %cmp = call i32 @strcmp(i8* %p, i8* %q)
   ret i32 %cmp
 }
 
 
 ; Fold strcmp(a5[0], a5[2]) to a5[0][2] - a5[2][2] or 1.
 
 define i32 @fold_strcmp_a5i0_a5i2_to_0() {
 ; CHECK-LABEL: @fold_strcmp_a5i0_a5i2_to_0(
-; CHECK-NEXT:    [[CMP:%.*]] = call i32 @strcmp(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 0, i64 0), i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 2, i64 0))
-; CHECK-NEXT:    ret i32 [[CMP]]
+; CHECK-NEXT:    ret i32 1
 ;
   %p = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 0, i64 0
   %q = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 2, i64 0
 
   %cmp = call i32 @strcmp(i8* %p, i8* %q)
   ret i32 %cmp
 }
 
 
 ; Fold strcmp(a5[2], a5[0]) to a5[0][2] - a5[2][2] or 1.
 
 define i32 @fold_strcmp_a5i2_a5i0_to_m1() {
 ; CHECK-LABEL: @fold_strcmp_a5i2_a5i0_to_m1(
-; CHECK-NEXT:    [[CMP:%.*]] = call i32 @strcmp(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 2, i64 0), i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 0, i64 0))
-; CHECK-NEXT:    ret i32 [[CMP]]
+; CHECK-NEXT:    ret i32 -1
 ;
   %p = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 0, i64 0
   %q = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5, i64 0, i64 2, i64 0
 
   %cmp = call i32 @strcmp(i8* %q, i8* %p)
   ret i32 %cmp
 }

llvm/test/Transforms/InstCombine/strlen-5.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; Verify that strlen calls with elements of constant arrays are folded.
 ;
 ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
 
 declare i64 @strlen(i8*)
 
 @a5_4 = constant [5 x [4 x i8]] [[4 x i8] c"123\00", [4 x i8] c"12\00\00", [4 x i8] c"1\00\00\00", [4 x i8] zeroinitializer, [4 x i8] zeroinitializer]
 
 
 ; Fold strlen(a5_4[0]) to 3.
 
 define i64 @fold_a5_4_i0_to_3() {
 ; CHECK-LABEL: @fold_a5_4_i0_to_3(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 0, i64 0))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 3
 ;
   %ptr = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 0, i64 0
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(&a5_4[0][1]) to 2.
 
 define i64 @fold_a5_4_i0_p1_to_2() {
 ; CHECK-LABEL: @fold_a5_4_i0_p1_to_2(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 0, i64 1))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 2
 ;
   %ptr = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 0, i64 1
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(&a5_4[0][2]) to 1.
 
 define i64 @fold_a5_4_i0_p2_to_1() {
 ; CHECK-LABEL: @fold_a5_4_i0_p2_to_1(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 0, i64 2))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 1
 ;
   %ptr = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 0, i64 2
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(&a5_4[0][3]) to 0.
 
 define i64 @fold_a5_4_i0_p3_to_0() {
 ; CHECK-LABEL: @fold_a5_4_i0_p3_to_0(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 0, i64 3))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 0
 ;
   %ptr = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 0, i64 3
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(a5_4[1]) to 2.
 
 define i64 @fold_a5_4_i1_to_2() {
 ; CHECK-LABEL: @fold_a5_4_i1_to_2(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 1, i64 0))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 2
 ;
   %ptr = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 1, i64 0
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(&a5_4[1][1]) to 1.
 
 define i64 @fold_a5_4_i1_p1_to_1() {
 ; CHECK-LABEL: @fold_a5_4_i1_p1_to_1(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 1, i64 1))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 1
 ;
   %ptr = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 1, i64 1
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(&a5_4[1][2]) to 0.
 
 define i64 @fold_a5_4_i1_p2_to_0() {
 ; CHECK-LABEL: @fold_a5_4_i1_p2_to_0(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 1, i64 2))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 0
 ;
   %ptr = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 1, i64 2
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(&a5_4[1][3]) to 0.
 
 define i64 @fold_a5_4_i1_p3_to_0() {
 ; CHECK-LABEL: @fold_a5_4_i1_p3_to_0(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 1, i64 3))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 0
 ;
   %ptr = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 1, i64 3
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(a5_4[2]) to 1.
 
 define i64 @fold_a5_4_i2_to_1() {
 ; CHECK-LABEL: @fold_a5_4_i2_to_1(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 2, i64 0))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 1
 ;
   %ptr = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 2, i64 0
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(&a5_4[2][1]) to 0.
 
 define i64 @fold_a5_4_i2_p1_to_0() {
 ; CHECK-LABEL: @fold_a5_4_i2_p1_to_0(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 2, i64 1))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 0
 ;
   %ptr = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 2, i64 1
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(&a5_4[2][2]) to 0.
 
 define i64 @fold_a5_4_i2_p2_to_0() {
 ; CHECK-LABEL: @fold_a5_4_i2_p2_to_0(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 2, i64 2))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 0
 ;
   %ptr = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 2, i64 2
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(&a5_4[2][3]) to 0.
 
 define i64 @fold_a5_4_i2_p3_to_0() {
 ; CHECK-LABEL: @fold_a5_4_i2_p3_to_0(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 2, i64 3))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 0
 ;
   %ptr = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 2, i64 3
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(a5_4[3]) to 0
 
 define i64 @fold_a5_4_i3_to_0() {
 ; CHECK-LABEL: @fold_a5_4_i3_to_0(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 3, i64 0))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 0
 ;
   %ptr = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 3, i64 0
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(&a5_4[3][1]) to 0
 
 define i64 @fold_a5_4_i3_p1_to_0() {
 ; CHECK-LABEL: @fold_a5_4_i3_p1_to_0(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 3, i64 1))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 0
 ;
   %ptr = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 3, i64 1
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(&a5_4[3][2]) to 0
 
 define i64 @fold_a5_4_i3_p2_to_0() {
 ; CHECK-LABEL: @fold_a5_4_i3_p2_to_0(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 3, i64 2))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 0
 ;
   %ptr = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 3, i64 2
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(&a5_4[3][3]) to 0
 
 define i64 @fold_a5_3_i4_p3_to_0() {
 ; CHECK-LABEL: @fold_a5_3_i4_p3_to_0(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 3, i64 3))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 0
 ;
   %ptr = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 3, i64 3
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(a5_4[4]) to 0
 
 define i64 @fold_a5_4_i4_to_0() {
 ; CHECK-LABEL: @fold_a5_4_i4_to_0(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 4, i64 0))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 0
 ;
   %ptr = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 4, i64 0
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(&a5_4[4][1]) to 0
 
 define i64 @fold_a5_4_i4_p1_to_0() {
 ; CHECK-LABEL: @fold_a5_4_i4_p1_to_0(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 4, i64 1))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 0
 ;
   %ptr = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 4, i64 1
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(&a5_4[4][2]) to 0
 
 define i64 @fold_a5_4_i4_p2_to_0() {
 ; CHECK-LABEL: @fold_a5_4_i4_p2_to_0(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 4, i64 2))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 0
 ;
   %ptr = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 4, i64 2
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(&a5_4[4][3]) to 0
 
 define i64 @fold_a5_4_i4_p3_to_0() {
 ; CHECK-LABEL: @fold_a5_4_i4_p3_to_0(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 4, i64 3))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 0
 ;
   %ptr = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 4, i64 3
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }

llvm/test/Transforms/InstCombine/strlen-6.ll

 
 declare i64 @strlen(i8*)
 
 
 ; Fold strlen(a_s3.a) to 3.
 
 define i64 @fold_strlen_a_S3_to_3() {
 ; CHECK-LABEL: @fold_strlen_a_S3_to_3(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A_A4:%.*]], %struct.A_a4* @a_s3, i64 0, i32 0, i64 0))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 3
 ;
   %ptr = getelementptr %struct.A_a4, %struct.A_a4* @a_s3, i32 0, i32 0, i32 0
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(&a_s3.a[1]) to 2.
 
 define i64 @fold_strlen_a_S3_p1_to_2() {
 ; CHECK-LABEL: @fold_strlen_a_S3_p1_to_2(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A_A4:%.*]], %struct.A_a4* @a_s3, i64 0, i32 0, i64 1))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 2
 ;
   %ptr = getelementptr %struct.A_a4, %struct.A_a4* @a_s3, i32 0, i32 0, i32 1
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(&a_s3.a[2]) to 1.
 
 define i64 @fold_strlen_a_S3_p2_to_1() {
 ; CHECK-LABEL: @fold_strlen_a_S3_p2_to_1(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A_A4:%.*]], %struct.A_a4* @a_s3, i64 0, i32 0, i64 2))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 1
 ;
   %ptr = getelementptr %struct.A_a4, %struct.A_a4* @a_s3, i32 0, i32 0, i32 2
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(&a_s3.a[3]) to 0.
 
 define i64 @fold_strlen_a_S3_p3_to_0() {
 ; CHECK-LABEL: @fold_strlen_a_S3_p3_to_0(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A_A4:%.*]], %struct.A_a4* @a_s3, i64 0, i32 0, i64 3))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 0
 ;
   %ptr = getelementptr %struct.A_a4, %struct.A_a4* @a_s3, i32 0, i32 0, i32 3
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(a_s3_s4.a) to 3.
 
 define i64 @fold_strlen_a_S3_s4_to_3() {
 ; CHECK-LABEL: @fold_strlen_a_S3_s4_to_3(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A_A4_A5:%.*]], %struct.A_a4_a5* @a_s3_s4, i64 0, i32 0, i64 0))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 3
 ;
   %ptr = getelementptr %struct.A_a4_a5, %struct.A_a4_a5* @a_s3_s4, i32 0, i32 0, i32 0
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(&a_s3_s4.a[2]) to 1.
 
 define i64 @fold_strlen_a_S3_p2_s4_to_1() {
 ; CHECK-LABEL: @fold_strlen_a_S3_p2_s4_to_1(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A_A4_A5:%.*]], %struct.A_a4_a5* @a_s3_s4, i64 0, i32 0, i64 2))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 1
 ;
   %ptr = getelementptr %struct.A_a4_a5, %struct.A_a4_a5* @a_s3_s4, i32 0, i32 0, i32 2
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(a_s3_s4.b) to 4.
 ; Exercise both variants of the GEP index.
 
 define void @fold_strlen_a_s3_S4_to_4() {
 ; CHECK-LABEL: @fold_strlen_a_s3_S4_to_4(
-; CHECK-NEXT:    [[LEN1:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A_A4_A5:%.*]], %struct.A_a4_a5* @a_s3_s4, i64 0, i32 1, i64 0))
-; CHECK-NEXT:    store i64 [[LEN1]], i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 0), align 4
-; CHECK-NEXT:    [[LEN2:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A_A4_A5]], %struct.A_a4_a5* @a_s3_s4, i64 0, i32 1, i64 0))
-; CHECK-NEXT:    store i64 [[LEN1]], i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 1), align 4
+; CHECK-NEXT:    store i64 4, i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 0), align 4
+; CHECK-NEXT:    store i64 4, i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 1), align 4
 ; CHECK-NEXT:    ret void
 ;
   %p1 = getelementptr %struct.A_a4_a5, %struct.A_a4_a5* @a_s3_s4, i32 0, i32 0, i32 4
   %len1 = call i64 @strlen(i8* %p1)
   %pax0 = getelementptr inbounds [0 x i64], [0 x i64]* @ax, i64 0, i64 0
   store i64 %len1, i64* %pax0
 
   %p2 = getelementptr %struct.A_a4_a5, %struct.A_a4_a5* @a_s3_s4, i32 0, i32 1, i32 0
   %len2 = call i64 @strlen(i8* %p2)
   %pax1 = getelementptr inbounds [0 x i64], [0 x i64]* @ax, i64 0, i64 1
   store i64 %len1, i64* %pax1
 
   ret void
 }
 
 
 ; Fold strlen(&a_s3_s4.b[1]) to 3.
 ; Exercise both variants of the GEP index.
 
 define void @fold_strlen_a_s3_S4_p1_to_3() {
 ; CHECK-LABEL: @fold_strlen_a_s3_S4_p1_to_3(
-; CHECK-NEXT:    [[LEN1:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A_A4_A5:%.*]], %struct.A_a4_a5* @a_s3_s4, i64 0, i32 1, i64 1))
-; CHECK-NEXT:    store i64 [[LEN1]], i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 0), align 4
-; CHECK-NEXT:    [[LEN2:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A_A4_A5]], %struct.A_a4_a5* @a_s3_s4, i64 0, i32 1, i64 1))
-; CHECK-NEXT:    store i64 [[LEN1]], i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 1), align 4
+; CHECK-NEXT:    store i64 3, i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 0), align 4
+; CHECK-NEXT:    store i64 3, i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 1), align 4
 ; CHECK-NEXT:    ret void
 ;
   %p1 = getelementptr %struct.A_a4_a5, %struct.A_a4_a5* @a_s3_s4, i32 0, i32 0, i32 5
   %len1 = call i64 @strlen(i8* %p1)
   %pax0 = getelementptr inbounds [0 x i64], [0 x i64]* @ax, i64 0, i64 0
   store i64 %len1, i64* %pax0
 
   %p2 = getelementptr %struct.A_a4_a5, %struct.A_a4_a5* @a_s3_s4, i32 0, i32 1, i32 1
   %len2 = call i64 @strlen(i8* %p2)
   %pax1 = getelementptr inbounds [0 x i64], [0 x i64]* @ax, i64 0, i64 1
   store i64 %len1, i64* %pax1
 
   ret void
 }
 
 
 ; Fold strlen(a_s3_i32_s4.b) to 4.
 ; Exercise both variants of the GEP index.
 
 define void @fold_strlen_a_s3_i32_S4_to_4() {
 ; CHECK-LABEL: @fold_strlen_a_s3_i32_S4_to_4(
-; CHECK-NEXT:    [[LEN1:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A_A4_I32_A5:%.*]], %struct.A_a4_i32_a5* @a_s3_i32_s4, i64 0, i32 2, i64 0))
-; CHECK-NEXT:    store i64 [[LEN1]], i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 0), align 4
-; CHECK-NEXT:    [[LEN2:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A_A4_I32_A5]], %struct.A_a4_i32_a5* @a_s3_i32_s4, i64 0, i32 2, i64 0))
-; CHECK-NEXT:    store i64 [[LEN1]], i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 1), align 4
+; CHECK-NEXT:    store i64 4, i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 0), align 4
+; CHECK-NEXT:    store i64 4, i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 1), align 4
 ; CHECK-NEXT:    ret void
 ;
   %p1 = getelementptr %struct.A_a4_i32_a5, %struct.A_a4_i32_a5* @a_s3_i32_s4, i32 0, i32 0, i32 8
   %len1 = call i64 @strlen(i8* %p1)
   %pax0 = getelementptr inbounds [0 x i64], [0 x i64]* @ax, i64 0, i64 0
   store i64 %len1, i64* %pax0
 
   %p2 = getelementptr %struct.A_a4_i32_a5, %struct.A_a4_i32_a5* @a_s3_i32_s4, i32 0, i32 2, i32 0
   %len2 = call i64 @strlen(i8* %p2)
   %pax1 = getelementptr inbounds [0 x i64], [0 x i64]* @ax, i64 0, i64 1
   store i64 %len1, i64* %pax1
 
   ret void
 }
 
 
 ; Fold strlen(&a_s3_i32_s4.b[1]) to 3.
 ; Exercise both variants of the GEP index.
 
 define void @fold_strlen_a_s3_i32_S4_p1_to_3() {
 ; CHECK-LABEL: @fold_strlen_a_s3_i32_S4_p1_to_3(
-; CHECK-NEXT:    [[LEN1:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A_A4_I32_A5:%.*]], %struct.A_a4_i32_a5* @a_s3_i32_s4, i64 0, i32 2, i64 1))
-; CHECK-NEXT:    store i64 [[LEN1]], i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 0), align 4
-; CHECK-NEXT:    [[LEN2:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A_A4_I32_A5]], %struct.A_a4_i32_a5* @a_s3_i32_s4, i64 0, i32 2, i64 0))
-; CHECK-NEXT:    store i64 [[LEN1]], i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 1), align 4
+; CHECK-NEXT:    store i64 3, i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 0), align 4
+; CHECK-NEXT:    store i64 3, i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 1), align 4
 ; CHECK-NEXT:    ret void
 ;
   %p1 = getelementptr %struct.A_a4_i32_a5, %struct.A_a4_i32_a5* @a_s3_i32_s4, i32 0, i32 0, i32 9
   %len1 = call i64 @strlen(i8* %p1)
   %pax0 = getelementptr inbounds [0 x i64], [0 x i64]* @ax, i64 0, i64 0
   store i64 %len1, i64* %pax0
 
   %p2 = getelementptr %struct.A_a4_i32_a5, %struct.A_a4_i32_a5* @a_s3_i32_s4, i32 0, i32 2, i32 0
   %len2 = call i64 @strlen(i8* %p2)
   %pax1 = getelementptr inbounds [0 x i64], [0 x i64]* @ax, i64 0, i64 1
   store i64 %len1, i64* %pax1
 
   ret void
 }
 
 
 ; Fold strlen(&a_s3_i32_s4.b[2]) to 2.
 ; Exercise both variants of the GEP index.
 
 define void @fold_strlen_a_s3_i32_S4_p2_to_2() {
 ; CHECK-LABEL: @fold_strlen_a_s3_i32_S4_p2_to_2(
-; CHECK-NEXT:    [[LEN1:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A_A4_I32_A5:%.*]], %struct.A_a4_i32_a5* @a_s3_i32_s4, i64 0, i32 2, i64 2))
-; CHECK-NEXT:    store i64 [[LEN1]], i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 0), align 4
-; CHECK-NEXT:    [[LEN2:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A_A4_I32_A5]], %struct.A_a4_i32_a5* @a_s3_i32_s4, i64 0, i32 2, i64 2))
-; CHECK-NEXT:    store i64 [[LEN1]], i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 1), align 4
+; CHECK-NEXT:    store i64 2, i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 0), align 4
+; CHECK-NEXT:    store i64 2, i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 1), align 4
 ; CHECK-NEXT:    ret void
 ;
   %p1 = getelementptr %struct.A_a4_i32_a5, %struct.A_a4_i32_a5* @a_s3_i32_s4, i32 0, i32 0, i32 10
   %len1 = call i64 @strlen(i8* %p1)
   %pax0 = getelementptr inbounds [0 x i64], [0 x i64]* @ax, i64 0, i64 0
   store i64 %len1, i64* %pax0
 
   %p2 = getelementptr %struct.A_a4_i32_a5, %struct.A_a4_i32_a5* @a_s3_i32_s4, i32 0, i32 2, i32 2
   %len2 = call i64 @strlen(i8* %p2)
   %pax1 = getelementptr inbounds [0 x i64], [0 x i64]* @ax, i64 0, i64 1
   store i64 %len1, i64* %pax1
 
   ret void
 }
 
 
 ; Fold strlen(&a_s3_i32_s4.b[3]) to 1.
 ; Exercise both variants of the GEP index.
 
 define void @fold_strlen_a_s3_i32_S4_p3_to_1() {
 ; CHECK-LABEL: @fold_strlen_a_s3_i32_S4_p3_to_1(
-; CHECK-NEXT:    [[LEN1:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A_A4_I32_A5:%.*]], %struct.A_a4_i32_a5* @a_s3_i32_s4, i64 0, i32 2, i64 3))
-; CHECK-NEXT:    store i64 [[LEN1]], i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 0), align 4
-; CHECK-NEXT:    [[LEN2:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A_A4_I32_A5]], %struct.A_a4_i32_a5* @a_s3_i32_s4, i64 0, i32 2, i64 3))
-; CHECK-NEXT:    store i64 [[LEN1]], i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 1), align 4
+; CHECK-NEXT:    store i64 1, i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 0), align 4
+; CHECK-NEXT:    store i64 1, i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 1), align 4
 ; CHECK-NEXT:    ret void
 ;
   %p1 = getelementptr %struct.A_a4_i32_a5, %struct.A_a4_i32_a5* @a_s3_i32_s4, i32 0, i32 0, i32 11
   %len1 = call i64 @strlen(i8* %p1)
   %pax0 = getelementptr inbounds [0 x i64], [0 x i64]* @ax, i64 0, i64 0
   store i64 %len1, i64* %pax0
 
   %p2 = getelementptr %struct.A_a4_i32_a5, %struct.A_a4_i32_a5* @a_s3_i32_s4, i32 0, i32 2, i32 3
   %len2 = call i64 @strlen(i8* %p2)
   %pax1 = getelementptr inbounds [0 x i64], [0 x i64]* @ax, i64 0, i64 1
   store i64 %len1, i64* %pax1
 
   ret void
 }
 
 
 ; Fold strlen(&a_s3_i32_s4.b[4]) to 0.
 ; Exercise both variants of the GEP index.
 
 define void @fold_strlen_a_s3_i32_S4_p4_to_0() {
 ; CHECK-LABEL: @fold_strlen_a_s3_i32_S4_p4_to_0(
-; CHECK-NEXT:    [[LEN1:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A_A4_I32_A5:%.*]], %struct.A_a4_i32_a5* @a_s3_i32_s4, i64 0, i32 2, i64 4))
-; CHECK-NEXT:    store i64 [[LEN1]], i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 0), align 4
-; CHECK-NEXT:    [[LEN2:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A_A4_I32_A5]], %struct.A_a4_i32_a5* @a_s3_i32_s4, i64 0, i32 2, i64 4))
-; CHECK-NEXT:    store i64 [[LEN1]], i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 1), align 4
+; CHECK-NEXT:    store i64 0, i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 0), align 4
+; CHECK-NEXT:    store i64 0, i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 1), align 4
 ; CHECK-NEXT:    ret void
 ;
   %p1 = getelementptr %struct.A_a4_i32_a5, %struct.A_a4_i32_a5* @a_s3_i32_s4, i32 0, i32 0, i32 12
   %len1 = call i64 @strlen(i8* %p1)
   %pax0 = getelementptr inbounds [0 x i64], [0 x i64]* @ax, i64 0, i64 0
   store i64 %len1, i64* %pax0
 
   %p2 = getelementptr %struct.A_a4_i32_a5, %struct.A_a4_i32_a5* @a_s3_i32_s4, i32 0, i32 2, i32 4
   %len2 = call i64 @strlen(i8* %p2)
   %pax1 = getelementptr inbounds [0 x i64], [0 x i64]* @ax, i64 0, i64 1
   store i64 %len1, i64* %pax1
 
   ret void
 }
 
 
 ; Fold strlen(ax_sN.a) of an constant initialized flexible array member
 ; to N for N in { 3, 5, 7 }.
 
 define void @fold_strlen_ax_s() {
 ; CHECK-LABEL: @fold_strlen_ax_s(
-; CHECK-NEXT:    [[LEN3:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ({ i8, [4 x i8] }, { i8, [4 x i8] }* @ax_s3, i64 0, i32 1, i64 0))
-; CHECK-NEXT:    store i64 [[LEN3]], i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 0), align 4
-; CHECK-NEXT:    [[LEN5:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ({ i16, [6 x i8] }, { i16, [6 x i8] }* @ax_s5, i64 0, i32 1, i64 0))
-; CHECK-NEXT:    store i64 [[LEN5]], i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 1), align 4
-; CHECK-NEXT:    [[LEN7:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ({ i32, i32, [8 x i8] }, { i32, i32, [8 x i8] }* @ax_s7, i64 0, i32 2, i64 0))
-; CHECK-NEXT:    store i64 [[LEN7]], i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 2), align 4
+; CHECK-NEXT:    store i64 3, i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 0), align 4
+; CHECK-NEXT:    store i64 5, i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 1), align 4
+; CHECK-NEXT:    store i64 7, i64* getelementptr inbounds ([0 x i64], [0 x i64]* @ax, i64 0, i64 2), align 4
 ; CHECK-NEXT:    ret void
 ;
   %pax_s3 = getelementptr { i8, [4 x i8] }, { i8, [4 x i8] }* @ax_s3, i64 0, i32 1, i64 0
   %len3 = call i64 @strlen(i8* %pax_s3)
   %pax1 = getelementptr inbounds [0 x i64], [0 x i64]* @ax, i64 0, i64 0
   store i64 %len3, i64* %pax1
 
   %pax_s5 = getelementptr { i16, [6 x i8] }, { i16, [6 x i8] }* @ax_s5, i64 0, i32 1, i64 0

llvm/test/Transforms/InstCombine/strlen-7.ll

 @a = constant [2 x %struct.A] [%struct.A { [4 x i8] c"1\00\00\00", [5 x i8] c"12\00\00\00" }, %struct.A { [4 x i8] c"123\00", [5 x i8] c"1234\00" }], align 16
 
 
 ; Fold strlen(a[I].a + J) and strlen(a[I].b + J) with constant I and J
 ; to constants.
 
 define void @fold_strlen_A(i64* %plen) {
 ; CHECK-LABEL: @fold_strlen_A(
-; CHECK-NEXT:    [[LENA0A:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 0, i64 0))
-; CHECK-NEXT:    store i64 [[LENA0A]], i64* [[PLEN:%.*]], align 4
-; CHECK-NEXT:    [[LENA0AP1:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 0, i64 1))
+; CHECK-NEXT:    store i64 1, i64* [[PLEN:%.*]], align 4
 ; CHECK-NEXT:    [[PLEN1:%.*]] = getelementptr i64, i64* [[PLEN]], i64 1
-; CHECK-NEXT:    store i64 [[LENA0AP1]], i64* [[PLEN1]], align 4
-; CHECK-NEXT:    [[LENA0AP2:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 0, i64 2))
+; CHECK-NEXT:    store i64 0, i64* [[PLEN1]], align 4
 ; CHECK-NEXT:    [[PLEN2:%.*]] = getelementptr i64, i64* [[PLEN]], i64 2
-; CHECK-NEXT:    store i64 [[LENA0AP2]], i64* [[PLEN2]], align 4
-; CHECK-NEXT:    [[LENA0AP3:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 0, i64 3))
+; CHECK-NEXT:    store i64 0, i64* [[PLEN2]], align 4
 ; CHECK-NEXT:    [[PLEN3:%.*]] = getelementptr i64, i64* [[PLEN]], i64 3
-; CHECK-NEXT:    store i64 [[LENA0AP3]], i64* [[PLEN3]], align 4
-; CHECK-NEXT:    [[LENA0B:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 1, i64 0))
+; CHECK-NEXT:    store i64 0, i64* [[PLEN3]], align 4
 ; CHECK-NEXT:    [[PLEN4:%.*]] = getelementptr i64, i64* [[PLEN]], i64 4
-; CHECK-NEXT:    store i64 [[LENA0B]], i64* [[PLEN4]], align 4
-; CHECK-NEXT:    [[LENA0BP1:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 1, i64 1))
+; CHECK-NEXT:    store i64 2, i64* [[PLEN4]], align 4
 ; CHECK-NEXT:    [[PLEN5:%.*]] = getelementptr i64, i64* [[PLEN]], i64 5
-; CHECK-NEXT:    store i64 [[LENA0BP1]], i64* [[PLEN5]], align 4
-; CHECK-NEXT:    [[LENA0BP2:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 1, i64 2))
+; CHECK-NEXT:    store i64 1, i64* [[PLEN5]], align 4
 ; CHECK-NEXT:    [[PLEN6:%.*]] = getelementptr i64, i64* [[PLEN]], i64 6
-; CHECK-NEXT:    store i64 [[LENA0BP2]], i64* [[PLEN6]], align 4
-; CHECK-NEXT:    [[LENA0BP3:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 1, i64 3))
+; CHECK-NEXT:    store i64 0, i64* [[PLEN6]], align 4
 ; CHECK-NEXT:    [[PLEN7:%.*]] = getelementptr i64, i64* [[PLEN]], i64 7
-; CHECK-NEXT:    store i64 [[LENA0BP3]], i64* [[PLEN7]], align 4
-; CHECK-NEXT:    [[LENA0BP4:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 1, i64 4))
+; CHECK-NEXT:    store i64 0, i64* [[PLEN7]], align 4
 ; CHECK-NEXT:    [[PLEN8:%.*]] = getelementptr i64, i64* [[PLEN]], i64 8
-; CHECK-NEXT:    store i64 [[LENA0BP4]], i64* [[PLEN8]], align 4
-; CHECK-NEXT:    [[LENA1A:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 0, i64 0))
+; CHECK-NEXT:    store i64 0, i64* [[PLEN8]], align 4
 ; CHECK-NEXT:    [[PLEN9:%.*]] = getelementptr i64, i64* [[PLEN]], i64 9
-; CHECK-NEXT:    store i64 [[LENA1A]], i64* [[PLEN9]], align 4
-; CHECK-NEXT:    [[LENA1AP1:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 0, i64 1))
+; CHECK-NEXT:    store i64 3, i64* [[PLEN9]], align 4
 ; CHECK-NEXT:    [[PLEN10:%.*]] = getelementptr i64, i64* [[PLEN]], i64 10
-; CHECK-NEXT:    store i64 [[LENA1AP1]], i64* [[PLEN10]], align 4
-; CHECK-NEXT:    [[LENA1AP2:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 0, i64 2))
+; CHECK-NEXT:    store i64 2, i64* [[PLEN10]], align 4
 ; CHECK-NEXT:    [[PLEN11:%.*]] = getelementptr i64, i64* [[PLEN]], i64 11
-; CHECK-NEXT:    store i64 [[LENA1AP2]], i64* [[PLEN11]], align 4
-; CHECK-NEXT:    [[LENA1AP3:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 0, i64 3))
+; CHECK-NEXT:    store i64 1, i64* [[PLEN11]], align 4
 ; CHECK-NEXT:    [[PLEN12:%.*]] = getelementptr i64, i64* [[PLEN]], i64 12
-; CHECK-NEXT:    store i64 [[LENA1AP3]], i64* [[PLEN12]], align 4
-; CHECK-NEXT:    [[LENA1B:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 1, i64 0))
+; CHECK-NEXT:    store i64 0, i64* [[PLEN12]], align 4
 ; CHECK-NEXT:    [[PLEN14:%.*]] = getelementptr i64, i64* [[PLEN]], i64 14
-; CHECK-NEXT:    store i64 [[LENA1B]], i64* [[PLEN14]], align 4
-; CHECK-NEXT:    [[LENA1BP1:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 1, i64 1))
+; CHECK-NEXT:    store i64 4, i64* [[PLEN14]], align 4
 ; CHECK-NEXT:    [[PLEN15:%.*]] = getelementptr i64, i64* [[PLEN]], i64 15
-; CHECK-NEXT:    store i64 [[LENA1BP1]], i64* [[PLEN15]], align 4
-; CHECK-NEXT:    [[LENA1BP2:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 1, i64 2))
+; CHECK-NEXT:    store i64 3, i64* [[PLEN15]], align 4
 ; CHECK-NEXT:    [[PLEN16:%.*]] = getelementptr i64, i64* [[PLEN]], i64 16
-; CHECK-NEXT:    store i64 [[LENA1BP2]], i64* [[PLEN16]], align 4
-; CHECK-NEXT:    [[LENA1BP3:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 1, i64 3))
+; CHECK-NEXT:    store i64 2, i64* [[PLEN16]], align 4
 ; CHECK-NEXT:    [[PLEN17:%.*]] = getelementptr i64, i64* [[PLEN]], i64 17
-; CHECK-NEXT:    store i64 [[LENA1BP3]], i64* [[PLEN17]], align 4
-; CHECK-NEXT:    [[LENA1BP4:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 1, i32 1, i64 4))
+; CHECK-NEXT:    store i64 1, i64* [[PLEN17]], align 4
 ; CHECK-NEXT:    [[PLEN18:%.*]] = getelementptr i64, i64* [[PLEN]], i64 18
-; CHECK-NEXT:    store i64 [[LENA1BP4]], i64* [[PLEN18]], align 4
+; CHECK-NEXT:    store i64 0, i64* [[PLEN18]], align 4
 ; CHECK-NEXT:    ret void
 ;
 ; Fold strlen(a[0].a) to 1.
   %pa0a = getelementptr [2 x %struct.A], [2 x %struct.A]* @a, i64 0, i64 0, i32 0, i64 0
   %lena0a = call i64 @strlen(i8* %pa0a)
   %plen0 = getelementptr i64, i64* %plen, i32 0
   store i64 %lena0a, i64* %plen0
 

llvm/test/Transforms/InstCombine/strlen-8.ll

 ; CHECK-NEXT:    ret i64 [[LEN]]
 ;
   %ptr = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 1, i64 %I
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(&a5_4[2][I]) to i <= 1 ? 1 - I : 0.
 
 define i64 @fold_a5_4_i2_pI(i64 %I) {
 ; CHECK-LABEL: @fold_a5_4_i2_pI(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 2, i64 1))
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 0
 ;
   %ptr = getelementptr [5 x [4 x i8]], [5 x [4 x i8]]* @a5_4, i64 0, i64 2, i64 1
   %len = call i64 @strlen(i8* %ptr)
   ret i64 %len
 }
 
 
 ; Fold strlen(&a5_4[3][I]) to 0.

llvm/test/Transforms/InstCombine/strncmp-4.ll

 
 declare i32 @strncmp(i8*, i8*, i64)
 
 define void @fold_strncmp_Aa_b(i32* %pcmp) {
 ; CHECK-LABEL: @fold_strncmp_Aa_b(
 ; CHECK-NEXT:    store i32 0, i32* [[PCMP:%.*]], align 4
 ; CHECK-NEXT:    [[PCMP1:%.*]] = getelementptr i32, i32* [[PCMP]], i64 1
 ; CHECK-NEXT:    store i32 0, i32* [[PCMP1]], align 4
-; CHECK-NEXT:    [[CMP2:%.*]] = call i32 @strncmp(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A:%.*]], %struct.A* @a, i64 0, i32 0, i64 0), i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A]], %struct.A* @a, i64 0, i32 1, i64 0), i64 2)
 ; CHECK-NEXT:    [[PCMP2:%.*]] = getelementptr i32, i32* [[PCMP]], i64 2
-; CHECK-NEXT:    store i32 [[CMP2]], i32* [[PCMP2]], align 4
-; CHECK-NEXT:    [[CMP3:%.*]] = call i32 @strncmp(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A]], %struct.A* @a, i64 0, i32 0, i64 0), i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A]], %struct.A* @a, i64 0, i32 1, i64 0), i64 3)
+; CHECK-NEXT:    store i32 0, i32* [[PCMP2]], align 4
 ; CHECK-NEXT:    [[PCMP3:%.*]] = getelementptr i32, i32* [[PCMP]], i64 3
-; CHECK-NEXT:    store i32 [[CMP3]], i32* [[PCMP3]], align 4
-; CHECK-NEXT:    [[CMP4:%.*]] = call i32 @strncmp(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A]], %struct.A* @a, i64 0, i32 0, i64 0), i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A]], %struct.A* @a, i64 0, i32 1, i64 0), i64 4)
+; CHECK-NEXT:    store i32 0, i32* [[PCMP3]], align 4
 ; CHECK-NEXT:    [[PCMP4:%.*]] = getelementptr i32, i32* [[PCMP]], i64 4
-; CHECK-NEXT:    store i32 [[CMP4]], i32* [[PCMP4]], align 4
-; CHECK-NEXT:    [[CMP5:%.*]] = call i32 @strncmp(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A]], %struct.A* @a, i64 0, i32 0, i64 0), i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A]], %struct.A* @a, i64 0, i32 1, i64 0), i64 5)
+; CHECK-NEXT:    store i32 0, i32* [[PCMP4]], align 4
 ; CHECK-NEXT:    [[PCMP5:%.*]] = getelementptr i32, i32* [[PCMP]], i64 5
-; CHECK-NEXT:    store i32 [[CMP5]], i32* [[PCMP5]], align 4
-; CHECK-NEXT:    [[CMP6:%.*]] = call i32 @strncmp(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A]], %struct.A* @a, i64 0, i32 0, i64 0), i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A]], %struct.A* @a, i64 0, i32 1, i64 0), i64 6)
+; CHECK-NEXT:    store i32 0, i32* [[PCMP5]], align 4
 ; CHECK-NEXT:    [[PCMP6:%.*]] = getelementptr i32, i32* [[PCMP]], i64 6
-; CHECK-NEXT:    store i32 [[CMP6]], i32* [[PCMP6]], align 4
-; CHECK-NEXT:    [[CMP7:%.*]] = call i32 @strncmp(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A]], %struct.A* @a, i64 0, i32 0, i64 0), i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A]], %struct.A* @a, i64 0, i32 1, i64 0), i64 7)
+; CHECK-NEXT:    store i32 0, i32* [[PCMP6]], align 4
 ; CHECK-NEXT:    [[PCMP7:%.*]] = getelementptr i32, i32* [[PCMP]], i64 7
-; CHECK-NEXT:    store i32 [[CMP7]], i32* [[PCMP7]], align 4
-; CHECK-NEXT:    [[CMP8:%.*]] = call i32 @strncmp(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A]], %struct.A* @a, i64 0, i32 0, i64 0), i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A]], %struct.A* @a, i64 0, i32 1, i64 0), i64 8)
+; CHECK-NEXT:    store i32 -1, i32* [[PCMP7]], align 4
 ; CHECK-NEXT:    [[PCMP8:%.*]] = getelementptr i32, i32* [[PCMP]], i64 8
-; CHECK-NEXT:    store i32 [[CMP8]], i32* [[PCMP8]], align 4
-; CHECK-NEXT:    [[CMP9:%.*]] = call i32 @strncmp(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A]], %struct.A* @a, i64 0, i32 0, i64 0), i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A]], %struct.A* @a, i64 0, i32 1, i64 0), i64 9)
+; CHECK-NEXT:    store i32 -1, i32* [[PCMP8]], align 4
 ; CHECK-NEXT:    [[PCMP9:%.*]] = getelementptr i32, i32* [[PCMP]], i64 9
-; CHECK-NEXT:    store i32 [[CMP9]], i32* [[PCMP9]], align 4
+; CHECK-NEXT:    store i32 -1, i32* [[PCMP9]], align 4
 ; CHECK-NEXT:    ret void
 ;
 ; p1 = a.a
   %p1 = getelementptr %struct.A, %struct.A* @a, i32 0, i32 0, i32 0
 ; p2 = a.b
   %p2 = getelementptr %struct.A, %struct.A* @a, i32 0, i32 1, i32 0
 
 ; Fold strncmp(a.a = "123", a.b = "1231", 0) to 0.

 }
 
 
 define void @fold_strncmp_Ab_a(i32* %pcmp) {
 ; CHECK-LABEL: @fold_strncmp_Ab_a(
 ; CHECK-NEXT:    store i32 0, i32* [[PCMP:%.*]], align 4
 ; CHECK-NEXT:    [[PCMP1:%.*]] = getelementptr i32, i32* [[PCMP]], i64 1
 ; CHECK-NEXT:    store i32 0, i32* [[PCMP1]], align 4
-; CHECK-NEXT:    [[CMP2:%.*]] = call i32 @strncmp(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A:%.*]], %struct.A* @a, i64 0, i32 1, i64 3), i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A]], %struct.A* @a, i64 0, i32 0, i64 0), i64 2)
 ; CHECK-NEXT:    [[PCMP2:%.*]] = getelementptr i32, i32* [[PCMP]], i64 2
-; CHECK-NEXT:    store i32 [[CMP2]], i32* [[PCMP2]], align 4
-; CHECK-NEXT:    [[CMP3:%.*]] = call i32 @strncmp(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A]], %struct.A* @a, i64 0, i32 1, i64 3), i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A]], %struct.A* @a, i64 0, i32 0, i64 0), i64 3)
+; CHECK-NEXT:    store i32 0, i32* [[PCMP2]], align 4
 ; CHECK-NEXT:    [[PCMP3:%.*]] = getelementptr i32, i32* [[PCMP]], i64 3
-; CHECK-NEXT:    store i32 [[CMP3]], i32* [[PCMP3]], align 4
-; CHECK-NEXT:    [[CMP4:%.*]] = call i32 @strncmp(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A]], %struct.A* @a, i64 0, i32 1, i64 3), i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A]], %struct.A* @a, i64 0, i32 0, i64 0), i64 4)
+; CHECK-NEXT:    store i32 0, i32* [[PCMP3]], align 4
 ; CHECK-NEXT:    [[PCMP4:%.*]] = getelementptr i32, i32* [[PCMP]], i64 4
-; CHECK-NEXT:    store i32 [[CMP4]], i32* [[PCMP4]], align 4
-; CHECK-NEXT:    [[CMP5:%.*]] = call i32 @strncmp(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A]], %struct.A* @a, i64 0, i32 1, i64 3), i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([[STRUCT_A]], %struct.A* @a, i64 0, i32 0, i64 0), i64 5)
+; CHECK-NEXT:    store i32 1, i32* [[PCMP4]], align 4
 ; CHECK-NEXT:    [[PCMP5:%.*]] = getelementptr i32, i32* [[PCMP]], i64 5
-; CHECK-NEXT:    store i32 [[CMP5]], i32* [[PCMP5]], align 4
+; CHECK-NEXT:    store i32 1, i32* [[PCMP5]], align 4
 ; CHECK-NEXT:    ret void
 ;
 ; p1 = &a.b[3]
   %p1 = getelementptr %struct.A, %struct.A* @a, i32 0, i32 1, i32 3
 ; p2 = &a.a
   %p2 = getelementptr %struct.A, %struct.A* @a, i32 0, i32 0, i32 0
 
 ; Fold strncmp(a.a = "123", &a.b[3] = "1" "2345", 0) to 0.

llvm/test/Transforms/InstCombine/wcslen-3.ll

;
   %hello_p = getelementptr [6 x i16], [6 x i16]* @hello, i64 0, i64 0
   %hello_l = call i64 @wcslen(i16* %hello_p)
   %eq_hello = icmp eq i64 %hello_l, 0
   ret i1 %eq_hello
 }
 
 define i1 @test_simplify6(i16* %str_p) {
 ; CHECK-LABEL: @test_simplify6(
-; CHECK-NEXT:    [[STRLENFIRST:%.*]] = load i16, i16* [[STR_P:%.*]], align 2
-; CHECK-NEXT:    [[EQ_NULL:%.*]] = icmp eq i16 [[STRLENFIRST]], 0
+; CHECK-NEXT:    [[CHAR0:%.*]] = load i16, i16* [[STR_P:%.*]], align 2
+; CHECK-NEXT:    [[EQ_NULL:%.*]] = icmp eq i16 [[CHAR0]], 0
 ; CHECK-NEXT:    ret i1 [[EQ_NULL]]
 ;
   %str_l = call i64 @wcslen(i16* %str_p)
   %eq_null = icmp eq i64 %str_l, 0
   ret i1 %eq_null
 }
 
 ; Check wcslen(x) != 0 --> *x != 0.
 
 define i1 @test_simplify7() {
 ; CHECK-LABEL: @test_simplify7(
 ; CHECK-NEXT:    ret i1 true
 ;
   %hello_p = getelementptr [6 x i16], [6 x i16]* @hello, i64 0, i64 0
   %hello_l = call i64 @wcslen(i16* %hello_p)
   %ne_hello = icmp ne i64 %hello_l, 0
   ret i1 %ne_hello
 }
 
 define i1 @test_simplify8(i16* %str_p) {
 ; CHECK-LABEL: @test_simplify8(
-; CHECK-NEXT:    [[STRLENFIRST:%.*]] = load i16, i16* [[STR_P:%.*]], align 2
-; CHECK-NEXT:    [[NE_NULL:%.*]] = icmp ne i16 [[STRLENFIRST]], 0
+; CHECK-NEXT:    [[CHAR0:%.*]] = load i16, i16* [[STR_P:%.*]], align 2
+; CHECK-NEXT:    [[NE_NULL:%.*]] = icmp ne i16 [[CHAR0]], 0
 ; CHECK-NEXT:    ret i1 [[NE_NULL]]
 ;
   %str_l = call i64 @wcslen(i16* %str_p)
   %ne_null = icmp ne i64 %str_l, 0
   ret i1 %ne_null
 }
 
 define i64 @test_simplify9(i1 %x) {
;
   %and = and i16 %x, 15
   %hello_p = getelementptr inbounds [13 x i16], [13 x i16]* @null_hello_mid, i16 0, i16 %and
   %hello_l = call i64 @wcslen(i16* %hello_p)
   ret i64 %hello_l
 }
 
 @str32 = constant [1 x i32] [i32 0]
 
-; This could in principle be simplified, but the current implementation bails on
-; type mismatches.
+; This is safe to simplify despite the type mismatch.
+
 define i64 @test_no_simplify4() {
 ; CHECK-LABEL: @test_no_simplify4(
-; CHECK-NEXT:    [[L:%.*]] = call i64 @wcslen(i16* bitcast ([1 x i32]* @str32 to i16*))
-; CHECK-NEXT:    ret i64 [[L]]
+; CHECK-NEXT:    ret i64 0
 ;
   %l = call i64 @wcslen(i16* bitcast ([1 x i32]* @str32 to i16*))
   ret i64 %l
 }

llvm/test/Transforms/InstCombine/wcslen-6.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+;
+; Verify that wcslen calls with a constant argument of a nonintegral type
+; of the same size as wchar_t or bigger doesn't cause trouble and is folded
+; as expected.
+;
+; RUN: opt < %s -passes=instcombine -S | FileCheck %s
+
+!llvm.module.flags = !{!0}
+!0 = !{i32 1, !"wchar_size", i32 4}
+
+declare i64 @wcslen(ptr)
+
+@af = constant [2 x float] [float 0x3FF3B2FEC0000000, float 0.0]
+
+; TODO: Fold wcslen(af) to a constant.
+
+define i64 @fold_af() {
+; CHECK-LABEL: @fold_af(
+; CHECK-NEXT:    [[N:%.*]] = call i64 @wcslen(ptr nonnull @af)
+; CHECK-NEXT:    ret i64 [[N]]
+;
+  %n = call i64 @wcslen(ptr @af)
+  ret i64 %n
+}
+
+; TODO: Likewise, fold wcslen(as) to a constant.
+
+%struct.S = type { i32 }
+@aS = constant [3 x %struct.S] [%struct.S { i32 2 }, %struct.S { i32 1 }, %struct.S zeroinitializer]
+
+define i64 @fold_aS() {
+; CHECK-LABEL: @fold_aS(
+; CHECK-NEXT:    [[N:%.*]] = call i64 @wcslen(ptr nonnull @aS)
+; CHECK-NEXT:    ret i64 [[N]]
+;
+  %n = call i64 @wcslen(ptr @aS)
+  ret i64 %n
+}