This is an archive of the discontinued LLVM Phabricator instance.

Differential D123665

[SimplifyLibCalls] Don't mark memchr() memory as fully dereferenceable
ClosedPublic

Authored by nikic on Apr 13 2022, 2:31 AM.

Details

Reviewers
efriedma
xbolva00
msebor
Commits
rG8c74169990c0: [SimplifyLibCalls] Don't mark memchr() memory as fully dereferenceable
Summary

C11 specifies memchr() as follows:

The memchr function locates the first occurrence of c (converted to an unsigned
char) in the initial n characters (each interpreted as unsigned char ) of the object
pointed to by s. The implementation shall behave as if it reads the characters sequentially
and stops as soon as a matching character is found.

In particular, it is well-defined to specify a memchr size larger than the underlying object, as long as the character is found before the end of the object.

Diff Detail

Event Timeline

nikic created this revision.Apr 13 2022, 2:31 AM
Herald added a project: Restricted Project. · View Herald TranscriptApr 13 2022, 2:31 AM
Herald added a subscriber: hiraditya. · View Herald Transcript
nikic requested review of this revision.Apr 13 2022, 2:31 AM
Herald added a project: Restricted Project. · View Herald TranscriptApr 13 2022, 2:31 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
nikic mentioned this in D123626: [InstCombine] Fold memrchr calls with constant size of zero or one..Apr 13 2022, 2:35 AM
Harbormaster completed remote builds in B159402: Diff 422443.Apr 13 2022, 3:07 AM
xbolva00 accepted this revision.Apr 13 2022, 3:41 AM

The implementation shall behave as if it reads the characters sequentially and stops as soon as a matching character is found.

Then LG

This revision is now accepted and ready to land.Apr 13 2022, 3:41 AM
This revision was landed with ongoing or failed builds.Apr 13 2022, 7:46 AM
Closed by commit rG8c74169990c0: [SimplifyLibCalls] Don't mark memchr() memory as fully dereferenceable (authored by nikic). · Explain Why
This revision was automatically updated to reflect the committed changes.
nikic added a commit: rG8c74169990c0: [SimplifyLibCalls] Don't mark memchr() memory as fully dereferenceable.

Revision Contents

PathSize
llvm/
lib/
Transforms/
Utils/
4 lines
test/
Transforms/
InstCombine/
8 lines
10 lines
2 lines

Diff 422443

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

