This is an archive of the discontinued LLVM Phabricator instance.

Differential D127443

[InstCombine] add zeroinitializer handling to memchr folders
Needs ReviewPublic

Authored by msebor on Jun 9 2022, 2:29 PM.

Details

Reviewers
MatzeB
nikic
xbolva00
bkramer
efriedma
Summary

Due to a limitation of the getConstantStringInfo function the memchr and memrchr folders are unable to fold calls with zeroinitialzer constant arrays. These are rare as global top-level objects but likely more common as members of other aggregates, the handling of which has been proposed in D125114. In anticipation of that enhancement this patch removes the getConstantStringInfo limitation and enables two of its clients, the memchr and memrchr handlers, to fold calls with zeroinitialzer constants. It adds a TODO comment to enhance the third client (memccpy).

The getConstantStringInfo change replaces the TrimAtNull input argument with an in-out ZeroInit argument. This preserves the common default mode of trimming the string at the first null byte while at the same time providing a way for the remaining clients to work with zeroinitializer constants larger than a single byte.

Diff Detail

Event Timeline

msebor created this revision.Jun 9 2022, 2:29 PM
Herald added a project: Restricted Project. · View Herald TranscriptJun 9 2022, 2:29 PM
Herald added a subscriber: hiraditya. · View Herald Transcript
msebor requested review of this revision.Jun 9 2022, 2:29 PM
Herald added a project: Restricted Project. · View Herald TranscriptJun 9 2022, 2:29 PM
Herald added a subscriber: llvm-commits. · View Herald Transcript
msebor edited the summary of this revision. (Show Details)Jun 9 2022, 3:02 PM
msebor added reviewers: MatzeB, nikic, xbolva00, bkramer.Jun 9 2022, 3:05 PM
Harbormaster completed remote builds in B168917: Diff 435682.Jun 9 2022, 3:42 PM
nikic added a comment.Jun 15 2022, 7:44 AM

The resulting API here seems pretty unfortunate, because the zeroinitializer case needs to be handled separately from the rest. I also find the fact that passing in ZeroInit changes the interpretation of null bytes somewhat unintuitive.

I think a cleaner alternative would be to accept an additional std::string *Storage = nullptr parameter, which gets populated with the zero-filled string, and can then be handled as a StringRef in the same way as all the other cases.

nikic mentioned this in D127766: [InstCombine] Fold memcmp of constant arrays and variable size.Jun 16 2022, 1:02 AM
msebor added a comment.Jun 17 2022, 11:43 AM

Neither API is ideal: both require the client to handle the zeroinitializer specially to some extent. The difference is that one approach is optimally efficient at the cost of more code, while the other allows for more uniform handling at the cost of inefficiency (memory allocation and linear traversal over all zeros). Both are trade-offs, and although I don't feel strongly enough to insist on it, in D125114 we discussed a similar concern and agreed to work toward a more efficient solution there in the future. I have a similar preference for this change. If it turns out that the uniform handling is more important than optimal efficiency the API can easily be changed.

msebor added a comment.Jun 23 2022, 4:33 PM

Ping: @nikic, do you have any further comments?

nikic added a reviewer: efriedma.Jun 24 2022, 2:18 AM

I'm still not a fan of this API. You already don't implement the necessary special handling for memccpy, and in the meantime we have gained additional uses of TrimAtNul for memcmp and soon strncmp. All of these will need special code to handle the zeroinitializer case. I don't think the ability to handle unrealistically large [2147483647 x i8] zeroinitializer style constants is important enough to warrant the additional complexity.

Revision Contents

PathSize
llvm/
include/
llvm/
Analysis/
14 lines
lib/
Analysis/
27 lines
Transforms/
Utils/
48 lines
test/
Transforms/
InstCombine/
8 lines
211 lines
180 lines

Diff 435682

llvm/include/llvm/Analysis/ValueTracking.h

Show First 20 Lines • Show All 323 Lines • ▼ Show 20 Linesconstexpr unsigned MaxAnalysisRecursionDepth = 6;
}; };
/// Returns true if the value \p V is a pointer into a ConstantDataArray. /// Returns true if the value \p V is a pointer into a ConstantDataArray.
/// If successful \p Slice will point to a ConstantDataArray info object /// If successful \p Slice will point to a ConstantDataArray info object
/// with an appropriate offset. /// with an appropriate offset.
bool getConstantDataArrayInfo(const Value *V, ConstantDataArraySlice &Slice, bool getConstantDataArrayInfo(const Value *V, ConstantDataArraySlice &Slice,
unsigned ElementSize, uint64_t Offset = 0); unsigned ElementSize, uint64_t Offset = 0);
/// This function computes the length of a null-terminated C string pointed to /// Computes the length of a null-terminated C string pointed to by V at
/// by V. If successful, it returns true and returns the string in Str. If /// Offset. On success returns true and sets Str to the string, otherwise
/// unsuccessful, it returns false. This does not include the trailing null /// returns false. If ZeroInit is null, Str ends just before the first null
/// character by default. If TrimAtNul is set to false, then this returns any /// byte. Otherwise, Str includes any interior as well as trailing null
/// trailing null characters as well as any other characters that come after /// bytes; if the string corresponds to a zeroinitializer *ZeroInit is set
/// it. /// to true and Str is set to empty.
bool getConstantStringInfo(const Value *V, StringRef &Str, bool getConstantStringInfo(const Value *V, StringRef &Str,
uint64_t Offset = 0, bool TrimAtNul = true); uint64_t Offset = 0, bool *ZeroInit = nullptr);
/// If we can compute the length of the string pointed to by the specified /// If we can compute the length of the string pointed to by the specified
/// pointer, return 'len+1'. If we can't, return 0. /// pointer, return 'len+1'. If we can't, return 0.
uint64_t GetStringLength(const Value *V, unsigned CharSize = 8); uint64_t GetStringLength(const Value *V, unsigned CharSize = 8);
/// This function returns call pointer argument that is considered the same by /// This function returns call pointer argument that is considered the same by
/// aliasing rules. You CAN'T use it to replace one value with another. If /// aliasing rules. You CAN'T use it to replace one value with another. If
/// \p MustPreserveNullness is true, the call must preserve the nullness of /// \p MustPreserveNullness is true, the call must preserve the nullness of
▲ Show 20 Lines • Show All 520 Lines • Show Last 20 Lines

llvm/lib/Analysis/ValueTracking.cpp

Show First 20 Lines • Show All 991 Lines • ▼ Show 20 Lines
return false; return false;
Slice.Array = Array; Slice.Array = Array;
Slice.Offset = Offset; Slice.Offset = Offset;
Slice.Length = NumElts - Offset; Slice.Length = NumElts - Offset;
return true; return true;
} }
/// This function computes the length of a null-terminated C string pointed to /// Computes the length of a null-terminated C string pointed to by V at
/// by V. If successful, it returns true and returns the string in Str. /// Offset. On success returns true and sets Str to the string, otherwise
/// If unsuccessful, it returns false. /// returns false. If ZeroInit is null, Str ends just before the first null
/// byte. Otherwise, Str includes any interior as well as trailing null
/// bytes; if the string corresponds to a zeroinitializer *ZeroInit is set
/// to true and Str is set to empty.
bool llvm::getConstantStringInfo(const Value *V, StringRef &Str, bool llvm::getConstantStringInfo(const Value *V, StringRef &Str,
uint64_t Offset, bool TrimAtNul) { uint64_t Offset, bool *ZeroInit) {
ConstantDataArraySlice Slice; ConstantDataArraySlice Slice;
if (!getConstantDataArrayInfo(V, Slice, 8, Offset)) if (!getConstantDataArrayInfo(V, Slice, 8, Offset))
return false; return false;
if (Slice.Array == nullptr) { if (Slice.Array == nullptr) {
if (TrimAtNul) { if (ZeroInit)
*ZeroInit = true;
else {
Str = StringRef(); Str = StringRef();
return true; return true;
} }
if (Slice.Length == 1) { if (Slice.Length == 1) {
// TODO: Increase this to some reasonably small number.
Str = StringRef("", 1); Str = StringRef("", 1);
return true; return true;
} }
// We cannot instantiate a StringRef as we do not have an appropriate string
// of 0s at hand. // We cannot create an arbitrarily large StringRef as we do not have
return false; // an appropriate string of 0s at hand.
return ZeroInit != nullptr;
} }
// Start out with the entire array in the StringRef. // Start out with the entire array in the StringRef.
Str = Slice.Array->getAsString(); Str = Slice.Array->getAsString();
// Skip over 'offset' bytes. // Skip over 'offset' bytes.
Str = Str.substr(Slice.Offset); Str = Str.substr(Slice.Offset);
if (TrimAtNul) { if (ZeroInit)
*ZeroInit = false;
else {
// Trim off the \0 and anything after it. If the array is not nul // Trim off the \0 and anything after it. If the array is not nul
// terminated, we just return the whole end of string. The client may know // terminated, we just return the whole end of string. The client may know
// some other way that the string is length-bound. // some other way that the string is length-bound.
Str = Str.substr(0, Str.find('\0')); Str = Str.substr(0, Str.find('\0'));
} }
return true; return true;
} }
▲ Show 20 Lines • Show All 991 Lines • Show Last 20 Lines

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

