This is an archive of the discontinued LLVM Phabricator instance.

Differential D89645

[InferAttrs] Add nocapture/writeonly to string/mem libcalls
ClosedPublic

Authored by xbolva00 on Oct 18 2020, 6:41 AM.

Details

Reviewers
fhahn
jdoerfert
efriedma
Commits
rG7a2abf5aca22: [InferAttrs] Add nocapture/writeonly to string/mem libcalls
Summary

One step closer to fix PR47644.

Diff Detail

Event Timeline

xbolva00 created this revision.Oct 18 2020, 6:41 AM
Herald added a project: Restricted Project. · View Herald TranscriptOct 18 2020, 6:41 AM
Herald added subscribers: llvm-commits, hiraditya. · View Herald Transcript
xbolva00 requested review of this revision.Oct 18 2020, 6:41 AM
xbolva00 added a comment.Oct 21 2020, 1:25 AM

ping

fhahn accepted this revision.Oct 21 2020, 5:52 AM
fhahn added a reviewer: efriedma.

LGTM, thanks! it might be good to wait a day or 2 with committing, so others can also take another look, because some of the changes can be quite subtle.

This revision is now accepted and ready to land.Oct 21 2020, 5:52 AM
efriedma added a comment.Oct 21 2020, 2:18 PM

Almost all the new setDoesNotCapture calls are wrong. If a call returns a pointer base on an argument, it can't be marked nocapture.

fhahn requested changes to this revision.Oct 21 2020, 2:27 PM
In D89645#2345674, @efriedma wrote:

Almost all the new setDoesNotCapture calls are wrong. If a call returns a pointer base on an argument, it can't be marked nocapture.

Oh right, I was only thinking about stores & co for nocapture. Thanks!

This revision now requires changes to proceed.Oct 21 2020, 2:27 PM
jdoerfert added a comment.Oct 21 2020, 2:51 PM

FWIW, we should make "nocapture-maybe-return" an enum attribute, the Attributor uses that internally and can also put it in the IR if you are interested. It's quite helpful for capture analysis as we can simplify follow the return value, and therefore for aliasing.

xbolva00 updated this revision to Diff 301690.Oct 29 2020, 11:14 AM
efriedma accepted this revision.Oct 29 2020, 11:20 AM

LGTM

This revision was not accepted when it landed; it landed in state Needs Review.Oct 29 2020, 12:07 PM
Closed by commit rG7a2abf5aca22: [InferAttrs] Add nocapture/writeonly to string/mem libcalls (authored by xbolva00). · Explain Why
This revision was automatically updated to reflect the committed changes.
xbolva00 added a commit: rG7a2abf5aca22: [InferAttrs] Add nocapture/writeonly to string/mem libcalls.
fhahn added inline comments.Apr 15 2021, 2:42 PM
llvm/lib/Transforms/Utils/BuildLibCalls.cpp
233

I believer this is causing the first argument of str(n)cat to be incorrectly marked as write only. str(n)cat appends at the end of the first string, but to do so it first needs to read the argument to find the end of the null-terminated string. I put up a fix D100601

xbolva00 added inline comments.Apr 15 2021, 3:14 PM
llvm/lib/Transforms/Utils/BuildLibCalls.cpp
233

Right, thanks!

Revision Contents

PathSize
llvm/
lib/
Transforms/
Utils/
21 lines
test/
Analysis/
BasicAA/
13 lines
Transforms/
InferFunctionAttrs/
30 lines
LoopIdiom/
2 lines

Diff 301690

llvm/lib/Transforms/Utils/BuildLibCalls.cpp