Show First 20 Lines • Show All 870 Lines • ▼ Show 20 LinesValue *LibCallSimplifier::optimizeMemRChr(CallInst *CI, IRBuilderBase &B) {
if (isKnownNonZero(CI->getOperand(2), DL)) if (isKnownNonZero(CI->getOperand(2), DL))
annotateNonNullNoUndefBasedOnAccess(CI, 0); annotateNonNullNoUndefBasedOnAccess(CI, 0);
return nullptr; return nullptr;
} }
Value *LibCallSimplifier::optimizeMemChr(CallInst *CI, IRBuilderBase &B) { Value *LibCallSimplifier::optimizeMemChr(CallInst *CI, IRBuilderBase &B) {
Value *SrcStr = CI->getArgOperand(0); Value *SrcStr = CI->getArgOperand(0);
Value *Size = CI->getArgOperand(2); Value *Size = CI->getArgOperand(2);
annotateNonNullAndDereferenceable(CI, 0, Size, DL); if (isKnownNonZero(Size, DL))
annotateNonNullNoUndefBasedOnAccess(CI, 0);
Value *CharVal = CI->getArgOperand(1); Value *CharVal = CI->getArgOperand(1);
ConstantInt *CharC = dyn_cast<ConstantInt>(CharVal); ConstantInt *CharC = dyn_cast<ConstantInt>(CharVal);
ConstantInt *LenC = dyn_cast<ConstantInt>(Size); ConstantInt *LenC = dyn_cast<ConstantInt>(Size);
// memchr(x, y, 0) -> null // memchr(x, y, 0) -> null
if (LenC) { if (LenC) {
if (LenC->isZero()) if (LenC->isZero())
return Constant::getNullValue(CI->getType()); return Constant::getNullValue(CI->getType());
▲ Show 20 Lines • Show All 2,682 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/mem-deref-bytes.ll

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 Lines
; CHECK-NEXT: ret i32 [[CALL]] ; CHECK-NEXT: ret i32 [[CALL]]
; ;
%call = tail call i32 @memcmp(i8* %d, i8* %s, i64 %n) %call = tail call i32 @memcmp(i8* %d, i8* %s, i64 %n)
ret i32 %call ret i32 %call
} }
define i8* @memcpy_const_size_set_deref(i8* nocapture readonly %d, i8* nocapture readonly %s) { define i8* @memcpy_const_size_set_deref(i8* nocapture readonly %d, i8* nocapture readonly %s) {
; CHECK-LABEL: @memcpy_const_size_set_deref( ; CHECK-LABEL: @memcpy_const_size_set_deref(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* noundef nonnull align 1 dereferenceable(64) [[D:%.*]], i8* noundef nonnull align 1 dereferenceable(64) [[S:%.*]], i64 64, i1 false) ; CHECK-NEXT: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* noundef nonnull align 1 dereferenceable(64) [[D:%.*]], i8* noundef nonnull align 1 dereferenceable(64) [[S:%.*]], i64 64, i1 false)
; CHECK-NEXT: ret i8* [[D]] ; CHECK-NEXT: ret i8* [[D]]
; ;
%call = tail call i8* @memcpy(i8* %d, i8* %s, i64 64) %call = tail call i8* @memcpy(i8* %d, i8* %s, i64 64)
ret i8* %call ret i8* %call
} }
define i8* @memmove_const_size_set_deref(i8* nocapture readonly %d, i8* nocapture readonly %s) { define i8* @memmove_const_size_set_deref(i8* nocapture readonly %d, i8* nocapture readonly %s) {
; CHECK-LABEL: @memmove_const_size_set_deref( ; CHECK-LABEL: @memmove_const_size_set_deref(
; CHECK-NEXT: call void @llvm.memmove.p0i8.p0i8.i64(i8* noundef nonnull align 1 dereferenceable(64) [[D:%.*]], i8* noundef nonnull align 1 dereferenceable(64) [[S:%.*]], i64 64, i1 false) ; CHECK-NEXT: tail call void @llvm.memmove.p0i8.p0i8.i64(i8* noundef nonnull align 1 dereferenceable(64) [[D:%.*]], i8* noundef nonnull align 1 dereferenceable(64) [[S:%.*]], i64 64, i1 false)
; CHECK-NEXT: ret i8* [[D]] ; CHECK-NEXT: ret i8* [[D]]
; ;
%call = tail call i8* @memmove(i8* %d, i8* %s, i64 64) %call = tail call i8* @memmove(i8* %d, i8* %s, i64 64)
ret i8* %call ret i8* %call
} }
define i8* @memset_const_size_set_deref(i8* nocapture readonly %s, i8 %c) { define i8* @memset_const_size_set_deref(i8* nocapture readonly %s, i8 %c) {
; CHECK-LABEL: @memset_const_size_set_deref( ; CHECK-LABEL: @memset_const_size_set_deref(
; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* noundef nonnull align 1 dereferenceable(64) [[S:%.*]], i8 [[C:%.*]], i64 64, i1 false) ; CHECK-NEXT: tail call void @llvm.memset.p0i8.i64(i8* noundef nonnull align 1 dereferenceable(64) [[S:%.*]], i8 [[C:%.*]], i64 64, i1 false)
; CHECK-NEXT: ret i8* [[S]] ; CHECK-NEXT: ret i8* [[S]]
; ;
%call = tail call i8* @memset(i8* %s, i8 %c, i64 64) %call = tail call i8* @memset(i8* %s, i8 %c, i64 64)
ret i8* %call ret i8* %call
} }
define i8* @memchr_const_size_set_deref(i8* nocapture readonly %s, i32 %c) { define i8* @memchr_const_size_set_deref(i8* nocapture readonly %s, i32 %c) {
; CHECK-LABEL: @memchr_const_size_set_deref( ; CHECK-LABEL: @memchr_const_size_set_deref(
; CHECK-NEXT: [[CALL:%.*]] = tail call i8* @memchr(i8* noundef nonnull dereferenceable(64) [[S:%.*]], i32 [[C:%.*]], i64 64) ; CHECK-NEXT: [[CALL:%.*]] = tail call i8* @memchr(i8* noundef nonnull dereferenceable(1) [[S:%.*]], i32 [[C:%.*]], i64 64)
; CHECK-NEXT: ret i8* [[CALL]] ; CHECK-NEXT: ret i8* [[CALL]]
; ;
%call = tail call i8* @memchr(i8* %s, i32 %c, i64 64) %call = tail call i8* @memchr(i8* %s, i32 %c, i64 64)
ret i8* %call ret i8* %call
} }
define i8* @llvm_memcpy_const_size_set_deref(i8* nocapture readonly %d, i8* nocapture readonly %s) { define i8* @llvm_memcpy_const_size_set_deref(i8* nocapture readonly %d, i8* nocapture readonly %s) {
; CHECK-LABEL: @llvm_memcpy_const_size_set_deref( ; CHECK-LABEL: @llvm_memcpy_const_size_set_deref(
Show All 23 Lines

llvm/test/Transforms/InstCombine/memchr.ll

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines;
%src = getelementptr [14 x i8], [14 x i8]* @hello, i32 0, i32 0 %src = getelementptr [14 x i8], [14 x i8]* @hello, i32 0, i32 0
%dst = call i8* @memchr(i8* %src, i32 0, i32 14) %dst = call i8* @memchr(i8* %src, i32 0, i32 14)
store i8* %dst, i8** @chp store i8* %dst, i8** @chp
ret void ret void
} }
define void @test4(i32 %chr) { define void @test4(i32 %chr) {
; CHECK-LABEL: @test4( ; CHECK-LABEL: @test4(
; CHECK-NEXT: [[DST:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(14) getelementptr inbounds ([14 x i8], [14 x i8]* @hello, i32 0, i32 0), i32 [[CHR:%.*]], i32 14) ; CHECK-NEXT: [[DST:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @hello, i32 0, i32 0), i32 [[CHR:%.*]], i32 14)
; CHECK-NEXT: store i8* [[DST]], i8** @chp, align 4 ; CHECK-NEXT: store i8* [[DST]], i8** @chp, align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%src = getelementptr [14 x i8], [14 x i8]* @hello, i32 0, i32 0 %src = getelementptr [14 x i8], [14 x i8]* @hello, i32 0, i32 0
%dst = call i8* @memchr(i8* %src, i32 %chr, i32 14) %dst = call i8* @memchr(i8* %src, i32 %chr, i32 14)
store i8* %dst, i8** @chp store i8* %dst, i8** @chp
ret void ret void
} }
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Lines;
%dst = call i8* @memchr(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @newlines, i64 0, i64 0), i32 %C, i32 2) %dst = call i8* @memchr(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @newlines, i64 0, i64 0), i32 %C, i32 2)
%cmp = icmp ne i8* %dst, null %cmp = icmp ne i8* %dst, null
ret i1 %cmp ret i1 %cmp
} }
; No 64 bits here ; No 64 bits here
define i1 @test12(i32 %C) { define i1 @test12(i32 %C) {
; CHECK-LABEL: @test12( ; CHECK-LABEL: @test12(
; CHECK-NEXT: [[DST:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(3) getelementptr inbounds ([4 x i8], [4 x i8]* @spaces, i32 0, i32 0), i32 [[C:%.*]], i32 3) ; CHECK-NEXT: [[DST:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @spaces, i32 0, i32 0), i32 [[C:%.*]], i32 3)
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i8* [[DST]], null ; CHECK-NEXT: [[CMP:%.*]] = icmp ne i8* [[DST]], null
; CHECK-NEXT: ret i1 [[CMP]] ; CHECK-NEXT: ret i1 [[CMP]]
; ;
%dst = call i8* @memchr(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @spaces, i64 0, i64 0), i32 %C, i32 3) %dst = call i8* @memchr(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @spaces, i64 0, i64 0), i32 %C, i32 3)
%cmp = icmp ne i8* %dst, null %cmp = icmp ne i8* %dst, null
ret i1 %cmp ret i1 %cmp
} }
Show All 20 Lines
; ;
%dst = call i8* @memchr(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @single, i64 0, i64 0), i32 %C, i32 1) %dst = call i8* @memchr(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @single, i64 0, i64 0), i32 %C, i32 1)
%cmp = icmp ne i8* %dst, null %cmp = icmp ne i8* %dst, null
ret i1 %cmp ret i1 %cmp
} }
define i1 @test15(i32 %C) { define i1 @test15(i32 %C) {
; CHECK-LABEL: @test15( ; CHECK-LABEL: @test15(
; CHECK-NEXT: [[DST:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @negative, i32 0, i32 0), i32 [[C:%.*]], i32 3) ; CHECK-NEXT: [[DST:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @negative, i32 0, i32 0), i32 [[C:%.*]], i32 3)
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i8* [[DST]], null ; CHECK-NEXT: [[CMP:%.*]] = icmp ne i8* [[DST]], null
; CHECK-NEXT: ret i1 [[CMP]] ; CHECK-NEXT: ret i1 [[CMP]]
; ;
%dst = call i8* @memchr(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @negative, i64 0, i64 0), i32 %C, i32 3) %dst = call i8* @memchr(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @negative, i64 0, i64 0), i32 %C, i32 3)
%cmp = icmp ne i8* %dst, null %cmp = icmp ne i8* %dst, null
ret i1 %cmp ret i1 %cmp
} }
Show All 23 Lines
; ;
%ret = call i8* @memchr(i8* nonnull %str, i32 %c, i32 %n) %ret = call i8* @memchr(i8* nonnull %str, i32 %c, i32 %n)
ret i8* %ret ret i8* %ret
} }
define i8* @test18(i8* %str, i32 %c) { define i8* @test18(i8* %str, i32 %c) {
; CHECK-LABEL: @test18( ; CHECK-LABEL: @test18(
; CHECK-NEXT: [[RET:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(5) [[STR:%.*]], i32 [[C:%.*]], i32 5) ; CHECK-NEXT: [[RET:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) [[STR:%.*]], i32 [[C:%.*]], i32 5)
; CHECK-NEXT: ret i8* [[RET]] ; CHECK-NEXT: ret i8* [[RET]]
; ;
%ret = call i8* @memchr(i8* %str, i32 %c, i32 5) %ret = call i8* @memchr(i8* %str, i32 %c, i32 5)
ret i8* %ret ret i8* %ret
} }
define i8* @test19(i8* %str, i32 %c) null_pointer_is_valid { define i8* @test19(i8* %str, i32 %c) null_pointer_is_valid {
; CHECK-LABEL: @test19( ; CHECK-LABEL: @test19(
; CHECK-NEXT: [[RET:%.*]] = call i8* @memchr(i8* noundef dereferenceable(5) [[STR:%.*]], i32 [[C:%.*]], i32 5) ; CHECK-NEXT: [[RET:%.*]] = call i8* @memchr(i8* noundef [[STR:%.*]], i32 [[C:%.*]], i32 5)
; CHECK-NEXT: ret i8* [[RET]] ; CHECK-NEXT: ret i8* [[RET]]
; ;
%ret = call i8* @memchr(i8* %str, i32 %c, i32 5) %ret = call i8* @memchr(i8* %str, i32 %c, i32 5)
ret i8* %ret ret i8* %ret
} }

llvm/test/Transforms/InstCombine/strchr-1.ll

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines;
%src = getelementptr [14 x i8], [14 x i8]* @hello, i32 0, i32 0 %src = getelementptr [14 x i8], [14 x i8]* @hello, i32 0, i32 0
%dst = call i8* @strchr(i8* %src, i32 0) %dst = call i8* @strchr(i8* %src, i32 0)
store i8* %dst, i8** @chp store i8* %dst, i8** @chp
ret void ret void
} }
define void @test_simplify4(i32 %chr) { define void @test_simplify4(i32 %chr) {
; CHECK-LABEL: @test_simplify4( ; CHECK-LABEL: @test_simplify4(
; CHECK-NEXT: [[MEMCHR:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(14) getelementptr inbounds ([14 x i8], [14 x i8]* @hello, i32 0, i32 0), i32 [[CHR:%.*]], i32 14) ; CHECK-NEXT: [[MEMCHR:%.*]] = call i8* @memchr(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @hello, i32 0, i32 0), i32 [[CHR:%.*]], i32 14)
; CHECK-NEXT: store i8* [[MEMCHR]], i8** @chp, align 4 ; CHECK-NEXT: store i8* [[MEMCHR]], i8** @chp, align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%src = getelementptr [14 x i8], [14 x i8]* @hello, i32 0, i32 0 %src = getelementptr [14 x i8], [14 x i8]* @hello, i32 0, i32 0
%dst = call i8* @strchr(i8* %src, i32 %chr) %dst = call i8* @strchr(i8* %src, i32 %chr)
store i8* %dst, i8** @chp store i8* %dst, i8** @chp
ret void ret void
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines