This is an archive of the discontinued LLVM Phabricator instance.

Differential D66217

[BuildLibCalls] Noalias annotation
ClosedPublic

Authored by xbolva00 on Aug 14 2019, 5:43 AM.

Details

Reviewers
jdoerfert
Commits
rG0e0fbae1a432: [BuildLibCalls] Noalias annotation
rL368875: [BuildLibCalls] Noalias annotation
Summary

I think this is better solution than annotating callsites in IC/SLC.

Diff Detail

Repository
rL LLVM

Event Timeline

xbolva00 created this revision.Aug 14 2019, 5:43 AM
Herald added a project: Restricted Project. · View Herald TranscriptAug 14 2019, 5:43 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
xbolva00 updated this revision to Diff 215094.Aug 14 2019, 5:47 AM
xbolva00 updated this revision to Diff 215095.
xbolva00 updated this revision to Diff 215099.Aug 14 2019, 5:57 AM
xbolva00 updated this revision to Diff 215100.Aug 14 2019, 6:02 AM

Added support for sprint, snprintf.

MaskRay added a subscriber: MaskRay.Aug 14 2019, 7:12 AM
jdoerfert added inline comments.Aug 14 2019, 8:13 AM
lib/Transforms/Utils/BuildLibCalls.cpp
188 ↗(On Diff #215100)

This makes sense.

263 ↗(On Diff #215100)

I'm not sure what this means or what this is going to help, but maybe I just miss something.

309 ↗(On Diff #215100)

Makes sense.

xbolva00 marked an inline comment as done.Aug 14 2019, 8:22 AM
xbolva00 added inline comments.
lib/Transforms/Utils/BuildLibCalls.cpp
263 ↗(On Diff #215100)

Target buffer may not overlap with other args.

I can remove it, but some future optimizations based on noalias info would be weaker.

jdoerfert added inline comments.Aug 14 2019, 8:28 AM
lib/Transforms/Utils/BuildLibCalls.cpp
263 ↗(On Diff #215100)

I was wrong, if that is the sprintf semantics, keep it.

xbolva00 marked an inline comment as done.Aug 14 2019, 8:41 AM
xbolva00 added inline comments.
lib/Transforms/Utils/BuildLibCalls.cpp
263 ↗(On Diff #215100)

Yea :)

man sprintf

Some programs imprudently rely on code such as the following

    sprintf(buf, "%s some further text", buf);

to append text to buf.  However, the standards explicitly note that the
results are undefined if source and destination  buffers  overlap  when
calling  sprintf(), snprintf(), vsprintf(), and vsnprintf()...
jdoerfert accepted this revision.Aug 14 2019, 9:35 AM

LGTM.

This revision is now accepted and ready to land.Aug 14 2019, 9:35 AM
Closed by commit rL368875: [BuildLibCalls] Noalias annotation (authored by xbolva00). · Explain WhyAug 14 2019, 9:49 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
trunk/
lib/
Transforms/
Utils/
16 lines
9 lines
test/
Analysis/
TypeBasedAliasAnalysis/
2 lines
Other/
2 lines
2 lines
Transforms/
InferFunctionAttrs/
10 lines
InstCombine/
78 lines
4 lines
4 lines
16 lines
6 lines
2 lines
6 lines
2 lines
2 lines
8 lines
16 lines
6 lines
8 lines
6 lines
MemCpyOpt/
2 lines

Diff 215146

llvm/trunk/lib/Transforms/Utils/BuildLibCalls.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
static bool setDoesNotCapture(Function &F, unsigned ArgNo) { static bool setDoesNotCapture(Function &F, unsigned ArgNo) {
if (F.hasParamAttribute(ArgNo, Attribute::NoCapture)) if (F.hasParamAttribute(ArgNo, Attribute::NoCapture))
return false; return false;
F.addParamAttr(ArgNo, Attribute::NoCapture); F.addParamAttr(ArgNo, Attribute::NoCapture);
++NumNoCapture; ++NumNoCapture;
return true; return true;
} }
static bool setDoesNotAlias(Function &F, unsigned ArgNo) {
if (F.hasParamAttribute(ArgNo, Attribute::NoAlias))
return false;
F.addParamAttr(ArgNo, Attribute::NoAlias);
++NumNoAlias;
return true;
}
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;
} }
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Linesbool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) {
case LibFunc_strtold: case LibFunc_strtold:
case LibFunc_strtoull: case LibFunc_strtoull:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 0); Changed |= setOnlyReadsMemory(F, 0);
return Changed; return Changed;
case LibFunc_strcpy: case LibFunc_strcpy:
case LibFunc_strncpy: case LibFunc_strncpy:
Changed |= setDoesNotAlias(F, 0);
Changed |= setDoesNotAlias(F, 1);
LLVM_FALLTHROUGH;
case LibFunc_strcat: case LibFunc_strcat:
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 |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines case LibFunc_sscanf:
Changed |= setDoesNotCapture(F, 0); Changed |= setDoesNotCapture(F, 0);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
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 |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 0); Changed |= setDoesNotCapture(F, 0);
Changed |= setDoesNotAlias(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 |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 0); Changed |= setDoesNotCapture(F, 0);
Changed |= setDoesNotAlias(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 |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
Show All 20 Lines case LibFunc_memrchr:
return Changed; return Changed;
case LibFunc_modf: case LibFunc_modf:
case LibFunc_modff: case LibFunc_modff:
case LibFunc_modfl: 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 |= setDoesNotAlias(F, 0);
Changed |= setDoesNotAlias(F, 1);
LLVM_FALLTHROUGH;
case LibFunc_memmove: case LibFunc_memmove:
Changed |= setReturnedArg(F, 0); Changed |= setReturnedArg(F, 0);
LLVM_FALLTHROUGH; LLVM_FALLTHROUGH;
case LibFunc_mempcpy: case LibFunc_mempcpy:
case LibFunc_memccpy: case LibFunc_memccpy:
Changed |= setDoesNotThrow(F); Changed |= setDoesNotThrow(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setOnlyReadsMemory(F, 1); Changed |= setOnlyReadsMemory(F, 1);
▲ Show 20 Lines • Show All 1,064 Lines • Show Last 20 Lines

llvm/trunk/lib/Transforms/Utils/SimplifyLibCalls.cpp

Show First 20 Lines • Show All 454 Lines • ▼ Show 20 LinesValue *LibCallSimplifier::optimizeStrNCmp(CallInst *CI, IRBuilder<> &B) {
return nullptr; return nullptr;
} }
Value *LibCallSimplifier::optimizeStrCpy(CallInst *CI, IRBuilder<> &B) { Value *LibCallSimplifier::optimizeStrCpy(CallInst *CI, IRBuilder<> &B) {
Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1); Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1);
if (Dst == Src) // strcpy(x,x) -> x if (Dst == Src) // strcpy(x,x) -> x
return Src; return Src;
CI->addParamAttr(0, Attribute::NoAlias);
CI->addParamAttr(1, Attribute::NoAlias);
// See if we can get the length of the input string. // See if we can get the length of the input string.
uint64_t Len = GetStringLength(Src); uint64_t Len = GetStringLength(Src);
if (Len == 0) if (Len == 0)
return nullptr; return nullptr;
// We have enough information to now generate the memcpy call to do the // We have enough information to now generate the memcpy call to do the
// copy for us. Make a memcpy to copy the nul byte with align = 1. // copy for us. Make a memcpy to copy the nul byte with align = 1.
B.CreateMemCpy(Dst, 1, Src, 1, B.CreateMemCpy(Dst, 1, Src, 1,
Show All 26 Lines
} }
Value *LibCallSimplifier::optimizeStrNCpy(CallInst *CI, IRBuilder<> &B) { Value *LibCallSimplifier::optimizeStrNCpy(CallInst *CI, IRBuilder<> &B) {
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
Value *Dst = CI->getArgOperand(0); Value *Dst = CI->getArgOperand(0);
Value *Src = CI->getArgOperand(1); Value *Src = CI->getArgOperand(1);
Value *LenOp = CI->getArgOperand(2); Value *LenOp = CI->getArgOperand(2);
CI->addParamAttr(0, Attribute::NoAlias);
CI->addParamAttr(1, Attribute::NoAlias);
// See if we can get the length of the input string. // See if we can get the length of the input string.
uint64_t SrcLen = GetStringLength(Src); uint64_t SrcLen = GetStringLength(Src);
if (SrcLen == 0) if (SrcLen == 0)
return nullptr; return nullptr;
--SrcLen; --SrcLen;
if (SrcLen == 0) { if (SrcLen == 0) {
// strncpy(x, "", y) -> memset(align 1 x, '\0', y) // strncpy(x, "", y) -> memset(align 1 x, '\0', y)
▲ Show 20 Lines • Show All 465 Lines • ▼ Show 20 Lines
} }
Value *LibCallSimplifier::optimizeMemCpy(CallInst *CI, IRBuilder<> &B, Value *LibCallSimplifier::optimizeMemCpy(CallInst *CI, IRBuilder<> &B,
bool isIntrinsic) { bool isIntrinsic) {
Value *Size = CI->getArgOperand(2); Value *Size = CI->getArgOperand(2);
if (ConstantInt *LenC = dyn_cast<ConstantInt>(Size)) if (ConstantInt *LenC = dyn_cast<ConstantInt>(Size))
annotateDereferenceableBytes(CI, {0, 1}, LenC->getZExtValue()); annotateDereferenceableBytes(CI, {0, 1}, LenC->getZExtValue());
CI->addParamAttr(0, Attribute::NoAlias);
CI->addParamAttr(1, Attribute::NoAlias);
if (isIntrinsic) if (isIntrinsic)
return nullptr; return nullptr;
// memcpy(x, y, n) -> llvm.memcpy(align 1 x, align 1 y, n) // memcpy(x, y, n) -> llvm.memcpy(align 1 x, align 1 y, n)
B.CreateMemCpy(CI->getArgOperand(0), 1, CI->getArgOperand(1), 1, Size); B.CreateMemCpy(CI->getArgOperand(0), 1, CI->getArgOperand(1), 1, Size);
return CI->getArgOperand(0); return CI->getArgOperand(0);
} }
▲ Show 20 Lines • Show All 2,200 Lines • Show Last 20 Lines

llvm/trunk/test/Analysis/TypeBasedAliasAnalysis/memcpyopt.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 -tbaa -basicaa -memcpyopt -instcombine < %s | FileCheck %s ; RUN: opt -S -tbaa -basicaa -memcpyopt -instcombine < %s | FileCheck %s
target datalayout = "e-p:64:64:64" target datalayout = "e-p:64:64:64"
; The second memcpy is redundant and can be deleted. There's an intervening store, but ; The second memcpy is redundant and can be deleted. There's an intervening store, but
; it has a TBAA tag which declares that it is unrelated. ; it has a TBAA tag which declares that it is unrelated.
define void @foo(i8* nocapture %p, i8* nocapture %q, i8* nocapture %s) nounwind { define void @foo(i8* nocapture %p, i8* nocapture %q, i8* nocapture %s) nounwind {
; CHECK: @foo ; CHECK: @foo
; CHECK-NEXT: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias align 1 dereferenceable(16) %p, i8* noalias align 1 dereferenceable(16) %q, i64 16, i1 false), !tbaa !0 ; CHECK-NEXT: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(16) %p, i8* align 1 dereferenceable(16) %q, i64 16, i1 false), !tbaa !0
; CHECK-NEXT: store i8 2, i8* %s, align 1, !tbaa [[TAGA:!.*]] ; CHECK-NEXT: store i8 2, i8* %s, align 1, !tbaa [[TAGA:!.*]]
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %p, i8* %q, i64 16, i1 false), !tbaa !2 tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %p, i8* %q, i64 16, i1 false), !tbaa !2
store i8 2, i8* %s, align 1, !tbaa !1 store i8 2, i8* %s, align 1, !tbaa !1
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %q, i8* %p, i64 16, i1 false), !tbaa !2 tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %q, i8* %p, i64 16, i1 false), !tbaa !2
ret void ret void
} }
Show All 9 Lines