Show All 29 Lines
//- Infer Attributes ---------------------------------------------------------// //- Infer Attributes ---------------------------------------------------------//
STATISTIC(NumReadNone, "Number of functions inferred as readnone"); STATISTIC(NumReadNone, "Number of functions inferred as readnone");
STATISTIC(NumReadOnly, "Number of functions inferred as readonly"); STATISTIC(NumReadOnly, "Number of functions inferred as readonly");
STATISTIC(NumArgMemOnly, "Number of functions inferred as argmemonly"); STATISTIC(NumArgMemOnly, "Number of functions inferred as argmemonly");
STATISTIC(NumNoUnwind, "Number of functions inferred as nounwind"); STATISTIC(NumNoUnwind, "Number of functions inferred as nounwind");
STATISTIC(NumNoCapture, "Number of arguments inferred as nocapture"); STATISTIC(NumNoCapture, "Number of arguments inferred as nocapture");
STATISTIC(NumWriteOnlyArg, "Number of arguments inferred as writeonly");
STATISTIC(NumReadOnlyArg, "Number of arguments inferred as readonly"); STATISTIC(NumReadOnlyArg, "Number of arguments inferred as readonly");
STATISTIC(NumNoAlias, "Number of function returns inferred as noalias"); STATISTIC(NumNoAlias, "Number of function returns inferred as noalias");
STATISTIC(NumNoUndef, "Number of function returns inferred as noundef returns"); STATISTIC(NumNoUndef, "Number of function returns inferred as noundef returns");
STATISTIC(NumNonNull, "Number of function returns inferred as nonnull returns"); STATISTIC(NumNonNull, "Number of function returns inferred as nonnull returns");
STATISTIC(NumReturnedArg, "Number of arguments inferred as returned"); STATISTIC(NumReturnedArg, "Number of arguments inferred as returned");
static bool setDoesNotAccessMemory(Function &F) { static bool setDoesNotAccessMemory(Function &F) {
if (F.doesNotAccessMemory()) if (F.doesNotAccessMemory())
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
static bool setOnlyReadsMemory(Function &F, unsigned ArgNo) { static bool setOnlyReadsMemory(Function &F, unsigned ArgNo) {
if (F.hasParamAttribute(ArgNo, Attribute::ReadOnly)) if (F.hasParamAttribute(ArgNo, Attribute::ReadOnly))
return false; return false;
F.addParamAttr(ArgNo, Attribute::ReadOnly); F.addParamAttr(ArgNo, Attribute::ReadOnly);
++NumReadOnlyArg; ++NumReadOnlyArg;
return true; return true;
} }
static bool setOnlyWritesMemory(Function &F, unsigned ArgNo) {
if (F.hasParamAttribute(ArgNo, Attribute::WriteOnly))
return false;
F.addParamAttr(ArgNo, Attribute::WriteOnly);
++NumWriteOnlyArg;
return true;
}
static bool setRetNoUndef(Function &F) { static bool setRetNoUndef(Function &F) {
if (!F.getReturnType()->isVoidTy() && if (!F.getReturnType()->isVoidTy() &&
!F.hasAttribute(AttributeList::ReturnIndex, Attribute::NoUndef)) { !F.hasAttribute(AttributeList::ReturnIndex, Attribute::NoUndef)) {
F.addAttribute(AttributeList::ReturnIndex, Attribute::NoUndef); F.addAttribute(AttributeList::ReturnIndex, Attribute::NoUndef);
++NumNoUndef; ++NumNoUndef;
return true; return true;
} }
return false; return false;
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Linesbool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) {
case LibFunc_strncat: case LibFunc_strncat:
Changed |= setReturnedArg(F, 0); Changed |= setReturnedArg(F, 0);
LLVM_FALLTHROUGH; LLVM_FALLTHROUGH;
case LibFunc_stpcpy: case LibFunc_stpcpy:
case LibFunc_stpncpy: case LibFunc_stpncpy:
Changed |= setOnlyAccessesArgMemory(F); Changed |= setOnlyAccessesArgMemory(F);
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyWritesMemory(F, 0);
fhahnUnsubmitted
Not Done
ReplyInline Actions

I believer this is causing the first argument of str(n)cat to be incorrectly marked as write only. str(n)cat appends at the end of the first string, but to do so it first needs to read the argument to find the end of the null-terminated string. I put up a fix D100601

fhahn: I believer this is causing the first argument of `str(n)cat` to be incorrectly marked as `write…
xbolva00AuthorUnsubmitted
Done
ReplyInline Actions

Right, thanks!

xbolva00: Right, thanks!
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
Changed |= setDoesNotAlias(F, 0); Changed |= setDoesNotAlias(F, 0);
Changed |= setDoesNotAlias(F, 1); Changed |= setDoesNotAlias(F, 1);
return Changed; return Changed;
case LibFunc_strxfrm: case LibFunc_strxfrm:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 0); Changed |= setDoesNotCapture(F, 0);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines case LibFunc_sscanf:
Changed |= setOnlyReadsMemory(F, 0); Changed |= setOnlyReadsMemory(F, 0);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc_sprintf: case LibFunc_sprintf:
Changed |= setRetAndArgsNoUndef(F); Changed |= setRetAndArgsNoUndef(F);
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 0); Changed |= setDoesNotCapture(F, 0);
Changed |= setDoesNotAlias(F, 0); Changed |= setDoesNotAlias(F, 0);
Changed |= setOnlyWritesMemory(F, 0);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc_snprintf: case LibFunc_snprintf:
Changed |= setRetAndArgsNoUndef(F); Changed |= setRetAndArgsNoUndef(F);
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 0); Changed |= setDoesNotCapture(F, 0);
Changed |= setDoesNotAlias(F, 0); Changed |= setDoesNotAlias(F, 0);
Changed |= setOnlyWritesMemory(F, 0);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 2); Changed |= setOnlyReadsMemory(F, 2);
return Changed; return Changed;
case LibFunc_setitimer: case LibFunc_setitimer:
Changed |= setRetAndArgsNoUndef(F); Changed |= setRetAndArgsNoUndef(F);
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Show All 29 Lines case LibFunc_modfl:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
return Changed; return Changed;
case LibFunc_memcpy: case LibFunc_memcpy:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setOnlyAccessesArgMemory(F); Changed |= setOnlyAccessesArgMemory(F);
Changed |= setDoesNotAlias(F, 0); Changed |= setDoesNotAlias(F, 0);
Changed |= setReturnedArg(F, 0); Changed |= setReturnedArg(F, 0);
Changed |= setOnlyWritesMemory(F, 0);
Changed |= setDoesNotAlias(F, 1); Changed |= setDoesNotAlias(F, 1);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc_memmove: case LibFunc_memmove:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setOnlyAccessesArgMemory(F); Changed |= setOnlyAccessesArgMemory(F);
Changed |= setReturnedArg(F, 0); Changed |= setReturnedArg(F, 0);
Changed |= setOnlyWritesMemory(F, 0);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc_mempcpy: case LibFunc_mempcpy:
case LibFunc_memccpy: case LibFunc_memccpy:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setOnlyAccessesArgMemory(F); Changed |= setOnlyAccessesArgMemory(F);
Changed |= setDoesNotAlias(F, 0); Changed |= setDoesNotAlias(F, 0);
Changed |= setOnlyWritesMemory(F, 0);
Changed |= setDoesNotAlias(F, 1); Changed |= setDoesNotAlias(F, 1);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
case LibFunc_memcpy_chk: case LibFunc_memcpy_chk:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
return Changed; return Changed;
case LibFunc_memalign: case LibFunc_memalign:
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines case LibFunc_aligned_alloc:
Changed |= setRetNoUndef(F); Changed |= setRetNoUndef(F);
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setRetDoesNotAlias(F); Changed |= setRetDoesNotAlias(F);
return Changed; return Changed;
case LibFunc_bcopy: case LibFunc_bcopy:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setOnlyAccessesArgMemory(F); Changed |= setOnlyAccessesArgMemory(F);
Changed |= setDoesNotCapture(F, 0); Changed |= setDoesNotCapture(F, 0);
Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 0); Changed |= setOnlyReadsMemory(F, 0);
Changed |= setOnlyWritesMemory(F, 1);
Changed |= setDoesNotCapture(F, 1);
return Changed; return Changed;
case LibFunc_bcmp: case LibFunc_bcmp:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setOnlyAccessesArgMemory(F); Changed |= setOnlyAccessesArgMemory(F);
Changed |= setOnlyReadsMemory(F); Changed |= setOnlyReadsMemory(F);
Changed |= setDoesNotCapture(F, 0); Changed |= setDoesNotCapture(F, 0);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
return Changed; return Changed;
case LibFunc_bzero: case LibFunc_bzero:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setOnlyAccessesArgMemory(F); Changed |= setOnlyAccessesArgMemory(F);
Changed |= setDoesNotCapture(F, 0); Changed |= setDoesNotCapture(F, 0);
Changed |= setOnlyWritesMemory(F, 0);
return Changed; return Changed;
case LibFunc_calloc: case LibFunc_calloc:
Changed |= setRetNoUndef(F); Changed |= setRetNoUndef(F);
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setRetDoesNotAlias(F); Changed |= setRetDoesNotAlias(F);
return Changed; return Changed;
case LibFunc_chmod: case LibFunc_chmod:
case LibFunc_chown: case LibFunc_chown:
▲ Show 20 Lines • Show All 442 Lines • ▼ Show 20 Lines case LibFunc_msvc_new_array_longlong: // new[](unsigned long long)
Changed |= setRetDoesNotAlias(F); Changed |= setRetDoesNotAlias(F);
return Changed; return Changed;
// TODO: add LibFunc entries for: // TODO: add LibFunc entries for:
// case LibFunc_memset_pattern4: // case LibFunc_memset_pattern4:
// case LibFunc_memset_pattern8: // case LibFunc_memset_pattern8:
case LibFunc_memset_pattern16: case LibFunc_memset_pattern16:
Changed |= setOnlyAccessesArgMemory(F); Changed |= setOnlyAccessesArgMemory(F);
Changed |= setDoesNotCapture(F, 0); Changed |= setDoesNotCapture(F, 0);
Changed |= setOnlyWritesMemory(F, 0);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
return Changed; return Changed;
// int __nvvm_reflect(const char *) // int __nvvm_reflect(const char *)
case LibFunc_nvvm_reflect: case LibFunc_nvvm_reflect:
Changed |= setRetAndArgsNoUndef(F); Changed |= setRetAndArgsNoUndef(F);
Changed |= setDoesNotAccessMemory(F); Changed |= setDoesNotAccessMemory(F);
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
▲ Show 20 Lines • Show All 504 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/libfuncs.ll

Show First 20 Lines • Show All 100 Lines • ▼ Show 20 Linesentry:
%a.gep.5 = getelementptr i8, i8* %a, i32 5 %a.gep.5 = getelementptr i8, i8* %a, i32 5
store i8 1, i8* %a.gep.5 store i8 1, i8* %a.gep.5
ret i8* %res ret i8* %res
} }
declare i8* @memccpy(i8*, i8*, i32, i64) declare i8* @memccpy(i8*, i8*, i32, i64)
; CHECK-LABEL: Function: test_memccpy_const_size ; CHECK-LABEL: Function: test_memccpy_const_size
; CHECK: Both ModRef: Ptr: i8* %a <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4) ; CHECK: Just Mod: Ptr: i8* %a <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4)
; CHECK-NEXT: Just Ref: Ptr: i8* %b <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4) ; CHECK-NEXT: Just Ref: Ptr: i8* %b <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4)
; CHECK-NEXT: Both ModRef: Ptr: i8* %res <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4) ; CHECK-NEXT:NoModRef: Ptr: i8* %res <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4)
; CHECK-NEXT: Both ModRef: Ptr: i8* %a.gep.1 <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4) ; CHECK-NEXT:Just Mod: Ptr: i8* %a.gep.1 <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4)
; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.5 <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4) ; CHECK-NEXT:NoModRef: Ptr: i8* %a.gep.5 <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4)
; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.1 <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4) ; CHECK-NEXT:Just Ref: Ptr: i8* %b.gep.1 <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4)
; CHECK-NEXT: NoModRef: Ptr: i8* %b.gep.5 <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4) ; CHECK-NEXT:NoModRef: Ptr: i8* %b.gep.5 <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4)
define i8* @test_memccpy_const_size(i8* noalias %a, i8* noalias %b) { define i8* @test_memccpy_const_size(i8* noalias %a, i8* noalias %b) {
entry: entry:
%res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4) %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4)
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
store i8 0, i8* %a.gep.1 store i8 0, i8* %a.gep.1
%a.gep.5 = getelementptr i8, i8* %a, i32 5 %a.gep.5 = getelementptr i8, i8* %a, i32 5
store i8 1, i8* %a.gep.5 store i8 1, i8* %a.gep.5
%b.gep.1 = getelementptr i8, i8* %b, i32 1 %b.gep.1 = getelementptr i8, i8* %b, i32 1
store i8 2, i8* %b.gep.1 store i8 2, i8* %b.gep.1
%b.gep.5 = getelementptr i8, i8* %b, i32 5 %b.gep.5 = getelementptr i8, i8* %b, i32 5
store i8 3, i8* %b.gep.5 store i8 3, i8* %b.gep.5
ret i8* %res ret i8* %res
} }

llvm/test/Transforms/InferFunctionAttrs/annotate.ll

Show First 20 Lines • Show All 241 Lines • ▼ Show 20 Lines
declare i64 @atoll(i8*) declare i64 @atoll(i8*)
; CHECK-LINUX: declare i32 @bcmp(i8* nocapture, i8* nocapture, i64) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY:#[0-9]+]] ; CHECK-LINUX: declare i32 @bcmp(i8* nocapture, i8* nocapture, i64) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY:#[0-9]+]]
; CHECK-DARWIN-NOT: declare i32 @bcmp(i8* nocapture, i8* nocapture, i64) [[G2]] ; CHECK-DARWIN-NOT: declare i32 @bcmp(i8* nocapture, i8* nocapture, i64) [[G2]]
; CHECK-UNKNOWN-NOT: declare i32 @bcmp(i8* nocapture, i8* nocapture, i64) [[G2]] ; CHECK-UNKNOWN-NOT: declare i32 @bcmp(i8* nocapture, i8* nocapture, i64) [[G2]]
; CHECK-NVPTX-NOT: declare i32 @bcmp(i8* nocapture, i8* nocapture, i64) [[G2]] ; CHECK-NVPTX-NOT: declare i32 @bcmp(i8* nocapture, i8* nocapture, i64) [[G2]]
declare i32 @bcmp(i8*, i8*, i64) declare i32 @bcmp(i8*, i8*, i64)
; CHECK: declare void @bcopy(i8* nocapture readonly, i8* nocapture, i64) [[ARGMEMONLY_NOFREE_NOUNWIND:#[0-9]+]] ; CHECK: declare void @bcopy(i8* nocapture readonly, i8* nocapture writeonly, i64) [[ARGMEMONLY_NOFREE_NOUNWIND:#[0-9]+]]
declare void @bcopy(i8*, i8*, i64) declare void @bcopy(i8*, i8*, i64)
; CHECK: declare void @bzero(i8* nocapture, i64) [[ARGMEMONLY_NOFREE_NOUNWIND:#[0-9]+]] ; CHECK: declare void @bzero(i8* nocapture writeonly, i64) [[ARGMEMONLY_NOFREE_NOUNWIND:#[0-9]+]]
declare void @bzero(i8*, i64) declare void @bzero(i8*, i64)
; CHECK: declare noalias noundef i8* @calloc(i64, i64) [[G1]] ; CHECK: declare noalias noundef i8* @calloc(i64, i64) [[G1]]
declare i8* @calloc(i64, i64) declare i8* @calloc(i64, i64)
; CHECK: declare double @cbrt(double) [[G0]] ; CHECK: declare double @cbrt(double) [[G0]]
declare double @cbrt(double) declare double @cbrt(double)
▲ Show 20 Lines • Show All 352 Lines • ▼ Show 20 Lines
declare i32 @lstat64(i8*, %opaque*) declare i32 @lstat64(i8*, %opaque*)
; CHECK: declare noalias noundef i8* @malloc(i64) [[G1]] ; CHECK: declare noalias noundef i8* @malloc(i64) [[G1]]
declare i8* @malloc(i64) declare i8* @malloc(i64)
; CHECK-LINUX: declare noalias i8* @memalign(i64, i64) [[G0]] ; CHECK-LINUX: declare noalias i8* @memalign(i64, i64) [[G0]]
declare i8* @memalign(i64, i64) declare i8* @memalign(i64, i64)
; CHECK: declare i8* @memccpy(i8* noalias, i8* noalias nocapture readonly, i32, i64) [[ARGMEMONLY_NOFREE_NOUNWIND:#[0-9]+]] ; CHECK: declare i8* @memccpy(i8* noalias writeonly, i8* noalias nocapture readonly, i32, i64) [[ARGMEMONLY_NOFREE_NOUNWIND:#[0-9]+]]
declare i8* @memccpy(i8*, i8*, i32, i64) declare i8* @memccpy(i8*, i8*, i32, i64)
; CHECK-LINUX: declare i8* @memchr(i8*, i32, i64) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY]] ; CHECK-LINUX: declare i8* @memchr(i8*, i32, i64) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY]]
; CHECK-DARWIN: declare i8* @memchr(i8*, i32, i64) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY:#[0-9]+]] ; CHECK-DARWIN: declare i8* @memchr(i8*, i32, i64) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY:#[0-9]+]]
; CHECK-UNKNOWN: declare i8* @memchr(i8*, i32, i64) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY:#[0-9]+]] ; CHECK-UNKNOWN: declare i8* @memchr(i8*, i32, i64) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY:#[0-9]+]]
declare i8* @memchr(i8*, i32, i64) declare i8* @memchr(i8*, i32, i64)
; CHECK: declare i32 @memcmp(i8* nocapture, i8* nocapture, i64) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY]] ; CHECK: declare i32 @memcmp(i8* nocapture, i8* nocapture, i64) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY]]
declare i32 @memcmp(i8*, i8*, i64) declare i32 @memcmp(i8*, i8*, i64)
; CHECK: declare i8* @memcpy(i8* noalias returned, i8* noalias nocapture readonly, i64) [[ARGMEMONLY_NOFREE_NOUNWIND]] ; CHECK: declare i8* @memcpy(i8* noalias returned writeonly, i8* noalias nocapture readonly, i64) [[ARGMEMONLY_NOFREE_NOUNWIND]]
declare i8* @memcpy(i8*, i8*, i64) declare i8* @memcpy(i8*, i8*, i64)
; CHECK: declare i8* @mempcpy(i8* noalias, i8* noalias nocapture readonly, i64) [[ARGMEMONLY_NOFREE_NOUNWIND]] ; CHECK: declare i8* @mempcpy(i8* noalias writeonly, i8* noalias nocapture readonly, i64) [[ARGMEMONLY_NOFREE_NOUNWIND]]
declare i8* @mempcpy(i8*, i8*, i64) declare i8* @mempcpy(i8*, i8*, i64)
; CHECK: declare i8* @memmove(i8* returned, i8* nocapture readonly, i64) [[ARGMEMONLY_NOFREE_NOUNWIND]] ; CHECK: declare i8* @memmove(i8* returned writeonly, i8* nocapture readonly, i64) [[ARGMEMONLY_NOFREE_NOUNWIND]]
declare i8* @memmove(i8*, i8*, i64) declare i8* @memmove(i8*, i8*, i64)
; CHECK: declare i8* @memset(i8*, i32, i64) [[G0]] ; CHECK: declare i8* @memset(i8*, i32, i64) [[G0]]
declare i8* @memset(i8*, i32, i64) declare i8* @memset(i8*, i32, i64)
; CHECK: declare noundef i32 @mkdir(i8* nocapture noundef readonly, i16 noundef zeroext) [[G1]] ; CHECK: declare noundef i32 @mkdir(i8* nocapture noundef readonly, i16 noundef zeroext) [[G1]]
declare i32 @mkdir(i8*, i16 zeroext) declare i32 @mkdir(i8*, i16 zeroext)
▲ Show 20 Lines • Show All 142 Lines • ▼ Show 20 Lines
declare float @sinhf(float) declare float @sinhf(float)
; CHECK: declare x86_fp80 @sinhl(x86_fp80) [[G0]] ; CHECK: declare x86_fp80 @sinhl(x86_fp80) [[G0]]
declare x86_fp80 @sinhl(x86_fp80) declare x86_fp80 @sinhl(x86_fp80)
; CHECK: declare x86_fp80 @sinl(x86_fp80) [[G0]] ; CHECK: declare x86_fp80 @sinl(x86_fp80) [[G0]]
declare x86_fp80 @sinl(x86_fp80) declare x86_fp80 @sinl(x86_fp80)
; CHECK: declare noundef i32 @snprintf(i8* noalias nocapture noundef, i64 noundef, i8* nocapture noundef readonly, ...) [[G1]] ; CHECK: declare noundef i32 @snprintf(i8* noalias nocapture noundef writeonly, i64 noundef, i8* nocapture noundef readonly, ...) [[G1]]
declare i32 @snprintf(i8*, i64, i8*, ...) declare i32 @snprintf(i8*, i64, i8*, ...)
; CHECK: declare noundef i32 @sprintf(i8* noalias nocapture noundef, i8* nocapture noundef readonly, ...) [[G1]] ; CHECK: declare noundef i32 @sprintf(i8* noalias nocapture noundef writeonly, i8* nocapture noundef readonly, ...) [[G1]]
declare i32 @sprintf(i8*, i8*, ...) declare i32 @sprintf(i8*, i8*, ...)
; CHECK: declare double @sqrt(double) [[G0]] ; CHECK: declare double @sqrt(double) [[G0]]
declare double @sqrt(double) declare double @sqrt(double)
; CHECK: declare float @sqrtf(float) [[G0]] ; CHECK: declare float @sqrtf(float) [[G0]]
declare float @sqrtf(float) declare float @sqrtf(float)
Show All 10 Lines
declare i32 @stat64(i8*, %opaque*) declare i32 @stat64(i8*, %opaque*)
; CHECK: declare noundef i32 @statvfs(i8* nocapture noundef readonly, %opaque* nocapture noundef) [[G1]] ; CHECK: declare noundef i32 @statvfs(i8* nocapture noundef readonly, %opaque* nocapture noundef) [[G1]]
declare i32 @statvfs(i8*, %opaque*) declare i32 @statvfs(i8*, %opaque*)
; CHECK-LINUX: declare noundef i32 @statvfs64(i8* nocapture noundef readonly, %opaque* nocapture noundef) [[G1]] ; CHECK-LINUX: declare noundef i32 @statvfs64(i8* nocapture noundef readonly, %opaque* nocapture noundef) [[G1]]
declare i32 @statvfs64(i8*, %opaque*) declare i32 @statvfs64(i8*, %opaque*)
; CHECK: declare i8* @stpcpy(i8* noalias, i8* noalias nocapture readonly) [[ARGMEMONLY_NOFREE_NOUNWIND]] ; CHECK: declare i8* @stpcpy(i8* noalias writeonly, i8* noalias nocapture readonly) [[ARGMEMONLY_NOFREE_NOUNWIND]]
declare i8* @stpcpy(i8*, i8*) declare i8* @stpcpy(i8*, i8*)
; CHECK: declare i8* @stpncpy(i8* noalias, i8* noalias nocapture readonly, i64) [[ARGMEMONLY_NOFREE_NOUNWIND]] ; CHECK: declare i8* @stpncpy(i8* noalias writeonly, i8* noalias nocapture readonly, i64) [[ARGMEMONLY_NOFREE_NOUNWIND]]
declare i8* @stpncpy(i8*, i8*, i64) declare i8* @stpncpy(i8*, i8*, i64)
; CHECK: declare i32 @strcasecmp(i8* nocapture, i8* nocapture) [[G2]] ; CHECK: declare i32 @strcasecmp(i8* nocapture, i8* nocapture) [[G2]]
declare i32 @strcasecmp(i8*, i8*) declare i32 @strcasecmp(i8*, i8*)
; CHECK: declare i8* @strcat(i8* noalias returned, i8* noalias nocapture readonly) [[ARGMEMONLY_NOFREE_NOUNWIND]] ; CHECK: declare i8* @strcat(i8* noalias returned writeonly, i8* noalias nocapture readonly) [[ARGMEMONLY_NOFREE_NOUNWIND]]
declare i8* @strcat(i8*, i8*) declare i8* @strcat(i8*, i8*)
; CHECK: declare i8* @strchr(i8*, i32) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY]] ; CHECK: declare i8* @strchr(i8*, i32) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY]]
declare i8* @strchr(i8*, i32) declare i8* @strchr(i8*, i32)
; CHECK: declare i32 @strcmp(i8* nocapture, i8* nocapture) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY]] ; CHECK: declare i32 @strcmp(i8* nocapture, i8* nocapture) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY]]
declare i32 @strcmp(i8*, i8*) declare i32 @strcmp(i8*, i8*)
; CHECK: declare i32 @strcoll(i8* nocapture, i8* nocapture) [[G2]] ; CHECK: declare i32 @strcoll(i8* nocapture, i8* nocapture) [[G2]]
declare i32 @strcoll(i8*, i8*) declare i32 @strcoll(i8*, i8*)
; CHECK: declare i8* @strcpy(i8* noalias returned, i8* noalias nocapture readonly) [[ARGMEMONLY_NOFREE_NOUNWIND]] ; CHECK: declare i8* @strcpy(i8* noalias returned writeonly, i8* noalias nocapture readonly) [[ARGMEMONLY_NOFREE_NOUNWIND]]
declare i8* @strcpy(i8*, i8*) declare i8* @strcpy(i8*, i8*)
; CHECK: declare i64 @strcspn(i8* nocapture, i8* nocapture) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY]] ; CHECK: declare i64 @strcspn(i8* nocapture, i8* nocapture) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY]]
declare i64 @strcspn(i8*, i8*) declare i64 @strcspn(i8*, i8*)
; CHECK: declare noalias i8* @strdup(i8* nocapture readonly) [[G1]] ; CHECK: declare noalias i8* @strdup(i8* nocapture readonly) [[G1]]
declare i8* @strdup(i8*) declare i8* @strdup(i8*)
; CHECK: declare i64 @strlen(i8* nocapture) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY]] ; CHECK: declare i64 @strlen(i8* nocapture) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY]]
declare i64 @strlen(i8*) declare i64 @strlen(i8*)
; CHECK: declare i32 @strncasecmp(i8* nocapture, i8* nocapture, i64) [[G2]] ; CHECK: declare i32 @strncasecmp(i8* nocapture, i8* nocapture, i64) [[G2]]
declare i32 @strncasecmp(i8*, i8*, i64) declare i32 @strncasecmp(i8*, i8*, i64)
; CHECK: declare i8* @strncat(i8* noalias returned, i8* noalias nocapture readonly, i64) [[ARGMEMONLY_NOFREE_NOUNWIND]] ; CHECK: declare i8* @strncat(i8* noalias returned writeonly, i8* noalias nocapture readonly, i64) [[ARGMEMONLY_NOFREE_NOUNWIND]]
declare i8* @strncat(i8*, i8*, i64) declare i8* @strncat(i8*, i8*, i64)
; CHECK: declare i32 @strncmp(i8* nocapture, i8* nocapture, i64) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY]] ; CHECK: declare i32 @strncmp(i8* nocapture, i8* nocapture, i64) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY]]
declare i32 @strncmp(i8*, i8*, i64) declare i32 @strncmp(i8*, i8*, i64)
; CHECK: declare i8* @strncpy(i8* noalias returned, i8* noalias nocapture readonly, i64) [[ARGMEMONLY_NOFREE_NOUNWIND]] ; CHECK: declare i8* @strncpy(i8* noalias returned writeonly, i8* noalias nocapture readonly, i64) [[ARGMEMONLY_NOFREE_NOUNWIND]]
declare i8* @strncpy(i8*, i8*, i64) declare i8* @strncpy(i8*, i8*, i64)
; CHECK: declare noalias i8* @strndup(i8* nocapture readonly, i64) [[G1]] ; CHECK: declare noalias i8* @strndup(i8* nocapture readonly, i64) [[G1]]
declare i8* @strndup(i8*, i64) declare i8* @strndup(i8*, i64)
; CHECK: declare i64 @strnlen(i8*, i64) [[G0]] ; CHECK: declare i64 @strnlen(i8*, i64) [[G0]]
declare i64 @strnlen(i8*, i64) declare i64 @strnlen(i8*, i64)
▲ Show 20 Lines • Show All 123 Lines • ▼ Show 20 Lines
; CHECK: declare noundef i32 @vsscanf(i8* nocapture noundef readonly, i8* nocapture noundef readonly, %opaque* noundef) [[G1]] ; CHECK: declare noundef i32 @vsscanf(i8* nocapture noundef readonly, i8* nocapture noundef readonly, %opaque* noundef) [[G1]]
declare i32 @vsscanf(i8*, i8*, %opaque*) declare i32 @vsscanf(i8*, i8*, %opaque*)
; CHECK: declare noundef i64 @write(i32 noundef, i8* nocapture noundef readonly, i64 noundef) [[G0]] ; CHECK: declare noundef i64 @write(i32 noundef, i8* nocapture noundef readonly, i64 noundef) [[G0]]
declare i64 @write(i32, i8*, i64) declare i64 @write(i32, i8*, i64)
; memset_pattern16 isn't available everywhere. ; memset_pattern16 isn't available everywhere.
; CHECK-DARWIN: declare void @memset_pattern16(i8* nocapture, i8* nocapture readonly, i64) [[ARGMEMONLY_NOFREE:#[0-9]+]] ; CHECK-DARWIN: declare void @memset_pattern16(i8* nocapture writeonly, i8* nocapture readonly, i64) [[ARGMEMONLY_NOFREE:#[0-9]+]]
declare void @memset_pattern16(i8*, i8*, i64) declare void @memset_pattern16(i8*, i8*, i64)
; CHECK: attributes [[G0]] = { nofree } ; CHECK: attributes [[G0]] = { nofree }
; CHECK: attributes [[G1]] = { nofree nounwind } ; CHECK: attributes [[G1]] = { nofree nounwind }
; CHECK: attributes [[G2]] = { nofree nounwind readonly } ; CHECK: attributes [[G2]] = { nofree nounwind readonly }
; CHECK-DAG-UNKNOWN: attributes [[ARGMEMONLY_NOFREE_NOUNWIND]] = { argmemonly nofree nounwind } ; CHECK-DAG-UNKNOWN: attributes [[ARGMEMONLY_NOFREE_NOUNWIND]] = { argmemonly nofree nounwind }
; CHECK-DAG-UNKNOWN: attributes [[NOUNWIND]] = { nounwind } ; CHECK-DAG-UNKNOWN: attributes [[NOUNWIND]] = { nounwind }
Show All 11 Lines

llvm/test/Transforms/LoopIdiom/basic.ll

Show First 20 Lines • Show All 1,058 Lines • ▼ Show 20 Lines
loop.exit: loop.exit:
br label %exit br label %exit
exit: exit:
ret void ret void
} }
; Validate that "memset_pattern" has the proper attributes. ; Validate that "memset_pattern" has the proper attributes.
; CHECK: declare void @memset_pattern16(i8* nocapture, i8* nocapture readonly, i64) [[ATTRS:#[0-9]+]] ; CHECK: declare void @memset_pattern16(i8* nocapture writeonly, i8* nocapture readonly, i64) [[ATTRS:#[0-9]+]]
; CHECK: [[ATTRS]] = { argmemonly nofree } ; CHECK: [[ATTRS]] = { argmemonly nofree }