Show First 20 Lines • Show All 200 Lines • ▼ Show 20 Linesstatic Value *copyFlags(const CallInst &Old, Value *New) {
return New; return New;
} }
// Helper to avoid truncating the length if size_t is 32-bits. // Helper to avoid truncating the length if size_t is 32-bits.
static StringRef substr(StringRef Str, uint64_t Len) { static StringRef substr(StringRef Str, uint64_t Len) {
return Len >= Str.size() ? Str : Str.substr(0, Len); return Len >= Str.size() ? Str : Str.substr(0, Len);
} }
// Helper used by optimizeMemchr and optimizeMemRChr. When Reverse is
// true return the IR corresponding to
// Size && (char)CharVal == '\0' ? Src + Size : Null
// otherwise
// Size && (char)CharVal == '\0' ? Src : Null
static Value *createSelectFromZeroInit(CallInst *CI, Value *ZeroInit,
Value *CharVal, Value *Size,
bool Reverse, IRBuilderBase &B,
const char *Name) {
Type *Int8Ty = B.getInt8Ty();
Type *SizeTy = Size->getType();
CharVal = B.CreateTrunc(CharVal, B.getInt8Ty());
Value *NullPtr = Constant::getNullValue(CI->getType());
Value *CEqZ = B.CreateICmpEQ(CharVal, ConstantInt::get(Int8Ty, 0));
Value *NNeZ = B.CreateICmpNE(Size, ConstantInt::get(SizeTy, 0));
Value *And = B.CreateLogicalAnd(NNeZ, CEqZ);
if (Reverse) {
Value *SizeM1 = B.CreateSub(Size, ConstantInt::get(SizeTy, 1));
Value *InitLast = B.CreateGEP(B.getInt8Ty(), ZeroInit, SizeM1);
return B.CreateSelect(And, InitLast, NullPtr, Name);
}
return B.CreateSelect(And, ZeroInit, NullPtr, Name);
}
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// String and Memory Library Call Optimizations // String and Memory Library Call Optimizations
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Value *LibCallSimplifier::optimizeStrCat(CallInst *CI, IRBuilderBase &B) { Value *LibCallSimplifier::optimizeStrCat(CallInst *CI, IRBuilderBase &B) {
// Extract some information from the instruction // Extract some information from the instruction
Value *Dst = CI->getArgOperand(0); Value *Dst = CI->getArgOperand(0);
Value *Src = CI->getArgOperand(1); Value *Src = CI->getArgOperand(1);
▲ Show 20 Lines • Show All 719 Lines • ▼ Show 20 Lines if (LenC->isOne()) {
// Slice off the character's high end bits. // Slice off the character's high end bits.
CharVal = B.CreateTrunc(CharVal, B.getInt8Ty()); CharVal = B.CreateTrunc(CharVal, B.getInt8Ty());
Value *Cmp = B.CreateICmpEQ(Val, CharVal, "memrchr.char0cmp"); Value *Cmp = B.CreateICmpEQ(Val, CharVal, "memrchr.char0cmp");
return B.CreateSelect(Cmp, SrcStr, NullPtr, "memrchr.sel"); return B.CreateSelect(Cmp, SrcStr, NullPtr, "memrchr.sel");
} }
} }
StringRef Str; StringRef Str;
if (!getConstantStringInfo(SrcStr, Str, 0, /*TrimAtNul=*/false)) bool ZeroInit;
if (!getConstantStringInfo(SrcStr, Str, 0, &ZeroInit))
return nullptr; return nullptr;
if (ZeroInit)
return createSelectFromZeroInit(CI, SrcStr, CharVal, Size, true, B,
"memrchr.sel");
uint64_t EndOff = UINT64_MAX; uint64_t EndOff = UINT64_MAX;
if (LenC) { if (LenC) {
EndOff = LenC->getZExtValue(); EndOff = LenC->getZExtValue();
if (Str.size() < EndOff) if (Str.size() < EndOff)
// Punt out-of-bounds accesses to sanitizers and/or libc. // Punt out-of-bounds accesses to sanitizers and/or libc.
return nullptr; return nullptr;
} }
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines if (LenC->isOne()) {
// Slice off the character's high end bits. // Slice off the character's high end bits.
CharVal = B.CreateTrunc(CharVal, B.getInt8Ty()); CharVal = B.CreateTrunc(CharVal, B.getInt8Ty());
Value *Cmp = B.CreateICmpEQ(Val, CharVal, "memchr.char0cmp"); Value *Cmp = B.CreateICmpEQ(Val, CharVal, "memchr.char0cmp");
return B.CreateSelect(Cmp, SrcStr, NullPtr, "memchr.sel"); return B.CreateSelect(Cmp, SrcStr, NullPtr, "memchr.sel");
} }
} }
StringRef Str; StringRef Str;
if (!getConstantStringInfo(SrcStr, Str, 0, /*TrimAtNul=*/false)) bool ZeroInit;
if (!getConstantStringInfo(SrcStr, Str, 0, &ZeroInit))
return nullptr; return nullptr;
if (ZeroInit)
return createSelectFromZeroInit(CI, SrcStr, CharVal, Size, false, B,
"memchr.sel");
if (CharC) { if (CharC) {
size_t Pos = Str.find(CharC->getZExtValue()); size_t Pos = Str.find(CharC->getZExtValue());
if (Pos == StringRef::npos) if (Pos == StringRef::npos)
// When the character is not in the source array fold the result // When the character is not in the source array fold the result
// to null regardless of Size. // to null regardless of Size.
return NullPtr; return NullPtr;
// Fold memchr(s, c, n) -> n <= Pos ? null : s + Pos // Fold memchr(s, c, n) -> n <= Pos ? null : s + Pos
▲ Show 20 Lines • Show All 249 Lines • ▼ Show 20 LinesValue *LibCallSimplifier::optimizeMemCCpy(CallInst *CI, IRBuilderBase &B) {
ConstantInt *N = dyn_cast<ConstantInt>(CI->getArgOperand(3)); ConstantInt *N = dyn_cast<ConstantInt>(CI->getArgOperand(3));
StringRef SrcStr; StringRef SrcStr;
if (CI->use_empty() && Dst == Src) if (CI->use_empty() && Dst == Src)
return Dst; return Dst;
// memccpy(d, s, c, 0) -> nullptr // memccpy(d, s, c, 0) -> nullptr
if (N) { if (N) {
if (N->isNullValue()) if (N->isNullValue())
return Constant::getNullValue(CI->getType()); return Constant::getNullValue(CI->getType());
if (!getConstantStringInfo(Src, SrcStr, /*Offset=*/0, bool ZeroInit;
/*TrimAtNul=*/false) || if (!getConstantStringInfo(Src, SrcStr, /*Offset=*/0, &ZeroInit) ||
!StopChar) // TODO: Handle zeroinitializer.
ZeroInit || !StopChar)
return nullptr; return nullptr;
} else { } else {
return nullptr; return nullptr;
} }
// Wrap arg 'c' of type int to char // Wrap arg 'c' of type int to char
size_t Pos = SrcStr.find(StopChar->getSExtValue() & 0xFF); size_t Pos = SrcStr.find(StopChar->getSExtValue() & 0xFF);
if (Pos == StringRef::npos) { if (Pos == StringRef::npos) {
▲ Show 20 Lines • Show All 991 Lines • Show Last 20 Lines

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

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -passes=instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; ;
; Verify that memchr calls with a string consisting of all the same ; Verify that memchr calls with a string consisting of all the same
; characters are folded and those with mixed strings are not. ; characters are folded and those with mixed strings are not.
declare i8* @memchr(i8*, i32, i64) declare i8* @memchr(i8*, i32, i64)
@a00000 = constant [5 x i8] zeroinitializer @a00000 = constant [5 x i8] zeroinitializer
@a11111 = constant [5 x i8] c"\01\01\01\01\01" @a11111 = constant [5 x i8] c"\01\01\01\01\01"
@a111122 = constant [6 x i8] c"\01\01\01\01\02\02" @a111122 = constant [6 x i8] c"\01\01\01\01\02\02"
@a1110111 = constant [7 x i8] c"\01\01\01\00\01\01\01" @a1110111 = constant [7 x i8] c"\01\01\01\00\01\01\01"
; Fold memchr(a00000, C, 5) to *a00000 == C ? a00000 : null. ; Fold memchr(a00000, C, 5) to *a00000 == C ? a00000 : null.
; TODO: This depends on getConstantStringInfo() being able to handle
; implicitly zeroed out constants.
define i8* @fold_memchr_a00000_c_5(i32 %C) { define i8* @fold_memchr_a00000_c_5(i32 %C) {
; CHECK-LABEL: @fold_memchr_a00000_c_5( ; CHECK-LABEL: @fold_memchr_a00000_c_5(
; CHECK-NEXT: [[RET:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @a00000, i64 0, i64 0), i32 [[C:%.*]], i64 5) ; CHECK-NEXT: [[TMP1:%.*]] = trunc i32 [[C:%.*]] to i8
; CHECK-NEXT: ret i8* [[RET]] ; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i8 [[TMP1]], 0
; CHECK-NEXT: [[MEMCHR_SEL:%.*]] = select i1 [[TMP2]], i8* getelementptr inbounds ([5 x i8], [5 x i8]* @a00000, i64 0, i64 0), i8* null
; CHECK-NEXT: ret i8* [[MEMCHR_SEL]]
; ;
%ptr = getelementptr [5 x i8], [5 x i8]* @a00000, i64 0, i64 0 %ptr = getelementptr [5 x i8], [5 x i8]* @a00000, i64 0, i64 0
%ret = call i8* @memchr(i8* %ptr, i32 %C, i64 5) %ret = call i8* @memchr(i8* %ptr, i32 %C, i64 5)
ret i8* %ret ret i8* %ret
} }
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

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

  • This file was added.
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -passes=instcombine -S | FileCheck %s
;
; Verify that memchr calls with constant zeroinitializer arrays are
; folded correctly.
declare i8* @memchr(i8*, i32, i64)
@a8 = constant [8 x i8] zeroinitializer
@ai32max = constant [2147483647 x i8] zeroinitializer
; Fold memchr(a8, 0, 1) to a8.
define i8* @fold_memchr_a8_0_1() {
; CHECK-LABEL: @fold_memchr_a8_0_1(
; CHECK-NEXT: ret i8* getelementptr inbounds ([8 x i8], [8 x i8]* @a8, i64 0, i64 0)
;
%ptr = getelementptr [8 x i8], [8 x i8]* @a8, i32 0, i32 0
%chr = tail call i8* @memchr(i8* %ptr, i32 0, i64 1)
ret i8* %chr
}
; Fold memchr(a8, 0, 8) to a8.
define i8* @fold_memchr_a8_0_8() {
; CHECK-LABEL: @fold_memchr_a8_0_8(
; CHECK-NEXT: ret i8* getelementptr inbounds ([8 x i8], [8 x i8]* @a8, i64 0, i64 0)
;
%ptr = getelementptr [8 x i8], [8 x i8]* @a8, i32 0, i32 0
%chr = tail call i8* @memchr(i8* %ptr, i32 0, i64 8)
ret i8* %chr
}
; Fold memchr(a8, 0, SIZE_MAX) to a8.
define i8* @fold_memchr_a8_0_szmax() {
; CHECK-LABEL: @fold_memchr_a8_0_szmax(
; CHECK-NEXT: ret i8* getelementptr inbounds ([8 x i8], [8 x i8]* @a8, i64 0, i64 0)
;
%ptr = getelementptr [8 x i8], [8 x i8]* @a8, i32 0, i32 0
%chr = tail call i8* @memchr(i8* %ptr, i32 0, i64 -1)
ret i8* %chr
}
; Fold memchr(a8, 0, N) to N ? a8 : null.
define i8* @fold_memchr_a8_0_N(i64 %N) {
; CHECK-LABEL: @fold_memchr_a8_0_N(
; CHECK-NEXT: [[DOTNOT:%.*]] = icmp eq i64 [[N:%.*]], 0
; CHECK-NEXT: [[MEMCHR_SEL:%.*]] = select i1 [[DOTNOT]], i8* null, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @a8, i64 0, i64 0)
; CHECK-NEXT: ret i8* [[MEMCHR_SEL]]
;
%ptr = getelementptr [8 x i8], [8 x i8]* @a8, i32 0, i32 0
%chr = tail call i8* @memchr(i8* %ptr, i32 0, i64 %N)
ret i8* %chr
}
; Fold memchr(a8, 1, 8) to null.
define i8* @fold_memchr_a8_1_8() {
; CHECK-LABEL: @fold_memchr_a8_1_8(
; CHECK-NEXT: ret i8* null
;
%ptr = getelementptr [8 x i8], [8 x i8]* @a8, i32 0, i32 0
%chr = tail call i8* @memchr(i8* %ptr, i32 1, i64 8)
ret i8* %chr
}
; Fold memchr(a8, 1, SIZE_MAX) to null.
define i8* @fold_memchr_a8_1_szmax() {
; CHECK-LABEL: @fold_memchr_a8_1_szmax(
; CHECK-NEXT: ret i8* null
;
%ptr = getelementptr [8 x i8], [8 x i8]* @a8, i32 0, i32 0
%chr = tail call i8* @memchr(i8* %ptr, i32 1, i64 -1)
ret i8* %chr
}
; Fold memchr(a8, 1, N) to null.
define i8* @fold_memchr_a8_1_N(i64 %N) {
; CHECK-LABEL: @fold_memchr_a8_1_N(
; CHECK-NEXT: ret i8* null
;
%ptr = getelementptr [8 x i8], [8 x i8]* @a8, i32 0, i32 0
%chr = tail call i8* @memchr(i8* %ptr, i32 1, i64 %N)
ret i8* %chr
}
; Fold memchr(a8, C, 8) to C == '\0' ? a8 : null.
define i8* @fold_memchr_a8_C_8(i32 %C) {
; CHECK-LABEL: @fold_memchr_a8_C_8(
; CHECK-NEXT: [[TMP1:%.*]] = trunc i32 [[C:%.*]] to i8
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i8 [[TMP1]], 0
; CHECK-NEXT: [[MEMCHR_SEL:%.*]] = select i1 [[TMP2]], i8* getelementptr inbounds ([8 x i8], [8 x i8]* @a8, i64 0, i64 0), i8* null
; CHECK-NEXT: ret i8* [[MEMCHR_SEL]]
;
%ptr = getelementptr [8 x i8], [8 x i8]* @a8, i32 0, i32 0
%chr = tail call i8* @memchr(i8* %ptr, i32 %C, i64 8)
ret i8* %chr
}
; Fold memchr(a8, C, SIZE_MAX) to C == '\0' ? a8 : null.
define i8* @fold_memchr_a8_C_szmax(i32 %C) {
; CHECK-LABEL: @fold_memchr_a8_C_szmax(
; CHECK-NEXT: [[TMP1:%.*]] = trunc i32 [[C:%.*]] to i8
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i8 [[TMP1]], 0
; CHECK-NEXT: [[MEMCHR_SEL:%.*]] = select i1 [[TMP2]], i8* getelementptr inbounds ([8 x i8], [8 x i8]* @a8, i64 0, i64 0), i8* null
; CHECK-NEXT: ret i8* [[MEMCHR_SEL]]
;
%ptr = getelementptr [8 x i8], [8 x i8]* @a8, i32 0, i32 0
%chr = tail call i8* @memchr(i8* %ptr, i32 %C, i64 -1)
ret i8* %chr
}
; Fold memchr(a8, C, N) to C == '\0' && N ? a8 : null.
define i8* @fold_memchr_a8_C_N(i32 %C, i64 %N) {
; CHECK-LABEL: @fold_memchr_a8_C_N(
; CHECK-NEXT: [[TMP1:%.*]] = trunc i32 [[C:%.*]] to i8
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i8 [[TMP1]], 0
; CHECK-NEXT: [[TMP3:%.*]] = icmp ne i64 [[N:%.*]], 0
; CHECK-NEXT: [[TMP4:%.*]] = select i1 [[TMP3]], i1 [[TMP2]], i1 false
; CHECK-NEXT: [[MEMCHR_SEL:%.*]] = select i1 [[TMP4]], i8* getelementptr inbounds ([8 x i8], [8 x i8]* @a8, i64 0, i64 0), i8* null
; CHECK-NEXT: ret i8* [[MEMCHR_SEL]]
;
%ptr = getelementptr [8 x i8], [8 x i8]* @a8, i32 0, i32 0
%chr = tail call i8* @memchr(i8* %ptr, i32 %C, i64 %N)
ret i8* %chr
}
; Fold memchr(ai32max, 0, INT32_MAX) to a8.
define i8* @fold_memchr_ai32max_0_i32max() {
; CHECK-LABEL: @fold_memchr_ai32max_0_i32max(
; CHECK-NEXT: ret i8* getelementptr inbounds ([2147483647 x i8], [2147483647 x i8]* @ai32max, i64 0, i64 0)
;
%ptr = getelementptr [2147483647 x i8], [2147483647 x i8]* @ai32max, i32 0, i32 0
%chr = tail call i8* @memchr(i8* %ptr, i32 0, i64 2147483647)
ret i8* %chr
}
; Fold memchr(ai32max, 1, INT32_MAX) to null.
define i8* @fold_memchr_ai32max_1_i32max() {
; CHECK-LABEL: @fold_memchr_ai32max_1_i32max(
; CHECK-NEXT: ret i8* null
;
%ptr = getelementptr [2147483647 x i8], [2147483647 x i8]* @ai32max, i32 0, i32 0
%chr = tail call i8* @memchr(i8* %ptr, i32 1, i64 2147483647)
ret i8* %chr
}
; Fold memchr(ai32max, 256, INT32_MAX) to ai32max.
define i8* @fold_memchr_ai32max_256_i32max() {
; CHECK-LABEL: @fold_memchr_ai32max_256_i32max(
; CHECK-NEXT: ret i8* getelementptr inbounds ([2147483647 x i8], [2147483647 x i8]* @ai32max, i64 0, i64 0)
;
%ptr = getelementptr [2147483647 x i8], [2147483647 x i8]* @ai32max, i32 0, i32 0
%chr = tail call i8* @memchr(i8* %ptr, i32 256, i64 2147483647)
ret i8* %chr
}
; Fold memchr(ai32max, 257, INT32_MAX) to null.
define i8* @fold_memchr_ai32max_257_i32max() {
; CHECK-LABEL: @fold_memchr_ai32max_257_i32max(
; CHECK-NEXT: ret i8* null
;
%ptr = getelementptr [2147483647 x i8], [2147483647 x i8]* @ai32max, i32 0, i32 0
%chr = tail call i8* @memchr(i8* %ptr, i32 257, i64 2147483647)
ret i8* %chr
}
; Fold memchr(ai32max, C, INT32_MAX) to C == '\0' ? ai32max : null.
define i8* @fold_memchr_ai32max_C_i32max(i32 %C) {
; CHECK-LABEL: @fold_memchr_ai32max_C_i32max(
; CHECK-NEXT: [[TMP1:%.*]] = trunc i32 [[C:%.*]] to i8
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i8 [[TMP1]], 0
; CHECK-NEXT: [[MEMCHR_SEL:%.*]] = select i1 [[TMP2]], i8* getelementptr inbounds ([2147483647 x i8], [2147483647 x i8]* @ai32max, i64 0, i64 0), i8* null
; CHECK-NEXT: ret i8* [[MEMCHR_SEL]]
;
%ptr = getelementptr [2147483647 x i8], [2147483647 x i8]* @ai32max, i32 0, i32 0
%chr = tail call i8* @memchr(i8* %ptr, i32 %C, i64 2147483647)
ret i8* %chr
}
; Fold memchr(ai32max, C, N) to C == '\0' && N ? ai32max : null.
define i8* @fold_memchr_ai32max_C_N(i32 %C, i64 %N) {
; CHECK-LABEL: @fold_memchr_ai32max_C_N(
; CHECK-NEXT: [[TMP1:%.*]] = trunc i32 [[C:%.*]] to i8
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i8 [[TMP1]], 0
; CHECK-NEXT: [[TMP3:%.*]] = icmp ne i64 [[N:%.*]], 0
; CHECK-NEXT: [[TMP4:%.*]] = select i1 [[TMP3]], i1 [[TMP2]], i1 false
; CHECK-NEXT: [[MEMCHR_SEL:%.*]] = select i1 [[TMP4]], i8* getelementptr inbounds ([2147483647 x i8], [2147483647 x i8]* @ai32max, i64 0, i64 0), i8* null
; CHECK-NEXT: ret i8* [[MEMCHR_SEL]]
;
%ptr = getelementptr [2147483647 x i8], [2147483647 x i8]* @ai32max, i32 0, i32 0
%chr = tail call i8* @memchr(i8* %ptr, i32 %C, i64 %N)
ret i8* %chr
}

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

  • This file was added.
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -passes=instcombine -S | FileCheck %s
;
; Verify that memrchr calls with constant zeroinitializer arrays are
; folded correctly.
declare i8* @memrchr(i8*, i32, i64)
@a8 = constant [8 x i8] zeroinitializer
@ai32max = constant [2147483647 x i8] zeroinitializer
; Fold memrchr(a8, 0, 1) to a8.
define i8* @fold_memrchr_a8_0_1() {
; CHECK-LABEL: @fold_memrchr_a8_0_1(
; CHECK-NEXT: ret i8* getelementptr inbounds ([8 x i8], [8 x i8]* @a8, i64 0, i64 0)
;
%ptr = getelementptr [8 x i8], [8 x i8]* @a8, i32 0, i32 0
%chr = tail call i8* @memrchr(i8* %ptr, i32 0, i64 1)
ret i8* %chr
}
; Fold memrchr(a8, 0, 8) to a8 + 7.
define i8* @fold_memrchr_a8_0_8() {
; CHECK-LABEL: @fold_memrchr_a8_0_8(
; CHECK-NEXT: ret i8* getelementptr inbounds ([8 x i8], [8 x i8]* @a8, i64 0, i64 7)
;
%ptr = getelementptr [8 x i8], [8 x i8]* @a8, i32 0, i32 0
%chr = tail call i8* @memrchr(i8* %ptr, i32 0, i64 8)
ret i8* %chr
}
; Fold memrchr(a8, 0, N) to N ? a8 + N - 1 : null.
define i8* @fold_memrchr_a8_0_N(i64 %N) {
; CHECK-LABEL: @fold_memrchr_a8_0_N(
; CHECK-NEXT: [[DOTNOT:%.*]] = icmp eq i64 [[N:%.*]], 0
; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[N]], -1
; CHECK-NEXT: [[TMP2:%.*]] = getelementptr [8 x i8], [8 x i8]* @a8, i64 0, i64 [[TMP1]]
; CHECK-NEXT: [[MEMRCHR_SEL:%.*]] = select i1 [[DOTNOT]], i8* null, i8* [[TMP2]]
; CHECK-NEXT: ret i8* [[MEMRCHR_SEL]]
;
%ptr = getelementptr [8 x i8], [8 x i8]* @a8, i32 0, i32 0
%chr = tail call i8* @memrchr(i8* %ptr, i32 0, i64 %N)
ret i8* %chr
}
; Fold memrchr(a8, 1, 8) to null.
define i8* @fold_memrchr_a8_1_8() {
; CHECK-LABEL: @fold_memrchr_a8_1_8(
; CHECK-NEXT: ret i8* null
;
%ptr = getelementptr [8 x i8], [8 x i8]* @a8, i32 0, i32 0
%chr = tail call i8* @memrchr(i8* %ptr, i32 1, i64 8)
ret i8* %chr
}
; Fold memrchr(a8, 1, N) to null.
define i8* @fold_memrchr_a8_1_N(i64 %N) {
; CHECK-LABEL: @fold_memrchr_a8_1_N(
; CHECK-NEXT: ret i8* null
;
%ptr = getelementptr [8 x i8], [8 x i8]* @a8, i32 0, i32 0
%chr = tail call i8* @memrchr(i8* %ptr, i32 1, i64 %N)
ret i8* %chr
}
; Fold memrchr(a8, C, 8) to C == '\0' ? a8 + 7 : null.
define i8* @fold_memrchr_a8_C_8(i32 %C) {
; CHECK-LABEL: @fold_memrchr_a8_C_8(
; CHECK-NEXT: [[TMP1:%.*]] = trunc i32 [[C:%.*]] to i8
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i8 [[TMP1]], 0
; CHECK-NEXT: [[MEMRCHR_SEL:%.*]] = select i1 [[TMP2]], i8* getelementptr inbounds ([8 x i8], [8 x i8]* @a8, i64 0, i64 7), i8* null
; CHECK-NEXT: ret i8* [[MEMRCHR_SEL]]
;
%ptr = getelementptr [8 x i8], [8 x i8]* @a8, i32 0, i32 0
%chr = tail call i8* @memrchr(i8* %ptr, i32 %C, i64 8)
ret i8* %chr
}
; Fold memrchr(a8, C, N) to C == '\0' && N ? a8 + N - 1 : null.
define i8* @fold_memrchr_a8_C_N(i32 %C, i64 %N) {
; CHECK-LABEL: @fold_memrchr_a8_C_N(
; CHECK-NEXT: [[TMP1:%.*]] = trunc i32 [[C:%.*]] to i8
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i8 [[TMP1]], 0
; CHECK-NEXT: [[TMP3:%.*]] = icmp ne i64 [[N:%.*]], 0
; CHECK-NEXT: [[TMP4:%.*]] = select i1 [[TMP3]], i1 [[TMP2]], i1 false
; CHECK-NEXT: [[TMP5:%.*]] = add i64 [[N]], -1
; CHECK-NEXT: [[TMP6:%.*]] = getelementptr [8 x i8], [8 x i8]* @a8, i64 0, i64 [[TMP5]]
; CHECK-NEXT: [[MEMRCHR_SEL:%.*]] = select i1 [[TMP4]], i8* [[TMP6]], i8* null
; CHECK-NEXT: ret i8* [[MEMRCHR_SEL]]
;
%ptr = getelementptr [8 x i8], [8 x i8]* @a8, i32 0, i32 0
%chr = tail call i8* @memrchr(i8* %ptr, i32 %C, i64 %N)
ret i8* %chr
}
; Fold memrchr(ai32max, 0, INT32_MAX) to a8 + INT32_MAX - 1.
define i8* @fold_memrchr_ai32max_0_i32max() {
; CHECK-LABEL: @fold_memrchr_ai32max_0_i32max(
; CHECK-NEXT: ret i8* getelementptr inbounds ([2147483647 x i8], [2147483647 x i8]* @ai32max, i64 0, i64 2147483646)
;
%ptr = getelementptr [2147483647 x i8], [2147483647 x i8]* @ai32max, i32 0, i32 0
%chr = tail call i8* @memrchr(i8* %ptr, i32 0, i64 2147483647)
ret i8* %chr
}
; Fold memrchr(ai32max, 1, INT32_MAX) to null.
define i8* @fold_memrchr_ai32max_1_i32max() {
; CHECK-LABEL: @fold_memrchr_ai32max_1_i32max(
; CHECK-NEXT: ret i8* null
;
%ptr = getelementptr [2147483647 x i8], [2147483647 x i8]* @ai32max, i32 0, i32 0
%chr = tail call i8* @memrchr(i8* %ptr, i32 1, i64 2147483647)
ret i8* %chr
}
; Fold memrchr(ai32max, 256, INT32_MAX) to ai32max + INT32_MAX - 1.
define i8* @fold_memrchr_ai32max_256_i32max() {
; CHECK-LABEL: @fold_memrchr_ai32max_256_i32max(
; CHECK-NEXT: ret i8* getelementptr inbounds ([2147483647 x i8], [2147483647 x i8]* @ai32max, i64 0, i64 2147483646)
;
%ptr = getelementptr [2147483647 x i8], [2147483647 x i8]* @ai32max, i32 0, i32 0
%chr = tail call i8* @memrchr(i8* %ptr, i32 256, i64 2147483647)
ret i8* %chr
}
; Fold memrchr(ai32max, 257, INT32_MAX) to null.
define i8* @fold_memrchr_ai32max_257_i32max() {
; CHECK-LABEL: @fold_memrchr_ai32max_257_i32max(
; CHECK-NEXT: ret i8* null
;
%ptr = getelementptr [2147483647 x i8], [2147483647 x i8]* @ai32max, i32 0, i32 0
%chr = tail call i8* @memrchr(i8* %ptr, i32 257, i64 2147483647)
ret i8* %chr
}
; Fold memrchr(ai32max, C, INT32_MAX) to C == '\0' ? ai32max + INT32_MAX - 1 : null.
define i8* @fold_memrchr_ai32max_C_i32max(i32 %C) {
; CHECK-LABEL: @fold_memrchr_ai32max_C_i32max(
; CHECK-NEXT: [[TMP1:%.*]] = trunc i32 [[C:%.*]] to i8
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i8 [[TMP1]], 0
; CHECK-NEXT: [[MEMRCHR_SEL:%.*]] = select i1 [[TMP2]], i8* getelementptr inbounds ([2147483647 x i8], [2147483647 x i8]* @ai32max, i64 0, i64 2147483646), i8* null
; CHECK-NEXT: ret i8* [[MEMRCHR_SEL]]
;
%ptr = getelementptr [2147483647 x i8], [2147483647 x i8]* @ai32max, i32 0, i32 0
%chr = tail call i8* @memrchr(i8* %ptr, i32 %C, i64 2147483647)
ret i8* %chr
}
; Fold memrchr(ai32max, C, N) to C == '\0' && N ? ai32max + N - 1 : null.
define i8* @fold_memrchr_ai32max_C_N(i32 %C, i64 %N) {
; CHECK-LABEL: @fold_memrchr_ai32max_C_N(
; CHECK-NEXT: [[TMP1:%.*]] = trunc i32 [[C:%.*]] to i8
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i8 [[TMP1]], 0
; CHECK-NEXT: [[TMP3:%.*]] = icmp ne i64 [[N:%.*]], 0
; CHECK-NEXT: [[TMP4:%.*]] = select i1 [[TMP3]], i1 [[TMP2]], i1 false
; CHECK-NEXT: [[TMP5:%.*]] = add i64 [[N]], -1
; CHECK-NEXT: [[TMP6:%.*]] = getelementptr [2147483647 x i8], [2147483647 x i8]* @ai32max, i64 0, i64 [[TMP5]]
; CHECK-NEXT: [[MEMRCHR_SEL:%.*]] = select i1 [[TMP4]], i8* [[TMP6]], i8* null
; CHECK-NEXT: ret i8* [[MEMRCHR_SEL]]
;
%ptr = getelementptr [2147483647 x i8], [2147483647 x i8]* @ai32max, i32 0, i32 0
%chr = tail call i8* @memrchr(i8* %ptr, i32 %C, i64 %N)
ret i8* %chr
}