llvm/trunk/test/Other/cgscc-devirt-iteration.ll

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Linesentry:
call void %f2() readonly call void %f2() readonly
; BEFORE: call void %f2() ; BEFORE: call void %f2()
; AFTER: call void @readnone() ; AFTER: call void @readnone()
ret void ret void
} }
declare i8* @memcpy(i8*, i8*, i64) declare i8* @memcpy(i8*, i8*, i64)
; CHECK-LABEL: declare i8* @memcpy( ; CHECK-LABEL: i8* @memcpy(
; The @test3 function checks that when we refine an indirect call to an ; The @test3 function checks that when we refine an indirect call to an
; intrinsic we still revisit the SCC pass. This also covers cases where the ; intrinsic we still revisit the SCC pass. This also covers cases where the
; value handle itself doesn't persist due to the nature of how instcombine ; value handle itself doesn't persist due to the nature of how instcombine
; creates the memcpy intrinsic call, and we rely on the count of indirect calls ; creates the memcpy intrinsic call, and we rely on the count of indirect calls
; decreasing and the count of direct calls increasing. ; decreasing and the count of direct calls increasing.
; Adding 'noinline' attribute to force attributes for improved matching. ; Adding 'noinline' attribute to force attributes for improved matching.
define void @test3(i8* %src, i8* %dest, i64 %size) noinline { define void @test3(i8* %src, i8* %dest, i64 %size) noinline {
Show All 24 Lines

llvm/trunk/test/Other/cgscc-libcall-update.ll

Show All 12 Lines
bb: bb:
%tmp = alloca [1024 x i8], align 16 %tmp = alloca [1024 x i8], align 16
%tmp2 = getelementptr inbounds [1024 x i8], [1024 x i8]* %tmp, i64 0, i64 0 %tmp2 = getelementptr inbounds [1024 x i8], [1024 x i8]* %tmp, i64 0, i64 0
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %tmp2, i8* %arg1, i64 1024, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %tmp2, i8* %arg1, i64 1024, i1 false)
; CHECK: call void @llvm.memcpy ; CHECK: call void @llvm.memcpy
%tmp3 = call i64 @llvm.objectsize.i64.p0i8(i8* %tmp2, i1 false, i1 true, i1 false) %tmp3 = call i64 @llvm.objectsize.i64.p0i8(i8* %tmp2, i1 false, i1 true, i1 false)
%tmp4 = call i8* @__strncpy_chk(i8* %arg2, i8* %tmp2, i64 1023, i64 %tmp3) %tmp4 = call i8* @__strncpy_chk(i8* %arg2, i8* %tmp2, i64 1023, i64 %tmp3)
; CHECK-NOT: call ; CHECK-NOT: call
; CHECK: call i8* @strncpy(i8* noalias %arg2, i8* noalias nonnull %tmp2, i64 1023) ; CHECK: call i8* @strncpy(i8* %arg2, i8* nonnull %tmp2, i64 1023)
; CHECK-NOT: call ; CHECK-NOT: call
ret i8* %tmp4 ret i8* %tmp4
; CHECK: ret ; CHECK: ret
} }
define i8* @strncpy(i8* %arg1, i8* %arg2, i64 %size) noinline { define i8* @strncpy(i8* %arg1, i8* %arg2, i64 %size) noinline {
bb: bb:
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/InferFunctionAttrs/annotate.ll

Show First 20 Lines • Show All 622 Lines • ▼ Show 20 Lines
declare i8* @memccpy(i8*, i8*, i32, i64) declare i8* @memccpy(i8*, i8*, i32, i64)
; CHECK: declare i8* @memchr(i8*, i32, i64) [[G2]] ; CHECK: declare i8* @memchr(i8*, i32, i64) [[G2]]
declare i8* @memchr(i8*, i32, i64) declare i8* @memchr(i8*, i32, i64)
; CHECK: declare i32 @memcmp(i8* nocapture, i8* nocapture, i64) [[G2]] ; CHECK: declare i32 @memcmp(i8* nocapture, i8* nocapture, i64) [[G2]]
declare i32 @memcmp(i8*, i8*, i64) declare i32 @memcmp(i8*, i8*, i64)
; CHECK: declare i8* @memcpy(i8* returned, i8* nocapture readonly, i64) [[G1]] ; CHECK: declare i8* @memcpy(i8* noalias returned, i8* noalias nocapture readonly, i64) [[G1]]
declare i8* @memcpy(i8*, i8*, i64) declare i8* @memcpy(i8*, i8*, i64)
; CHECK: declare i8* @mempcpy(i8*, i8* nocapture readonly, i64) [[G1]] ; CHECK: declare i8* @mempcpy(i8*, i8* nocapture readonly, i64) [[G1]]
declare i8* @mempcpy(i8*, i8*, i64) declare i8* @mempcpy(i8*, i8*, i64)
; CHECK: declare i8* @memmove(i8* returned, i8* nocapture readonly, i64) [[G1]] ; CHECK: declare i8* @memmove(i8* returned, i8* nocapture readonly, i64) [[G1]]
declare i8* @memmove(i8*, i8*, i64) declare i8* @memmove(i8*, i8*, i64)
▲ Show 20 Lines • Show All 148 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 i32 @snprintf(i8* nocapture, i64, i8* nocapture readonly, ...) [[G1]] ; CHECK: declare i32 @snprintf(i8* noalias nocapture, i64, i8* nocapture readonly, ...) [[G1]]
declare i32 @snprintf(i8*, i64, i8*, ...) declare i32 @snprintf(i8*, i64, i8*, ...)
; CHECK: declare i32 @sprintf(i8* nocapture, i8* nocapture readonly, ...) [[G1]] ; CHECK: declare i32 @sprintf(i8* noalias nocapture, i8* nocapture 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 31 Lines
declare i8* @strchr(i8*, i32) declare i8* @strchr(i8*, i32)
; CHECK: declare i32 @strcmp(i8* nocapture, i8* nocapture) [[G2]] ; CHECK: declare i32 @strcmp(i8* nocapture, i8* nocapture) [[G2]]
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* returned, i8* nocapture readonly) [[G1]] ; CHECK: declare i8* @strcpy(i8* noalias returned, i8* noalias nocapture readonly) [[G1]]
declare i8* @strcpy(i8*, i8*) declare i8* @strcpy(i8*, i8*)
; CHECK: declare i64 @strcspn(i8* nocapture, i8* nocapture) [[G2]] ; CHECK: declare i64 @strcspn(i8* nocapture, i8* nocapture) [[G2]]
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) [[G4:#[0-9]+]] ; CHECK: declare i64 @strlen(i8* nocapture) [[G4:#[0-9]+]]
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* returned, i8* nocapture readonly, i64) [[G1]] ; CHECK: declare i8* @strncat(i8* returned, i8* nocapture readonly, i64) [[G1]]
declare i8* @strncat(i8*, i8*, i64) declare i8* @strncat(i8*, i8*, i64)
; CHECK: declare i32 @strncmp(i8* nocapture, i8* nocapture, i64) [[G2]] ; CHECK: declare i32 @strncmp(i8* nocapture, i8* nocapture, i64) [[G2]]
declare i32 @strncmp(i8*, i8*, i64) declare i32 @strncmp(i8*, i8*, i64)
; CHECK: declare i8* @strncpy(i8* returned, i8* nocapture readonly, i64) [[G1]] ; CHECK: declare i8* @strncpy(i8* noalias returned, i8* noalias nocapture readonly, i64) [[G1]]
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 140 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/InstCombine/annotate-noalias.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -instcombine -S < %s | FileCheck %s
declare i8* @memcpy(i8* nocapture, i8* nocapture, i64)
declare i8* @strncpy(i8* nocapture, i8* nocapture, i64)
declare i8* @strcpy(i8* nocapture, i8* nocapture)
define i8* @memcpy_const_size_noalias(i8* nocapture readonly %d, i8* nocapture readonly %s) {
; CHECK-LABEL: @memcpy_const_size_noalias(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias align 1 dereferenceable(16) [[D:%.*]], i8* noalias align 1 dereferenceable(16) [[S:%.*]], i64 16, i1 false)
; CHECK-NEXT: ret i8* [[D]]
;
%call = tail call i8* @memcpy(i8* %d, i8* %s, i64 16)
ret i8* %call
}
define i8* @memcpy_const_zero_size_noalias(i8* nocapture readonly %d, i8* nocapture readonly %s) {
; CHECK-LABEL: @memcpy_const_zero_size_noalias(
; CHECK-NEXT: ret i8* [[D:%.*]]
;
%call = tail call i8* @memcpy(i8* %d, i8* %s, i64 0)
ret i8* %call
}
define i8* @memcpy_nonconst_size_noalias(i8* nocapture readonly %d, i8* nocapture readonly %s, i64 %n) {
; CHECK-LABEL: @memcpy_nonconst_size_noalias(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias align 1 [[D:%.*]], i8* noalias align 1 [[S:%.*]], i64 [[N:%.*]], i1 false)
; CHECK-NEXT: ret i8* [[D]]
;
%call = tail call i8* @memcpy(i8* %d, i8* %s, i64 %n)
ret i8* %call
}
define i8* @strncpy_const_size_noalias(i8* nocapture readonly %d, i8* nocapture readonly %s) {
; CHECK-LABEL: @strncpy_const_size_noalias(
; CHECK-NEXT: [[CALL:%.*]] = tail call i8* @strncpy(i8* noalias [[D:%.*]], i8* noalias [[S:%.*]], i64 16)
; CHECK-NEXT: ret i8* [[CALL]]
;
%call = tail call i8* @strncpy(i8* %d, i8* %s, i64 16)
ret i8* %call
}
define i8* @strncpy_const_zero_size_noalias(i8* nocapture readonly %d, i8* nocapture readonly %s) {
; CHECK-LABEL: @strncpy_const_zero_size_noalias(
; CHECK-NEXT: [[CALL:%.*]] = tail call i8* @strncpy(i8* noalias [[D:%.*]], i8* noalias [[S:%.*]], i64 0)
; CHECK-NEXT: ret i8* [[CALL]]
;
%call = tail call i8* @strncpy(i8* %d, i8* %s, i64 0)
ret i8* %call
}
define i8* @strncpy_nonconst_size_noalias(i8* nocapture readonly %d, i8* nocapture readonly %s, i64 %n) {
; CHECK-LABEL: @strncpy_nonconst_size_noalias(
; CHECK-NEXT: [[CALL:%.*]] = tail call i8* @strncpy(i8* noalias [[D:%.*]], i8* noalias [[S:%.*]], i64 [[N:%.*]])
; CHECK-NEXT: ret i8* [[CALL]]
;
%call = tail call i8* @strncpy(i8* %d, i8* %s, i64 %n)
ret i8* %call
}
define i8* @strcpy_const_size_noalias(i8* nocapture readonly %d, i8* nocapture readonly %s) {
; CHECK-LABEL: @strcpy_const_size_noalias(
; CHECK-NEXT: [[CALL:%.*]] = tail call i8* @strcpy(i8* noalias [[D:%.*]], i8* noalias [[S:%.*]])
; CHECK-NEXT: ret i8* [[CALL]]
;
%call = tail call i8* @strcpy(i8* %d, i8* %s)
ret i8* %call
}
define i8* @strcpy_nonconst_size_noalias(i8* nocapture readonly %d, i8* nocapture readonly %s) {
; CHECK-LABEL: @strcpy_nonconst_size_noalias(
; CHECK-NEXT: [[CALL:%.*]] = tail call i8* @strcpy(i8* noalias [[D:%.*]], i8* noalias [[S:%.*]])
; CHECK-NEXT: ret i8* [[CALL]]
;
%call = tail call i8* @strcpy(i8* %d, i8* %s)
ret i8* %call
}

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

Show First 20 Lines • Show All 78 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* noalias align 1 dereferenceable(64) [[D:%.*]], i8* noalias align 1 dereferenceable(64) [[S:%.*]], i64 64, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(64) [[D:%.*]], i8* 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(
Show All 19 Lines
; 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(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias align 1 dereferenceable(16) [[D:%.*]], i8* noalias align 1 dereferenceable(16) [[S:%.*]], i64 16, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(16) [[D:%.*]], i8* align 1 dereferenceable(16) [[S:%.*]], i64 16, i1 false)
; CHECK-NEXT: ret i8* [[D]] ; CHECK-NEXT: ret i8* [[D]]
; ;
call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %d, i8* align 1 %s, i64 16, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %d, i8* align 1 %s, i64 16, i1 false)
ret i8* %d ret i8* %d
} }
define i8* @llvm_memmove_const_size_set_deref(i8* nocapture readonly %d, i8* nocapture readonly %s) { define i8* @llvm_memmove_const_size_set_deref(i8* nocapture readonly %d, i8* nocapture readonly %s) {
; CHECK-LABEL: @llvm_memmove_const_size_set_deref( ; CHECK-LABEL: @llvm_memmove_const_size_set_deref(
Show All 14 Lines

llvm/trunk/test/Transforms/InstCombine/memcpy-1.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test that the memcpy library call simplifier works correctly. ; Test that the memcpy library call simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -instcombine -S | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
declare i8* @memcpy(i8*, i8*, i32) declare i8* @memcpy(i8*, i8*, i32)
; Check memcpy(mem1, mem2, size) -> llvm.memcpy(mem1, mem2, size, 1). ; Check memcpy(mem1, mem2, size) -> llvm.memcpy(mem1, mem2, size, 1).
define i8* @test_simplify1(i8* %mem1, i8* %mem2, i32 %size) { define i8* @test_simplify1(i8* %mem1, i8* %mem2, i32 %size) {
; CHECK-LABEL: @test_simplify1( ; CHECK-LABEL: @test_simplify1(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias align 1 [[MEM1:%.*]], i8* noalias align 1 [[MEM2:%.*]], i32 [[SIZE:%.*]], i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[MEM1:%.*]], i8* align 1 [[MEM2:%.*]], i32 [[SIZE:%.*]], i1 false)
; CHECK-NEXT: ret i8* [[MEM1]] ; CHECK-NEXT: ret i8* [[MEM1]]
; ;
%ret = call i8* @memcpy(i8* %mem1, i8* %mem2, i32 %size) %ret = call i8* @memcpy(i8* %mem1, i8* %mem2, i32 %size)
ret i8* %ret ret i8* %ret
} }
; Verify that the strictfp attr doesn't block this optimization. ; Verify that the strictfp attr doesn't block this optimization.
define i8* @test_simplify2(i8* %mem1, i8* %mem2, i32 %size) { define i8* @test_simplify2(i8* %mem1, i8* %mem2, i32 %size) {
; CHECK-LABEL: @test_simplify2( ; CHECK-LABEL: @test_simplify2(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias align 1 [[MEM1:%.*]], i8* noalias align 1 [[MEM2:%.*]], i32 [[SIZE:%.*]], i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[MEM1:%.*]], i8* align 1 [[MEM2:%.*]], i32 [[SIZE:%.*]], i1 false)
; CHECK-NEXT: ret i8* [[MEM1]] ; CHECK-NEXT: ret i8* [[MEM1]]
; ;
%ret = call i8* @memcpy(i8* %mem1, i8* %mem2, i32 %size) strictfp %ret = call i8* @memcpy(i8* %mem1, i8* %mem2, i32 %size) strictfp
ret i8* %ret ret i8* %ret
} }

llvm/trunk/test/Transforms/InstCombine/memcpy-from-global.ll

Show First 20 Lines • Show All 72 Lines • ▼ Show 20 Lines
@G = constant %T {i8 1, [123 x i8] zeroinitializer } @G = constant %T {i8 1, [123 x i8] zeroinitializer }
@H = constant [2 x %U] zeroinitializer, align 16 @H = constant [2 x %U] zeroinitializer, align 16
define void @test2() { define void @test2() {
; CHECK-LABEL: @test2( ; CHECK-LABEL: @test2(
; CHECK-NEXT: [[B1:%.*]] = alloca [124 x i8], align 8 ; CHECK-NEXT: [[B1:%.*]] = alloca [124 x i8], align 8
; CHECK-NEXT: [[B1_SUB:%.*]] = getelementptr inbounds [124 x i8], [124 x i8]* [[B1]], i64 0, i64 0 ; CHECK-NEXT: [[B1_SUB:%.*]] = getelementptr inbounds [124 x i8], [124 x i8]* [[B1]], i64 0, i64 0
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias nonnull align 8 dereferenceable(124) [[B1_SUB]], i8* noalias align 16 dereferenceable(124) getelementptr inbounds (%T, %T* @G, i64 0, i32 0), i64 124, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 8 dereferenceable(124) [[B1_SUB]], i8* align 16 dereferenceable(124) getelementptr inbounds (%T, %T* @G, i64 0, i32 0), i64 124, i1 false)
; CHECK-NEXT: call void @bar(i8* nonnull [[B1_SUB]]) ; CHECK-NEXT: call void @bar(i8* nonnull [[B1_SUB]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%A = alloca %T %A = alloca %T
%B = alloca %T %B = alloca %T
%a = bitcast %T* %A to i8* %a = bitcast %T* %A to i8*
%b = bitcast %T* %B to i8* %b = bitcast %T* %B to i8*
; %A alloca is deleted ; %A alloca is deleted
; use @G instead of %A ; use @G instead of %A
call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %a, i8* align 4 bitcast (%T* @G to i8*), i64 124, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %a, i8* align 4 bitcast (%T* @G to i8*), i64 124, i1 false)
call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %b, i8* align 4 %a, i64 124, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %b, i8* align 4 %a, i64 124, i1 false)
call void @bar(i8* %b) call void @bar(i8* %b)
ret void ret void
} }
define void @test2_no_null_opt() #0 { define void @test2_no_null_opt() #0 {
; CHECK-LABEL: @test2_no_null_opt( ; CHECK-LABEL: @test2_no_null_opt(
; CHECK-NEXT: [[B1:%.*]] = alloca [124 x i8], align 8 ; CHECK-NEXT: [[B1:%.*]] = alloca [124 x i8], align 8
; CHECK-NEXT: [[B1_SUB:%.*]] = getelementptr inbounds [124 x i8], [124 x i8]* [[B1]], i64 0, i64 0 ; CHECK-NEXT: [[B1_SUB:%.*]] = getelementptr inbounds [124 x i8], [124 x i8]* [[B1]], i64 0, i64 0
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias align 8 dereferenceable(124) [[B1_SUB]], i8* noalias align 16 dereferenceable(124) getelementptr inbounds (%T, %T* @G, i64 0, i32 0), i64 124, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 dereferenceable(124) [[B1_SUB]], i8* align 16 dereferenceable(124) getelementptr inbounds (%T, %T* @G, i64 0, i32 0), i64 124, i1 false)
; CHECK-NEXT: call void @bar(i8* [[B1_SUB]]) ; CHECK-NEXT: call void @bar(i8* [[B1_SUB]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%A = alloca %T %A = alloca %T
%B = alloca %T %B = alloca %T
%a = bitcast %T* %A to i8* %a = bitcast %T* %A to i8*
%b = bitcast %T* %B to i8* %b = bitcast %T* %B to i8*
; %A alloca is deleted ; %A alloca is deleted
; use @G instead of %A ; use @G instead of %A
call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %a, i8* align 4 bitcast (%T* @G to i8*), i64 124, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %a, i8* align 4 bitcast (%T* @G to i8*), i64 124, i1 false)
call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %b, i8* align 4 %a, i64 124, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %b, i8* align 4 %a, i64 124, i1 false)
call void @bar(i8* %b) call void @bar(i8* %b)
ret void ret void
} }
define void @test2_addrspacecast() { define void @test2_addrspacecast() {
; CHECK-LABEL: @test2_addrspacecast( ; CHECK-LABEL: @test2_addrspacecast(
; CHECK-NEXT: [[B1:%.*]] = alloca [124 x i8], align 8 ; CHECK-NEXT: [[B1:%.*]] = alloca [124 x i8], align 8
; CHECK-NEXT: [[B1_SUB:%.*]] = getelementptr inbounds [124 x i8], [124 x i8]* [[B1]], i64 0, i64 0 ; CHECK-NEXT: [[B1_SUB:%.*]] = getelementptr inbounds [124 x i8], [124 x i8]* [[B1]], i64 0, i64 0
; CHECK-NEXT: [[B:%.*]] = addrspacecast i8* [[B1_SUB]] to i8 addrspace(1)* ; CHECK-NEXT: [[B:%.*]] = addrspacecast i8* [[B1_SUB]] to i8 addrspace(1)*
; CHECK-NEXT: call void @llvm.memcpy.p1i8.p1i8.i64(i8 addrspace(1)* noalias align 4 dereferenceable(124) [[B]], i8 addrspace(1)* noalias align 4 dereferenceable(124) addrspacecast (i8* getelementptr inbounds (%T, %T* @G, i64 0, i32 0) to i8 addrspace(1)*), i64 124, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p1i8.p1i8.i64(i8 addrspace(1)* align 4 dereferenceable(124) [[B]], i8 addrspace(1)* align 4 dereferenceable(124) addrspacecast (i8* getelementptr inbounds (%T, %T* @G, i64 0, i32 0) to i8 addrspace(1)*), i64 124, i1 false)
; CHECK-NEXT: call void @bar_as1(i8 addrspace(1)* [[B]]) ; CHECK-NEXT: call void @bar_as1(i8 addrspace(1)* [[B]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%A = alloca %T %A = alloca %T
%B = alloca %T %B = alloca %T
%a = addrspacecast %T* %A to i8 addrspace(1)* %a = addrspacecast %T* %A to i8 addrspace(1)*
%b = addrspacecast %T* %B to i8 addrspace(1)* %b = addrspacecast %T* %B to i8 addrspace(1)*
▲ Show 20 Lines • Show All 92 Lines • ▼ Show 20 Lines;
call void @bar(i8* %a) readonly call void @bar(i8* %a) readonly
ret void ret void
} }
define void @test8() { define void @test8() {
; CHECK-LABEL: @test8( ; CHECK-LABEL: @test8(
; CHECK-NEXT: [[AL:%.*]] = alloca [[U:%.*]], align 16 ; CHECK-NEXT: [[AL:%.*]] = alloca [[U:%.*]], align 16
; CHECK-NEXT: [[A:%.*]] = bitcast %U* [[AL]] to i8* ; CHECK-NEXT: [[A:%.*]] = bitcast %U* [[AL]] to i8*
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias nonnull align 16 dereferenceable(20) [[A]], i8* noalias align 4 dereferenceable(20) bitcast (%U* getelementptr inbounds ([2 x %U], [2 x %U]* @H, i64 0, i64 1) to i8*), i64 20, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 16 dereferenceable(20) [[A]], i8* align 4 dereferenceable(20) bitcast (%U* getelementptr inbounds ([2 x %U], [2 x %U]* @H, i64 0, i64 1) to i8*), i64 20, i1 false)
; CHECK-NEXT: call void @bar(i8* nonnull [[A]]) #2 ; CHECK-NEXT: call void @bar(i8* nonnull [[A]]) #2
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%al = alloca %U, align 16 %al = alloca %U, align 16
%a = bitcast %U* %al to i8* %a = bitcast %U* %al to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %a, i8* align 4 bitcast (%U* getelementptr ([2 x %U], [2 x %U]* @H, i64 0, i32 1) to i8*), i64 20, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %a, i8* align 4 bitcast (%U* getelementptr ([2 x %U], [2 x %U]* @H, i64 0, i32 1) to i8*), i64 20, i1 false)
call void @bar(i8* %a) readonly call void @bar(i8* %a) readonly
ret void ret void
} }
define void @test8_addrspacecast() { define void @test8_addrspacecast() {
; CHECK-LABEL: @test8_addrspacecast( ; CHECK-LABEL: @test8_addrspacecast(
; CHECK-NEXT: [[AL:%.*]] = alloca [[U:%.*]], align 16 ; CHECK-NEXT: [[AL:%.*]] = alloca [[U:%.*]], align 16
; CHECK-NEXT: [[A:%.*]] = bitcast %U* [[AL]] to i8* ; CHECK-NEXT: [[A:%.*]] = bitcast %U* [[AL]] to i8*
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p1i8.i64(i8* noalias nonnull align 16 dereferenceable(20) [[A]], i8 addrspace(1)* noalias align 4 dereferenceable(20) addrspacecast (i8* bitcast (%U* getelementptr inbounds ([2 x %U], [2 x %U]* @H, i64 0, i64 1) to i8*) to i8 addrspace(1)*), i64 20, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p1i8.i64(i8* nonnull align 16 dereferenceable(20) [[A]], i8 addrspace(1)* align 4 dereferenceable(20) addrspacecast (i8* bitcast (%U* getelementptr inbounds ([2 x %U], [2 x %U]* @H, i64 0, i64 1) to i8*) to i8 addrspace(1)*), i64 20, i1 false)
; CHECK-NEXT: call void @bar(i8* nonnull [[A]]) #2 ; CHECK-NEXT: call void @bar(i8* nonnull [[A]]) #2
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%Al = alloca %U, align 16 %Al = alloca %U, align 16
%a = bitcast %U* %Al to i8* %a = bitcast %U* %Al to i8*
call void @llvm.memcpy.p0i8.p1i8.i64(i8* align 4 %a, i8 addrspace(1)* align 4 addrspacecast (%U* getelementptr ([2 x %U], [2 x %U]* @H, i64 0, i32 1) to i8 addrspace(1)*), i64 20, i1 false) call void @llvm.memcpy.p0i8.p1i8.i64(i8* align 4 %a, i8 addrspace(1)* align 4 addrspacecast (%U* getelementptr ([2 x %U], [2 x %U]* @H, i64 0, i32 1) to i8 addrspace(1)*), i64 20, i1 false)
call void @bar(i8* %a) readonly call void @bar(i8* %a) readonly
ret void ret void
Show All 27 Lines
@_ZL3KKK = internal unnamed_addr constant [3 x i8] c"\01\01\02", align 1 @_ZL3KKK = internal unnamed_addr constant [3 x i8] c"\01\01\02", align 1
; Should not replace alloca with global because of size mismatch. ; Should not replace alloca with global because of size mismatch.
define void @test9_small_global() { define void @test9_small_global() {
; CHECK-LABEL: @test9_small_global( ; CHECK-LABEL: @test9_small_global(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[CC:%.*]] = alloca [1000000 x i8], align 16 ; CHECK-NEXT: [[CC:%.*]] = alloca [1000000 x i8], align 16
; CHECK-NEXT: [[ARRAYDECAY:%.*]] = getelementptr inbounds [1000000 x i8], [1000000 x i8]* [[CC]], i64 0, i64 0 ; CHECK-NEXT: [[ARRAYDECAY:%.*]] = getelementptr inbounds [1000000 x i8], [1000000 x i8]* [[CC]], i64 0, i64 0
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias nonnull align 16 dereferenceable(3) [[ARRAYDECAY]], i8* noalias align 16 dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @_ZL3KKK, i64 0, i64 0), i64 3, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 16 dereferenceable(3) [[ARRAYDECAY]], i8* align 16 dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @_ZL3KKK, i64 0, i64 0), i64 3, i1 false)
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias align 16 dereferenceable(1000000) getelementptr inbounds ([1000000 x i8], [1000000 x i8]* @bbb, i64 0, i64 0), i8* noalias nonnull align 16 dereferenceable(1000000) [[ARRAYDECAY]], i64 1000000, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 dereferenceable(1000000) getelementptr inbounds ([1000000 x i8], [1000000 x i8]* @bbb, i64 0, i64 0), i8* nonnull align 16 dereferenceable(1000000) [[ARRAYDECAY]], i64 1000000, i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry: entry:
%cc = alloca [1000000 x i8], align 16 %cc = alloca [1000000 x i8], align 16
%cc.0..sroa_idx = getelementptr inbounds [1000000 x i8], [1000000 x i8]* %cc, i64 0, i64 0 %cc.0..sroa_idx = getelementptr inbounds [1000000 x i8], [1000000 x i8]* %cc, i64 0, i64 0
%arraydecay = getelementptr inbounds [1000000 x i8], [1000000 x i8]* %cc, i32 0, i32 0 %arraydecay = getelementptr inbounds [1000000 x i8], [1000000 x i8]* %cc, i32 0, i32 0
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %arraydecay, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @_ZL3KKK, i32 0, i32 0), i64 3, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %arraydecay, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @_ZL3KKK, i32 0, i32 0), i64 3, i1 false)
call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 getelementptr inbounds ([1000000 x i8], [1000000 x i8]* @bbb, i32 0, i32 0), i8* align 16 %arraydecay, i64 1000000, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 getelementptr inbounds ([1000000 x i8], [1000000 x i8]* @bbb, i32 0, i32 0), i8* align 16 %arraydecay, i64 1000000, i1 false)
ret void ret void
} }
; Should replace alloca with global as they have exactly the same size. ; Should replace alloca with global as they have exactly the same size.
define void @test10_same_global() { define void @test10_same_global() {
; CHECK-LABEL: @test10_same_global( ; CHECK-LABEL: @test10_same_global(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias align 16 dereferenceable(3) getelementptr inbounds ([1000000 x i8], [1000000 x i8]* @bbb, i64 0, i64 0), i8* noalias align 16 dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @_ZL3KKK, i64 0, i64 0), i64 3, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 dereferenceable(3) getelementptr inbounds ([1000000 x i8], [1000000 x i8]* @bbb, i64 0, i64 0), i8* align 16 dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @_ZL3KKK, i64 0, i64 0), i64 3, i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry: entry:
%cc = alloca [3 x i8], align 1 %cc = alloca [3 x i8], align 1
%cc.0..sroa_idx = getelementptr inbounds [3 x i8], [3 x i8]* %cc, i64 0, i64 0 %cc.0..sroa_idx = getelementptr inbounds [3 x i8], [3 x i8]* %cc, i64 0, i64 0
%arraydecay = getelementptr inbounds [3 x i8], [3 x i8]* %cc, i32 0, i32 0 %arraydecay = getelementptr inbounds [3 x i8], [3 x i8]* %cc, i32 0, i32 0
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %arraydecay, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @_ZL3KKK, i32 0, i32 0), i64 3, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %arraydecay, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @_ZL3KKK, i32 0, i32 0), i64 3, i1 false)
call void @llvm.memcpy.p0i8.p0i8.i64(i8* getelementptr inbounds ([1000000 x i8], [1000000 x i8]* @bbb, i32 0, i32 0), i8* %arraydecay, i64 3, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* getelementptr inbounds ([1000000 x i8], [1000000 x i8]* @bbb, i32 0, i32 0), i8* %arraydecay, i64 3, i1 false)
ret void ret void
} }
attributes #0 = { "null-pointer-is-valid"="true" } attributes #0 = { "null-pointer-is-valid"="true" }

llvm/trunk/test/Transforms/InstCombine/memcpy-to-load.ll

Show All 28 Lines;
call void @llvm.memcpy.p0i8.p0i8.i32(i8* %d, i8* %s, i32 2, i1 false) call void @llvm.memcpy.p0i8.p0i8.i32(i8* %d, i8* %s, i32 2, i1 false)
ret void ret void
} }
; We don't expand small non-power-of-2. Should we? Might be a target-dependent choice. ; We don't expand small non-power-of-2. Should we? Might be a target-dependent choice.
define void @copy_3_bytes(i8* %d, i8* %s) { define void @copy_3_bytes(i8* %d, i8* %s) {
; ALL-LABEL: @copy_3_bytes( ; ALL-LABEL: @copy_3_bytes(
; ALL-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias align 1 dereferenceable(3) [[D:%.*]], i8* noalias align 1 dereferenceable(3) [[S:%.*]], i32 3, i1 false) ; ALL-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 dereferenceable(3) [[D:%.*]], i8* align 1 dereferenceable(3) [[S:%.*]], i32 3, i1 false)
; ALL-NEXT: ret void ; ALL-NEXT: ret void
; ;
call void @llvm.memcpy.p0i8.p0i8.i32(i8* %d, i8* %s, i32 3, i1 false) call void @llvm.memcpy.p0i8.p0i8.i32(i8* %d, i8* %s, i32 3, i1 false)
ret void ret void
} }
define void @copy_4_bytes(i8* %d, i8* %s) { define void @copy_4_bytes(i8* %d, i8* %s) {
; ALL-LABEL: @copy_4_bytes( ; ALL-LABEL: @copy_4_bytes(
; ALL-NEXT: [[TMP1:%.*]] = bitcast i8* [[S:%.*]] to i32* ; ALL-NEXT: [[TMP1:%.*]] = bitcast i8* [[S:%.*]] to i32*
; ALL-NEXT: [[TMP2:%.*]] = bitcast i8* [[D:%.*]] to i32* ; ALL-NEXT: [[TMP2:%.*]] = bitcast i8* [[D:%.*]] to i32*
; ALL-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP1]], align 1 ; ALL-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP1]], align 1
; ALL-NEXT: store i32 [[TMP3]], i32* [[TMP2]], align 1 ; ALL-NEXT: store i32 [[TMP3]], i32* [[TMP2]], align 1
; ALL-NEXT: ret void ; ALL-NEXT: ret void
; ;
call void @llvm.memcpy.p0i8.p0i8.i32(i8* %d, i8* %s, i32 4, i1 false) call void @llvm.memcpy.p0i8.p0i8.i32(i8* %d, i8* %s, i32 4, i1 false)
ret void ret void
} }
; We don't expand small non-power-of-2. Should we? Might be a target-dependent choice. ; We don't expand small non-power-of-2. Should we? Might be a target-dependent choice.
define void @copy_5_bytes(i8* %d, i8* %s) { define void @copy_5_bytes(i8* %d, i8* %s) {
; ALL-LABEL: @copy_5_bytes( ; ALL-LABEL: @copy_5_bytes(
; ALL-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias align 1 dereferenceable(5) [[D:%.*]], i8* noalias align 1 dereferenceable(5) [[S:%.*]], i32 5, i1 false) ; ALL-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 dereferenceable(5) [[D:%.*]], i8* align 1 dereferenceable(5) [[S:%.*]], i32 5, i1 false)
; ALL-NEXT: ret void ; ALL-NEXT: ret void
; ;
call void @llvm.memcpy.p0i8.p0i8.i32(i8* %d, i8* %s, i32 5, i1 false) call void @llvm.memcpy.p0i8.p0i8.i32(i8* %d, i8* %s, i32 5, i1 false)
ret void ret void
} }
define void @copy_8_bytes(i8* %d, i8* %s) { define void @copy_8_bytes(i8* %d, i8* %s) {
; ALL-LABEL: @copy_8_bytes( ; ALL-LABEL: @copy_8_bytes(
; ALL-NEXT: [[TMP1:%.*]] = bitcast i8* [[S:%.*]] to i64* ; ALL-NEXT: [[TMP1:%.*]] = bitcast i8* [[S:%.*]] to i64*
; ALL-NEXT: [[TMP2:%.*]] = bitcast i8* [[D:%.*]] to i64* ; ALL-NEXT: [[TMP2:%.*]] = bitcast i8* [[D:%.*]] to i64*
; ALL-NEXT: [[TMP3:%.*]] = load i64, i64* [[TMP1]], align 1 ; ALL-NEXT: [[TMP3:%.*]] = load i64, i64* [[TMP1]], align 1
; ALL-NEXT: store i64 [[TMP3]], i64* [[TMP2]], align 1 ; ALL-NEXT: store i64 [[TMP3]], i64* [[TMP2]], align 1
; ALL-NEXT: ret void ; ALL-NEXT: ret void
; ;
call void @llvm.memcpy.p0i8.p0i8.i32(i8* %d, i8* %s, i32 8, i1 false) call void @llvm.memcpy.p0i8.p0i8.i32(i8* %d, i8* %s, i32 8, i1 false)
ret void ret void
} }
define void @copy_16_bytes(i8* %d, i8* %s) { define void @copy_16_bytes(i8* %d, i8* %s) {
; ALL-LABEL: @copy_16_bytes( ; ALL-LABEL: @copy_16_bytes(
; ALL-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias align 1 dereferenceable(16) [[D:%.*]], i8* noalias align 1 dereferenceable(16) [[S:%.*]], i32 16, i1 false) ; ALL-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 dereferenceable(16) [[D:%.*]], i8* align 1 dereferenceable(16) [[S:%.*]], i32 16, i1 false)
; ALL-NEXT: ret void ; ALL-NEXT: ret void
; ;
call void @llvm.memcpy.p0i8.p0i8.i32(i8* %d, i8* %s, i32 16, i1 false) call void @llvm.memcpy.p0i8.p0i8.i32(i8* %d, i8* %s, i32 16, i1 false)
ret void ret void
} }

llvm/trunk/test/Transforms/InstCombine/memcpy.ll

Show All 23 Lines;
tail call void @llvm.memcpy.p0i8.p0i8.i32(i8* %a, i8* %a, i32 100, i1 true) tail call void @llvm.memcpy.p0i8.p0i8.i32(i8* %a, i8* %a, i32 100, i1 true)
ret void ret void
} }
; 17179869184 == 0x400000000 - make sure that doesn't get truncated to 32-bit. ; 17179869184 == 0x400000000 - make sure that doesn't get truncated to 32-bit.
define void @test3(i8* %d, i8* %s) { define void @test3(i8* %d, i8* %s) {
; CHECK-LABEL: @test3( ; CHECK-LABEL: @test3(
; CHECK-NEXT: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias align 4 dereferenceable(17179869184) [[D:%.*]], i8* noalias align 4 dereferenceable(17179869184) [[S:%.*]], i64 17179869184, i1 false) ; CHECK-NEXT: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 dereferenceable(17179869184) [[D:%.*]], i8* align 4 dereferenceable(17179869184) [[S:%.*]], i64 17179869184, i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %d, i8* align 4 %s, i64 17179869184, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %d, i8* align 4 %s, i64 17179869184, i1 false)
ret void ret void
} }
@UnknownConstant = external constant i128 @UnknownConstant = external constant i128
define void @memcpy_to_constant(i8* %src) { define void @memcpy_to_constant(i8* %src) {
; CHECK-LABEL: @memcpy_to_constant( ; CHECK-LABEL: @memcpy_to_constant(
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%dest = bitcast i128* @UnknownConstant to i8* %dest = bitcast i128* @UnknownConstant to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 16, i1 false) call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 16, i1 false)
ret void ret void
} }

llvm/trunk/test/Transforms/InstCombine/memcpy_chk-1.ll

Show All 12 Lines
@t1 = common global %struct.T1 zeroinitializer @t1 = common global %struct.T1 zeroinitializer
@t2 = common global %struct.T2 zeroinitializer @t2 = common global %struct.T2 zeroinitializer
@t3 = common global %struct.T3 zeroinitializer @t3 = common global %struct.T3 zeroinitializer
; Check cases where dstlen >= len. ; Check cases where dstlen >= len.
define i8* @test_simplify1() { define i8* @test_simplify1() {
; CHECK-LABEL: @test_simplify1( ; CHECK-LABEL: @test_simplify1(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias align 4 dereferenceable(1824) bitcast (%struct.T1* @t1 to i8*), i8* noalias align 4 dereferenceable(1824) bitcast (%struct.T2* @t2 to i8*), i64 1824, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 dereferenceable(1824) bitcast (%struct.T1* @t1 to i8*), i8* align 4 dereferenceable(1824) bitcast (%struct.T2* @t2 to i8*), i64 1824, i1 false)
; CHECK-NEXT: ret i8* bitcast (%struct.T1* @t1 to i8*) ; CHECK-NEXT: ret i8* bitcast (%struct.T1* @t1 to i8*)
; ;
%dst = bitcast %struct.T1* @t1 to i8* %dst = bitcast %struct.T1* @t1 to i8*
%src = bitcast %struct.T2* @t2 to i8* %src = bitcast %struct.T2* @t2 to i8*
%ret = call i8* @__memcpy_chk(i8* %dst, i8* %src, i64 1824, i64 1824) %ret = call i8* @__memcpy_chk(i8* %dst, i8* %src, i64 1824, i64 1824)
ret i8* %ret ret i8* %ret
} }
define i8* @test_simplify2() { define i8* @test_simplify2() {
; CHECK-LABEL: @test_simplify2( ; CHECK-LABEL: @test_simplify2(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias align 4 dereferenceable(1824) bitcast (%struct.T1* @t1 to i8*), i8* noalias align 4 dereferenceable(1824) bitcast (%struct.T3* @t3 to i8*), i64 1824, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 dereferenceable(1824) bitcast (%struct.T1* @t1 to i8*), i8* align 4 dereferenceable(1824) bitcast (%struct.T3* @t3 to i8*), i64 1824, i1 false)
; CHECK-NEXT: ret i8* bitcast (%struct.T1* @t1 to i8*) ; CHECK-NEXT: ret i8* bitcast (%struct.T1* @t1 to i8*)
; ;
%dst = bitcast %struct.T1* @t1 to i8* %dst = bitcast %struct.T1* @t1 to i8*
%src = bitcast %struct.T3* @t3 to i8* %src = bitcast %struct.T3* @t3 to i8*
%ret = call i8* @__memcpy_chk(i8* %dst, i8* %src, i64 1824, i64 2848) %ret = call i8* @__memcpy_chk(i8* %dst, i8* %src, i64 1824, i64 2848)
ret i8* %ret ret i8* %ret
} }
Show All 19 Lines;
%src = bitcast %struct.T2* @t2 to i8* %src = bitcast %struct.T2* @t2 to i8*
%ret = call i8* @__memcpy_chk(i8* %dst, i8* %src, i64 1024, i64 0) %ret = call i8* @__memcpy_chk(i8* %dst, i8* %src, i64 1024, i64 0)
ret i8* %ret ret i8* %ret
} }
define i8* @test_simplify_return_indcall(i8* ()* %alloc) { define i8* @test_simplify_return_indcall(i8* ()* %alloc) {
; CHECK-LABEL: @test_simplify_return_indcall( ; CHECK-LABEL: @test_simplify_return_indcall(
; CHECK-NEXT: [[DST:%.*]] = call i8* [[ALLOC:%.*]]() ; CHECK-NEXT: [[DST:%.*]] = call i8* [[ALLOC:%.*]]()
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias align 1 dereferenceable(1824) [[DST]], i8* noalias align 4 dereferenceable(1824) bitcast (%struct.T2* @t2 to i8*), i64 1824, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(1824) [[DST]], i8* align 4 dereferenceable(1824) bitcast (%struct.T2* @t2 to i8*), i64 1824, i1 false)
; CHECK-NEXT: ret i8* [[DST]] ; CHECK-NEXT: ret i8* [[DST]]
; ;
%src = bitcast %struct.T2* @t2 to i8* %src = bitcast %struct.T2* @t2 to i8*
%dst = call i8* %alloc() %dst = call i8* %alloc()
%ret = call i8* @__memcpy_chk(i8* %dst, i8* %src, i64 1824, i64 1824) %ret = call i8* @__memcpy_chk(i8* %dst, i8* %src, i64 1824, i64 1824)
ret i8* %ret ret i8* %ret
} }
declare i8* @__memcpy_chk(i8*, i8*, i64, i64) declare i8* @__memcpy_chk(i8*, i8*, i64, i64)

llvm/trunk/test/Transforms/InstCombine/memmove.ll

Show All 13 Lines
; ;
call void @llvm.memmove.p0i8.p0i8.i32(i8* %A, i8* %B, i32 0, i1 false) call void @llvm.memmove.p0i8.p0i8.i32(i8* %A, i8* %B, i32 0, i1 false)
ret void ret void
} }
define void @test2(i8* %A, i32 %N) { define void @test2(i8* %A, i32 %N) {
;; dest can't alias source since we can't write to source! ;; dest can't alias source since we can't write to source!
; CHECK-LABEL: @test2( ; CHECK-LABEL: @test2(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias align 1 [[A:%.*]], i8* noalias align 16 getelementptr inbounds ([33 x i8], [33 x i8]* @S, i64 0, i64 0), i32 [[N:%.*]], i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A:%.*]], i8* align 16 getelementptr inbounds ([33 x i8], [33 x i8]* @S, i64 0, i64 0), i32 [[N:%.*]], i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.memmove.p0i8.p0i8.i32(i8* %A, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @S, i32 0, i32 0), i32 %N, i1 false) call void @llvm.memmove.p0i8.p0i8.i32(i8* %A, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @S, i32 0, i32 0), i32 %N, i1 false)
ret void ret void
} }
define i32 @test3([1024 x i8]* %target) { ; arg: [1024 x i8]*> [#uses=1] define i32 @test3([1024 x i8]* %target) { ; arg: [1024 x i8]*> [#uses=1]
; CHECK-LABEL: @test3( ; CHECK-LABEL: @test3(
Show All 40 Lines

llvm/trunk/test/Transforms/InstCombine/objsize.ll

Show First 20 Lines • Show All 157 Lines • ▼ Show 20 Lines
; rdar://7782496 ; rdar://7782496
@s = external global i8* @s = external global i8*
define i8* @test5(i32 %n) nounwind ssp { define i8* @test5(i32 %n) nounwind ssp {
; CHECK-LABEL: @test5( ; CHECK-LABEL: @test5(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = tail call noalias i8* @malloc(i32 20) #0 ; CHECK-NEXT: [[TMP0:%.*]] = tail call noalias i8* @malloc(i32 20) #0
; CHECK-NEXT: [[TMP1:%.*]] = load i8*, i8** @s, align 8 ; CHECK-NEXT: [[TMP1:%.*]] = load i8*, i8** @s, align 8
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias align 1 dereferenceable(10) [[TMP0]], i8* noalias align 1 dereferenceable(10) [[TMP1]], i32 10, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 dereferenceable(10) [[TMP0]], i8* align 1 dereferenceable(10) [[TMP1]], i32 10, i1 false)
; CHECK-NEXT: ret i8* [[TMP0]] ; CHECK-NEXT: ret i8* [[TMP0]]
; ;
entry: entry:
%0 = tail call noalias i8* @malloc(i32 20) nounwind %0 = tail call noalias i8* @malloc(i32 20) nounwind
%1 = tail call i32 @llvm.objectsize.i32.p0i8(i8* %0, i1 false, i1 false, i1 false) %1 = tail call i32 @llvm.objectsize.i32.p0i8(i8* %0, i1 false, i1 false, i1 false)
%2 = load i8*, i8** @s, align 8 %2 = load i8*, i8** @s, align 8
%3 = tail call i8* @__memcpy_chk(i8* %0, i8* %2, i32 10, i32 %1) nounwind %3 = tail call i8* @__memcpy_chk(i8* %0, i8* %2, i32 10, i32 %1) nounwind
ret i8* %0 ret i8* %0
▲ Show 20 Lines • Show All 210 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/InstCombine/sprintf-1.ll

Show All 15 Lines
@percent_s = constant [3 x i8] c"%s\00" @percent_s = constant [3 x i8] c"%s\00"
declare i32 @sprintf(i8*, i8*, ...) declare i32 @sprintf(i8*, i8*, ...)
; Check sprintf(dst, fmt) -> llvm.memcpy(str, fmt, strlen(fmt) + 1, 1). ; Check sprintf(dst, fmt) -> llvm.memcpy(str, fmt, strlen(fmt) + 1, 1).
define void @test_simplify1(i8* %dst) { define void @test_simplify1(i8* %dst) {
; CHECK-LABEL: @test_simplify1( ; CHECK-LABEL: @test_simplify1(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias align 1 dereferenceable(13) [[DST:%.*]], i8* noalias align 1 dereferenceable(13) getelementptr inbounds ([13 x i8], [13 x i8]* @hello_world, i32 0, i32 0), i32 13, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 dereferenceable(13) [[DST:%.*]], i8* align 1 dereferenceable(13) getelementptr inbounds ([13 x i8], [13 x i8]* @hello_world, i32 0, i32 0), i32 13, i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
; CHECK-IPRINTF-LABEL: @test_simplify1( ; CHECK-IPRINTF-LABEL: @test_simplify1(
; CHECK-IPRINTF-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias align 1 dereferenceable(13) [[DST:%.*]], i8* noalias align 1 dereferenceable(13) getelementptr inbounds ([13 x i8], [13 x i8]* @hello_world, i32 0, i32 0), i32 13, i1 false) ; CHECK-IPRINTF-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 dereferenceable(13) [[DST:%.*]], i8* align 1 dereferenceable(13) getelementptr inbounds ([13 x i8], [13 x i8]* @hello_world, i32 0, i32 0), i32 13, i1 false)
; CHECK-IPRINTF-NEXT: ret void ; CHECK-IPRINTF-NEXT: ret void
; ;
%fmt = getelementptr [13 x i8], [13 x i8]* @hello_world, i32 0, i32 0 %fmt = getelementptr [13 x i8], [13 x i8]* @hello_world, i32 0, i32 0
call i32 (i8*, i8*, ...) @sprintf(i8* %dst, i8* %fmt) call i32 (i8*, i8*, ...) @sprintf(i8* %dst, i8* %fmt)
ret void ret void
} }
define void @test_simplify2(i8* %dst) { define void @test_simplify2(i8* %dst) {
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
} }
; Check sprintf(dst, "%s", str) -> llvm.memcpy(dest, str, strlen(str) + 1, 1). ; Check sprintf(dst, "%s", str) -> llvm.memcpy(dest, str, strlen(str) + 1, 1).
define void @test_simplify5(i8* %dst, i8* %str) { define void @test_simplify5(i8* %dst, i8* %str) {
; CHECK-LABEL: @test_simplify5( ; CHECK-LABEL: @test_simplify5(
; CHECK-NEXT: [[STRLEN:%.*]] = call i32 @strlen(i8* [[STR:%.*]]) ; CHECK-NEXT: [[STRLEN:%.*]] = call i32 @strlen(i8* [[STR:%.*]])
; CHECK-NEXT: [[LENINC:%.*]] = add i32 [[STRLEN]], 1 ; CHECK-NEXT: [[LENINC:%.*]] = add i32 [[STRLEN]], 1
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias align 1 [[DST:%.*]], i8* noalias align 1 [[STR]], i32 [[LENINC]], i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[DST:%.*]], i8* align 1 [[STR]], i32 [[LENINC]], i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
; CHECK-IPRINTF-LABEL: @test_simplify5( ; CHECK-IPRINTF-LABEL: @test_simplify5(
; CHECK-IPRINTF-NEXT: [[STRLEN:%.*]] = call i32 @strlen(i8* [[STR:%.*]]) ; CHECK-IPRINTF-NEXT: [[STRLEN:%.*]] = call i32 @strlen(i8* [[STR:%.*]])
; CHECK-IPRINTF-NEXT: [[LENINC:%.*]] = add i32 [[STRLEN]], 1 ; CHECK-IPRINTF-NEXT: [[LENINC:%.*]] = add i32 [[STRLEN]], 1
; CHECK-IPRINTF-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias align 1 [[DST:%.*]], i8* noalias align 1 [[STR]], i32 [[LENINC]], i1 false) ; CHECK-IPRINTF-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[DST:%.*]], i8* align 1 [[STR]], i32 [[LENINC]], i1 false)
; CHECK-IPRINTF-NEXT: ret void ; CHECK-IPRINTF-NEXT: ret void
; ;
%fmt = getelementptr [3 x i8], [3 x i8]* @percent_s, i32 0, i32 0 %fmt = getelementptr [3 x i8], [3 x i8]* @percent_s, i32 0, i32 0
call i32 (i8*, i8*, ...) @sprintf(i8* %dst, i8* %fmt, i8* %str) call i32 (i8*, i8*, ...) @sprintf(i8* %dst, i8* %fmt, i8* %str)
ret void ret void
} }
; Check sprintf(dst, format, ...) -> siprintf(str, format, ...) if no floating. ; Check sprintf(dst, format, ...) -> siprintf(str, format, ...) if no floating.
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/InstCombine/stpcpy-1.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test that the stpcpy library call simplifier works correctly. ; Test that the stpcpy library call simplifier works correctly.
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -instcombine -S | FileCheck %s
; ;
; This transformation requires the pointer size, as it assumes that size_t is ; This transformation requires the pointer size, as it assumes that size_t is
; the size of a pointer. ; the size of a pointer.
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128-n8:16:32" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128-n8:16:32"
@hello = constant [6 x i8] c"hello\00" @hello = constant [6 x i8] c"hello\00"
@a = common global [32 x i8] zeroinitializer, align 1 @a = common global [32 x i8] zeroinitializer, align 1
@b = common global [32 x i8] zeroinitializer, align 1 @b = common global [32 x i8] zeroinitializer, align 1
declare i8* @stpcpy(i8*, i8*) declare i8* @stpcpy(i8*, i8*)
define i8* @test_simplify1() { define i8* @test_simplify1() {
; CHECK-LABEL: @test_simplify1( ; CHECK-LABEL: @test_simplify1(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 dereferenceable(6) getelementptr inbounds ([32 x i8], [32 x i8]* @a, i32 0, i32 0), i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @hello, i32 0, i32 0), i32 6, i1 false)
; CHECK-NEXT: ret i8* getelementptr inbounds ([32 x i8], [32 x i8]* @a, i32 0, i32 5)
;
%dst = getelementptr [32 x i8], [32 x i8]* @a, i32 0, i32 0 %dst = getelementptr [32 x i8], [32 x i8]* @a, i32 0, i32 0
%src = getelementptr [6 x i8], [6 x i8]* @hello, i32 0, i32 0 %src = getelementptr [6 x i8], [6 x i8]* @hello, i32 0, i32 0
%ret = call i8* @stpcpy(i8* %dst, i8* %src) %ret = call i8* @stpcpy(i8* %dst, i8* %src)
; CHECK: @llvm.memcpy.p0i8.p0i8.i32
; CHECK-NEXT: getelementptr inbounds ([32 x i8], [32 x i8]* @a, i32 0, i32 5)
ret i8* %ret ret i8* %ret
} }
define i8* @test_simplify2() { define i8* @test_simplify2() {
; CHECK-LABEL: @test_simplify2( ; CHECK-LABEL: @test_simplify2(
; CHECK-NEXT: [[STRLEN:%.*]] = call i32 @strlen(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @a, i32 0, i32 0))
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds [32 x i8], [32 x i8]* @a, i32 0, i32 [[STRLEN]]
; CHECK-NEXT: ret i8* [[TMP1]]
;
%dst = getelementptr [32 x i8], [32 x i8]* @a, i32 0, i32 0 %dst = getelementptr [32 x i8], [32 x i8]* @a, i32 0, i32 0
%ret = call i8* @stpcpy(i8* %dst, i8* %dst) %ret = call i8* @stpcpy(i8* %dst, i8* %dst)
; CHECK: [[LEN:%[a-z]+]] = call i32 @strlen
; CHECK-NEXT: getelementptr inbounds [32 x i8], [32 x i8]* @a, i32 0, i32 [[LEN]]
ret i8* %ret ret i8* %ret
} }
define i8* @test_no_simplify1() { define i8* @test_no_simplify1() {
; CHECK-LABEL: @test_no_simplify1( ; CHECK-LABEL: @test_no_simplify1(
; CHECK-NEXT: [[RET:%.*]] = call i8* @stpcpy(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @a, i32 0, i32 0), i8* getelementptr inbounds ([32 x i8], [32 x i8]* @b, i32 0, i32 0))
; CHECK-NEXT: ret i8* [[RET]]
;
%dst = getelementptr [32 x i8], [32 x i8]* @a, i32 0, i32 0 %dst = getelementptr [32 x i8], [32 x i8]* @a, i32 0, i32 0
%src = getelementptr [32 x i8], [32 x i8]* @b, i32 0, i32 0 %src = getelementptr [32 x i8], [32 x i8]* @b, i32 0, i32 0
%ret = call i8* @stpcpy(i8* %dst, i8* %src) %ret = call i8* @stpcpy(i8* %dst, i8* %src)
; CHECK: call i8* @stpcpy
ret i8* %ret ret i8* %ret
} }

llvm/trunk/test/Transforms/InstCombine/stpcpy_chk-1.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test lib call simplification of __stpcpy_chk calls with various values ; Test lib call simplification of __stpcpy_chk calls with various values
; for src, dst, and slen. ; for src, dst, and slen.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -instcombine -S | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
@a = common global [60 x i8] zeroinitializer, align 1 @a = common global [60 x i8] zeroinitializer, align 1
@b = common global [60 x i8] zeroinitializer, align 1 @b = common global [60 x i8] zeroinitializer, align 1
@.str = private constant [12 x i8] c"abcdefghijk\00" @.str = private constant [12 x i8] c"abcdefghijk\00"
; Check cases where slen >= strlen (src). ; Check cases where slen >= strlen (src).
define i8* @test_simplify1() { define i8* @test_simplify1() {
; CHECK-LABEL: @test_simplify1( ; CHECK-LABEL: @test_simplify1(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias align 1 dereferenceable(12) getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* noalias align 1 dereferenceable(12) getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i32 0, i32 0), i32 12, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 dereferenceable(12) getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* align 1 dereferenceable(12) getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i32 0, i32 0), i32 12, i1 false)
; CHECK-NEXT: ret i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 11) ; CHECK-NEXT: ret i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 11)
; ;
%dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0 %dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0
%src = getelementptr inbounds [12 x i8], [12 x i8]* @.str, i32 0, i32 0 %src = getelementptr inbounds [12 x i8], [12 x i8]* @.str, i32 0, i32 0
%ret = call i8* @__stpcpy_chk(i8* %dst, i8* %src, i32 60) %ret = call i8* @__stpcpy_chk(i8* %dst, i8* %src, i32 60)
ret i8* %ret ret i8* %ret
} }
define i8* @test_simplify2() { define i8* @test_simplify2() {
; CHECK-LABEL: @test_simplify2( ; CHECK-LABEL: @test_simplify2(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias align 1 dereferenceable(12) getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* noalias align 1 dereferenceable(12) getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i32 0, i32 0), i32 12, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 dereferenceable(12) getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* align 1 dereferenceable(12) getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i32 0, i32 0), i32 12, i1 false)
; CHECK-NEXT: ret i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 11) ; CHECK-NEXT: ret i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 11)
; ;
%dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0 %dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0
%src = getelementptr inbounds [12 x i8], [12 x i8]* @.str, i32 0, i32 0 %src = getelementptr inbounds [12 x i8], [12 x i8]* @.str, i32 0, i32 0
%ret = call i8* @__stpcpy_chk(i8* %dst, i8* %src, i32 12) %ret = call i8* @__stpcpy_chk(i8* %dst, i8* %src, i32 12)
ret i8* %ret ret i8* %ret
} }
define i8* @test_simplify3() { define i8* @test_simplify3() {
; CHECK-LABEL: @test_simplify3( ; CHECK-LABEL: @test_simplify3(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias align 1 dereferenceable(12) getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* noalias align 1 dereferenceable(12) getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i32 0, i32 0), i32 12, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 dereferenceable(12) getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* align 1 dereferenceable(12) getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i32 0, i32 0), i32 12, i1 false)
; CHECK-NEXT: ret i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 11) ; CHECK-NEXT: ret i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 11)
; ;
%dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0 %dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0
%src = getelementptr inbounds [12 x i8], [12 x i8]* @.str, i32 0, i32 0 %src = getelementptr inbounds [12 x i8], [12 x i8]* @.str, i32 0, i32 0
%ret = call i8* @__stpcpy_chk(i8* %dst, i8* %src, i32 -1) %ret = call i8* @__stpcpy_chk(i8* %dst, i8* %src, i32 -1)
ret i8* %ret ret i8* %ret
} }
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/InstCombine/strcpy_chk-1.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test lib call simplification of __strcpy_chk calls with various values ; Test lib call simplification of __strcpy_chk calls with various values
; for src, dst, and slen. ; for src, dst, and slen.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -instcombine -S | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
@a = common global [60 x i8] zeroinitializer, align 1 @a = common global [60 x i8] zeroinitializer, align 1
@b = common global [60 x i8] zeroinitializer, align 1 @b = common global [60 x i8] zeroinitializer, align 1
@.str = private constant [12 x i8] c"abcdefghijk\00" @.str = private constant [12 x i8] c"abcdefghijk\00"
; Check cases where slen >= strlen (src). ; Check cases where slen >= strlen (src).
define i8* @test_simplify1() { define i8* @test_simplify1() {
; CHECK-LABEL: @test_simplify1( ; CHECK-LABEL: @test_simplify1(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias align 1 dereferenceable(12) getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* noalias align 1 dereferenceable(12) getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i32 0, i32 0), i32 12, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 dereferenceable(12) getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* align 1 dereferenceable(12) getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i32 0, i32 0), i32 12, i1 false)
; CHECK-NEXT: ret i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0) ; CHECK-NEXT: ret i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0)
; ;
%dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0 %dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0
%src = getelementptr inbounds [12 x i8], [12 x i8]* @.str, i32 0, i32 0 %src = getelementptr inbounds [12 x i8], [12 x i8]* @.str, i32 0, i32 0
%ret = call i8* @__strcpy_chk(i8* %dst, i8* %src, i32 60) %ret = call i8* @__strcpy_chk(i8* %dst, i8* %src, i32 60)
ret i8* %ret ret i8* %ret
} }
define i8* @test_simplify2() { define i8* @test_simplify2() {
; CHECK-LABEL: @test_simplify2( ; CHECK-LABEL: @test_simplify2(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias align 1 dereferenceable(12) getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* noalias align 1 dereferenceable(12) getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i32 0, i32 0), i32 12, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 dereferenceable(12) getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* align 1 dereferenceable(12) getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i32 0, i32 0), i32 12, i1 false)
; CHECK-NEXT: ret i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0) ; CHECK-NEXT: ret i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0)
; ;
%dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0 %dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0
%src = getelementptr inbounds [12 x i8], [12 x i8]* @.str, i32 0, i32 0 %src = getelementptr inbounds [12 x i8], [12 x i8]* @.str, i32 0, i32 0
%ret = call i8* @__strcpy_chk(i8* %dst, i8* %src, i32 12) %ret = call i8* @__strcpy_chk(i8* %dst, i8* %src, i32 12)
ret i8* %ret ret i8* %ret
} }
define i8* @test_simplify3() { define i8* @test_simplify3() {
; CHECK-LABEL: @test_simplify3( ; CHECK-LABEL: @test_simplify3(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias align 1 dereferenceable(12) getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* noalias align 1 dereferenceable(12) getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i32 0, i32 0), i32 12, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 dereferenceable(12) getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* align 1 dereferenceable(12) getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i32 0, i32 0), i32 12, i1 false)
; CHECK-NEXT: ret i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0) ; CHECK-NEXT: ret i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0)
; ;
%dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0 %dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0
%src = getelementptr inbounds [12 x i8], [12 x i8]* @.str, i32 0, i32 0 %src = getelementptr inbounds [12 x i8], [12 x i8]* @.str, i32 0, i32 0
%ret = call i8* @__strcpy_chk(i8* %dst, i8* %src, i32 -1) %ret = call i8* @__strcpy_chk(i8* %dst, i8* %src, i32 -1)
ret i8* %ret ret i8* %ret
} }
; Check cases where there are no string constants. ; Check cases where there are no string constants.
define i8* @test_simplify4() { define i8* @test_simplify4() {
; CHECK-LABEL: @test_simplify4( ; CHECK-LABEL: @test_simplify4(
; CHECK-NEXT: [[STRCPY:%.*]] = call i8* @strcpy(i8* noalias getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* noalias getelementptr inbounds ([60 x i8], [60 x i8]* @b, i32 0, i32 0)) ; CHECK-NEXT: [[STRCPY:%.*]] = call i8* @strcpy(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* getelementptr inbounds ([60 x i8], [60 x i8]* @b, i32 0, i32 0))
; CHECK-NEXT: ret i8* [[STRCPY]] ; CHECK-NEXT: ret i8* [[STRCPY]]
; ;
%dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0 %dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0
%src = getelementptr inbounds [60 x i8], [60 x i8]* @b, i32 0, i32 0 %src = getelementptr inbounds [60 x i8], [60 x i8]* @b, i32 0, i32 0
%ret = call i8* @__strcpy_chk(i8* %dst, i8* %src, i32 -1) %ret = call i8* @__strcpy_chk(i8* %dst, i8* %src, i32 -1)
ret i8* %ret ret i8* %ret
} }
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/InstCombine/strncpy_chk-1.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test lib call simplification of __strncpy_chk calls with various values ; Test lib call simplification of __strncpy_chk calls with various values
; for len and dstlen. ; for len and dstlen.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -instcombine -S | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
@a = common global [60 x i8] zeroinitializer, align 1 @a = common global [60 x i8] zeroinitializer, align 1
@b = common global [60 x i8] zeroinitializer, align 1 @b = common global [60 x i8] zeroinitializer, align 1
@.str = private constant [12 x i8] c"abcdefghijk\00" @.str = private constant [12 x i8] c"abcdefghijk\00"
; Check cases where dstlen >= len ; Check cases where dstlen >= len
define i8* @test_simplify1() { define i8* @test_simplify1() {
; CHECK-LABEL: @test_simplify1( ; CHECK-LABEL: @test_simplify1(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias align 1 dereferenceable(12) getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* noalias align 1 dereferenceable(12) getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i32 0, i32 0), i32 12, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 dereferenceable(12) getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* align 1 dereferenceable(12) getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i32 0, i32 0), i32 12, i1 false)
; CHECK-NEXT: ret i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0) ; CHECK-NEXT: ret i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0)
; ;
%dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0 %dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0
%src = getelementptr inbounds [12 x i8], [12 x i8]* @.str, i32 0, i32 0 %src = getelementptr inbounds [12 x i8], [12 x i8]* @.str, i32 0, i32 0
%ret = call i8* @__strncpy_chk(i8* %dst, i8* %src, i32 12, i32 60) %ret = call i8* @__strncpy_chk(i8* %dst, i8* %src, i32 12, i32 60)
ret i8* %ret ret i8* %ret
} }
define i8* @test_simplify2() { define i8* @test_simplify2() {
; CHECK-LABEL: @test_simplify2( ; CHECK-LABEL: @test_simplify2(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias align 1 dereferenceable(12) getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* noalias align 1 dereferenceable(12) getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i32 0, i32 0), i32 12, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 dereferenceable(12) getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* align 1 dereferenceable(12) getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i32 0, i32 0), i32 12, i1 false)
; CHECK-NEXT: ret i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0) ; CHECK-NEXT: ret i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0)
; ;
%dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0 %dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0
%src = getelementptr inbounds [12 x i8], [12 x i8]* @.str, i32 0, i32 0 %src = getelementptr inbounds [12 x i8], [12 x i8]* @.str, i32 0, i32 0
%ret = call i8* @__strncpy_chk(i8* %dst, i8* %src, i32 12, i32 12) %ret = call i8* @__strncpy_chk(i8* %dst, i8* %src, i32 12, i32 12)
ret i8* %ret ret i8* %ret
} }
define i8* @test_simplify3() { define i8* @test_simplify3() {
; CHECK-LABEL: @test_simplify3( ; CHECK-LABEL: @test_simplify3(
; CHECK-NEXT: [[STRNCPY:%.*]] = call i8* @strncpy(i8* noalias getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* noalias getelementptr inbounds ([60 x i8], [60 x i8]* @b, i32 0, i32 0), i32 12) ; CHECK-NEXT: [[STRNCPY:%.*]] = call i8* @strncpy(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* getelementptr inbounds ([60 x i8], [60 x i8]* @b, i32 0, i32 0), i32 12)
; CHECK-NEXT: ret i8* [[STRNCPY]] ; CHECK-NEXT: ret i8* [[STRNCPY]]
; ;
%dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0 %dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0
%src = getelementptr inbounds [60 x i8], [60 x i8]* @b, i32 0, i32 0 %src = getelementptr inbounds [60 x i8], [60 x i8]* @b, i32 0, i32 0
%ret = call i8* @__strncpy_chk(i8* %dst, i8* %src, i32 12, i32 60) %ret = call i8* @__strncpy_chk(i8* %dst, i8* %src, i32 12, i32 60)
ret i8* %ret ret i8* %ret
} }
Show All 28 Lines

llvm/trunk/test/Transforms/MemCpyOpt/memcpy-to-memset-with-lifetimes.ll

Show All 28 Lines
; CHECK-NEXT: [[A:%.*]] = alloca [8 x i64], align 8 ; CHECK-NEXT: [[A:%.*]] = alloca [8 x i64], align 8
; CHECK-NEXT: [[A_CAST:%.*]] = bitcast [8 x i64]* [[A]] to i8* ; CHECK-NEXT: [[A_CAST:%.*]] = bitcast [8 x i64]* [[A]] to i8*
; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 64, i8* nonnull [[A_CAST]]) ; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 64, i8* nonnull [[A_CAST]])
; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(64) [[A_CAST]], i8 0, i64 64, i1 false) ; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(64) [[A_CAST]], i8 0, i64 64, i1 false)
; CHECK-NEXT: [[SRET_CAST:%.*]] = bitcast [8 x i64]* [[SRET:%.*]] to i8* ; CHECK-NEXT: [[SRET_CAST:%.*]] = bitcast [8 x i64]* [[SRET:%.*]] to i8*
; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(64) [[SRET_CAST]], i8 0, i64 64, i1 false) ; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(64) [[SRET_CAST]], i8 0, i64 64, i1 false)
; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(32) [[A_CAST]], i8 42, i64 32, i1 false) ; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(32) [[A_CAST]], i8 42, i64 32, i1 false)
; CHECK-NEXT: [[OUT_CAST:%.*]] = bitcast [8 x i64]* [[OUT:%.*]] to i8* ; CHECK-NEXT: [[OUT_CAST:%.*]] = bitcast [8 x i64]* [[OUT:%.*]] to i8*
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias nonnull align 8 dereferenceable(64) [[OUT_CAST]], i8* noalias nonnull align 8 dereferenceable(64) [[A_CAST]], i64 64, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 8 dereferenceable(64) [[OUT_CAST]], i8* nonnull align 8 dereferenceable(64) [[A_CAST]], i64 64, i1 false)
; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 64, i8* nonnull [[A_CAST]]) ; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 64, i8* nonnull [[A_CAST]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry-block: entry-block:
%a = alloca [8 x i64], align 8 %a = alloca [8 x i64], align 8
%a.cast = bitcast [8 x i64]* %a to i8* %a.cast = bitcast [8 x i64]* %a to i8*
call void @llvm.lifetime.start.p0i8(i64 64, i8* %a.cast) call void @llvm.lifetime.start.p0i8(i64 64, i8* %a.cast)
call void @llvm.memset.p0i8.i64(i8* align 8 %a.cast, i8 0, i64 64, i1 false) call void @llvm.memset.p0i8.i64(i8* align 8 %a.cast, i8 0, i64 64, i1 false)
Show All 15 Lines
llvm/trunk/test/Transforms/InferFunctionAttrs/annotate.ll