This is an archive of the discontinued LLVM Phabricator instance.

Differential D139615

[InstCombine] Expand memcpy to vector instead of integer load/store
AbandonedPublic

Authored by nikic on Dec 8 2022, 2:10 AM.

Details

Reviewers
None
Summary

Expanding into a vector ensures that byte-wise poison is preserved.

Diff Detail

Unit TestsFailed

TimeTest
1,160 msx64 debian > Clang.CodeGenCXX::auto-var-init.cpp

Event Timeline

nikic created this revision.Dec 8 2022, 2:10 AM
Herald added a project: Restricted Project. · View Herald TranscriptDec 8 2022, 2:10 AM
Herald added subscribers: zzheng, hiraditya. · View Herald Transcript
nikic requested review of this revision.Dec 8 2022, 2:10 AM
Herald added a project: Restricted Project. · View Herald TranscriptDec 8 2022, 2:10 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
Harbormaster completed remote builds in B201916: Diff 481208.Dec 8 2022, 11:21 AM
nikic abandoned this revision.Dec 12 2022, 12:37 AM

This was just for reference, I don't think we're ready to make this change, it will result in too many optimization regressions.

Revision Contents

PathSize
llvm/
lib/
Transforms/
InstCombine/
20 lines
test/
Transforms/
Inline/
12 lines
InstCombine/
4 lines
6 lines
4 lines
12 lines
12 lines
6 lines
18 lines
79 lines
79 lines
6 lines
1 line
168 lines
171 lines
2 lines
6 lines
6 lines
6 lines
PhaseOrdering/
X86/
43 lines

Diff 481208

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

Show First 20 Lines • Show All 168 Lines • ▼ Show 20 LinesInstruction *InstCombinerImpl::SimplifyAnyMemTransfer(AnyMemTransferInst *MI) {
// If it is an atomic and alignment is less than the size then we will // If it is an atomic and alignment is less than the size then we will
// introduce the unaligned memory access which will be later transformed // introduce the unaligned memory access which will be later transformed
// into libcall in CodeGen. This is not evident performance gain so disable // into libcall in CodeGen. This is not evident performance gain so disable
// it now. // it now.
if (isa<AtomicMemTransferInst>(MI)) if (isa<AtomicMemTransferInst>(MI))
if (*CopyDstAlign < Size || *CopySrcAlign < Size) if (*CopyDstAlign < Size || *CopySrcAlign < Size)
return nullptr; return nullptr;
// Use an integer load+store unless we can find something better.
unsigned SrcAddrSp = unsigned SrcAddrSp =
cast<PointerType>(MI->getArgOperand(1)->getType())->getAddressSpace(); cast<PointerType>(MI->getArgOperand(1)->getType())->getAddressSpace();
unsigned DstAddrSp = unsigned DstAddrSp =
cast<PointerType>(MI->getArgOperand(0)->getType())->getAddressSpace(); cast<PointerType>(MI->getArgOperand(0)->getType())->getAddressSpace();
IntegerType* IntType = IntegerType::get(MI->getContext(), Size<<3); // Replace memcpy with an <N x i8> vector load/store, to preserve byte-wise
Type *NewSrcPtrTy = PointerType::get(IntType, SrcAddrSp); // poison.
Type *NewDstPtrTy = PointerType::get(IntType, DstAddrSp); // TODO: Atomic load/store does not support vectors, so keep using integers
// for now.
LLVMContext &Context = MI->getContext();
Type *NewValTy = isa<AtomicMemTransferInst>(MI) || Size == 1
? (Type*)Type::getIntNTy(Context, Size * 8)
: FixedVectorType::get(Type::getInt8Ty(Context), Size);
Type *NewSrcPtrTy = PointerType::get(NewValTy, SrcAddrSp);
Type *NewDstPtrTy = PointerType::get(NewValTy, DstAddrSp);
// If the memcpy has metadata describing the members, see if we can get the // If the memcpy has metadata describing the members, see if we can get the
// TBAA tag describing our copy. // TBAA tag describing our copy.
MDNode *CopyMD = nullptr; MDNode *CopyMD = nullptr;
if (MDNode *M = MI->getMetadata(LLVMContext::MD_tbaa)) { if (MDNode *M = MI->getMetadata(LLVMContext::MD_tbaa)) {
CopyMD = M; CopyMD = M;
} else if (MDNode *M = MI->getMetadata(LLVMContext::MD_tbaa_struct)) { } else if (MDNode *M = MI->getMetadata(LLVMContext::MD_tbaa_struct)) {
if (M->getNumOperands() == 3 && M->getOperand(0) && if (M->getNumOperands() == 3 && M->getOperand(0) &&
mdconst::hasa<ConstantInt>(M->getOperand(0)) && mdconst::hasa<ConstantInt>(M->getOperand(0)) &&
mdconst::extract<ConstantInt>(M->getOperand(0))->isZero() && mdconst::extract<ConstantInt>(M->getOperand(0))->isZero() &&
M->getOperand(1) && M->getOperand(1) &&
mdconst::hasa<ConstantInt>(M->getOperand(1)) && mdconst::hasa<ConstantInt>(M->getOperand(1)) &&
mdconst::extract<ConstantInt>(M->getOperand(1))->getValue() == mdconst::extract<ConstantInt>(M->getOperand(1))->getValue() ==
Size && Size &&
M->getOperand(2) && isa<MDNode>(M->getOperand(2))) M->getOperand(2) && isa<MDNode>(M->getOperand(2)))
CopyMD = cast<MDNode>(M->getOperand(2)); CopyMD = cast<MDNode>(M->getOperand(2));
} }
Value *Src = Builder.CreateBitCast(MI->getArgOperand(1), NewSrcPtrTy); Value *Src = Builder.CreateBitCast(MI->getArgOperand(1), NewSrcPtrTy);
Value *Dest = Builder.CreateBitCast(MI->getArgOperand(0), NewDstPtrTy); Value *Dest = Builder.CreateBitCast(MI->getArgOperand(0), NewDstPtrTy);
LoadInst *L = Builder.CreateLoad(IntType, Src); LoadInst *L = Builder.CreateLoad(NewValTy, Src);
// Alignment from the mem intrinsic will be better, so use it. // Alignment from the mem intrinsic will be better, so use it.
L->setAlignment(*CopySrcAlign); L->setAlignment(*CopySrcAlign);
if (CopyMD) if (CopyMD)
L->setMetadata(LLVMContext::MD_tbaa, CopyMD); L->setMetadata(LLVMContext::MD_tbaa, CopyMD);
MDNode *LoopMemParallelMD = MDNode *LoopMemParallelMD =
MI->getMetadata(LLVMContext::MD_mem_parallel_loop_access); MI->getMetadata(LLVMContext::MD_mem_parallel_loop_access);
if (LoopMemParallelMD) if (LoopMemParallelMD)
L->setMetadata(LLVMContext::MD_mem_parallel_loop_access, LoopMemParallelMD); L->setMetadata(LLVMContext::MD_mem_parallel_loop_access, LoopMemParallelMD);
▲ Show 20 Lines • Show All 3,589 Lines • Show Last 20 Lines

llvm/test/Transforms/Inline/byval-tail-call.ll

Show All 17 Lines;
call void @ext(ptr %x) call void @ext(ptr %x)
ret void ret void
} }
define void @foo(ptr %x) { define void @foo(ptr %x) {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: [[X1:%.*]] = alloca i32, align 4 ; CHECK-NEXT: [[X1:%.*]] = alloca i32, align 4
; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[X1]]) ; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[X1]])
; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[X:%.*]], align 1 ; CHECK-NEXT: [[TMP1:%.*]] = load <4 x i8>, ptr [[X:%.*]], align 1
; CHECK-NEXT: store i32 [[TMP2]], ptr [[X1]], align 4 ; CHECK-NEXT: store <4 x i8> [[TMP1]], ptr [[X1]], align 4
; CHECK-NEXT: call void @ext(ptr nonnull [[X1]]) ; CHECK-NEXT: call void @ext(ptr nonnull [[X1]])
; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[X1]]) ; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[X1]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @bar(ptr byval(i32) %x) call void @bar(ptr byval(i32) %x)
ret void ret void
} }
define internal void @qux(ptr byval(i32) %x) { define internal void @qux(ptr byval(i32) %x) {
call void @ext(ptr %x) call void @ext(ptr %x)
tail call void @ext(ptr null) tail call void @ext(ptr null)
ret void ret void
} }
define void @frob(ptr %x) { define void @frob(ptr %x) {
; CHECK-LABEL: @frob( ; CHECK-LABEL: @frob(
; CHECK-NEXT: [[X1:%.*]] = alloca i32, align 4 ; CHECK-NEXT: [[X1:%.*]] = alloca i32, align 4
; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[X1]]) ; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[X1]])
; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[X:%.*]], align 1 ; CHECK-NEXT: [[TMP1:%.*]] = load <4 x i8>, ptr [[X:%.*]], align 1
; CHECK-NEXT: store i32 [[TMP2]], ptr [[X1]], align 4 ; CHECK-NEXT: store <4 x i8> [[TMP1]], ptr [[X1]], align 4
; CHECK-NEXT: call void @ext(ptr nonnull [[X1]]) ; CHECK-NEXT: call void @ext(ptr nonnull [[X1]])
; CHECK-NEXT: tail call void @ext(ptr null) ; CHECK-NEXT: tail call void @ext(ptr null)
; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[X1]]) ; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[X1]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
tail call void @qux(ptr byval(i32) %x) tail call void @qux(ptr byval(i32) %x)
ret void ret void
} }
Show All 11 Lines;
call void @ext2(ptr byval(i32) %x) call void @ext2(ptr byval(i32) %x)
ret void ret void
} }
define void @foobar(ptr %x) { define void @foobar(ptr %x) {
; CHECK-LABEL: @foobar( ; CHECK-LABEL: @foobar(
; CHECK-NEXT: [[X1:%.*]] = alloca i32, align 4 ; CHECK-NEXT: [[X1:%.*]] = alloca i32, align 4
; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[X1]]) ; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[X1]])
; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[X:%.*]], align 1 ; CHECK-NEXT: [[TMP1:%.*]] = load <4 x i8>, ptr [[X:%.*]], align 1
; CHECK-NEXT: store i32 [[TMP2]], ptr [[X1]], align 4 ; CHECK-NEXT: store <4 x i8> [[TMP1]], ptr [[X1]], align 4
; CHECK-NEXT: tail call void @ext2(ptr nonnull byval(i32) [[X1]]) ; CHECK-NEXT: tail call void @ext2(ptr nonnull byval(i32) [[X1]])
; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[X1]]) ; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[X1]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
tail call void @bar2(ptr byval(i32) %x) tail call void @bar2(ptr byval(i32) %x)
ret void ret void
} }
Show All 12 Lines

llvm/test/Transforms/InstCombine/alloca.ll

Show First 20 Lines • Show All 183 Lines • ▼ Show 20 Lines
declare void @test9_aux(ptr inalloca(<{ %struct_type }>)) declare void @test9_aux(ptr inalloca(<{ %struct_type }>))
declare ptr @llvm.stacksave() declare ptr @llvm.stacksave()
declare void @llvm.stackrestore(ptr) declare void @llvm.stackrestore(ptr)
define void @test9(ptr %a) { define void @test9(ptr %a) {
; ALL-LABEL: @test9( ; ALL-LABEL: @test9(
; ALL-NEXT: entry: ; ALL-NEXT: entry:
; ALL-NEXT: [[ARGMEM:%.*]] = alloca inalloca <{ [[STRUCT_TYPE:%.*]] }>, align 8 ; ALL-NEXT: [[ARGMEM:%.*]] = alloca inalloca <{ [[STRUCT_TYPE:%.*]] }>, align 8
; ALL-NEXT: [[TMP0:%.*]] = load i64, ptr [[A:%.*]], align 4 ; ALL-NEXT: [[TMP0:%.*]] = load <8 x i8>, ptr [[A:%.*]], align 4
; ALL-NEXT: store i64 [[TMP0]], ptr [[ARGMEM]], align 8 ; ALL-NEXT: store <8 x i8> [[TMP0]], ptr [[ARGMEM]], align 8
; ALL-NEXT: call void @test9_aux(ptr nonnull inalloca(<{ [[STRUCT_TYPE]] }>) [[ARGMEM]]) ; ALL-NEXT: call void @test9_aux(ptr nonnull inalloca(<{ [[STRUCT_TYPE]] }>) [[ARGMEM]])
; ALL-NEXT: ret void ; ALL-NEXT: ret void
; ;
entry: entry:
%inalloca.save = call ptr @llvm.stacksave() %inalloca.save = call ptr @llvm.stacksave()
%argmem = alloca inalloca <{ %struct_type }> %argmem = alloca inalloca <{ %struct_type }>
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %argmem, ptr align 4 %a, i32 8, i1 false) call void @llvm.memcpy.p0.p0.i32(ptr align 4 %argmem, ptr align 4 %a, i32 8, i1 false)
call void @test9_aux(ptr inalloca(<{ %struct_type }>) %argmem) call void @test9_aux(ptr inalloca(<{ %struct_type }>) %argmem)
Show All 33 Lines

llvm/test/Transforms/InstCombine/bcopy.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -passes=instcombine -data-layout=p:32:32 -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -data-layout=p:32:32 -S | FileCheck %s
declare void @bcopy(ptr nocapture readonly, ptr nocapture, i32) declare void @bcopy(ptr nocapture readonly, ptr nocapture, i32)
define void @bcopy_memmove(ptr nocapture readonly %a, ptr nocapture %b) { define void @bcopy_memmove(ptr nocapture readonly %a, ptr nocapture %b) {
; CHECK-LABEL: @bcopy_memmove( ; CHECK-LABEL: @bcopy_memmove(
; CHECK-NEXT: [[TMP3:%.*]] = load i64, ptr [[A:%.*]], align 1 ; CHECK-NEXT: [[TMP1:%.*]] = load <8 x i8>, ptr [[A:%.*]], align 1
; CHECK-NEXT: store i64 [[TMP3]], ptr [[B:%.*]], align 1 ; CHECK-NEXT: store <8 x i8> [[TMP1]], ptr [[B:%.*]], align 1
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
tail call void @bcopy(ptr %a, ptr %b, i32 8) tail call void @bcopy(ptr %a, ptr %b, i32 8)
ret void ret void
} }
define void @bcopy_memmove2(ptr nocapture readonly %a, ptr nocapture %b, i32 %len) { define void @bcopy_memmove2(ptr nocapture readonly %a, ptr nocapture %b, i32 %len) {
; CHECK-LABEL: @bcopy_memmove2( ; CHECK-LABEL: @bcopy_memmove2(
; CHECK-NEXT: call void @llvm.memmove.p0.p0.i32(ptr align 1 [[B:%.*]], ptr align 1 [[A:%.*]], i32 [[LEN:%.*]], i1 false) ; CHECK-NEXT: tail call void @llvm.memmove.p0.p0.i32(ptr align 1 [[B:%.*]], ptr align 1 [[A:%.*]], i32 [[LEN:%.*]], i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
tail call void @bcopy(ptr %a, ptr %b, i32 %len) tail call void @bcopy(ptr %a, ptr %b, i32 %len)
ret void ret void
} }

llvm/test/Transforms/InstCombine/mem-par-metadata-memcpy.ll

Show All 19 Lines
; CHECK: for.cond: ; CHECK: for.cond:
; CHECK-NEXT: [[I_0:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[ADD2:%.*]], [[FOR_INC:%.*]] ] ; CHECK-NEXT: [[I_0:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[ADD2:%.*]], [[FOR_INC:%.*]] ]
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i64 [[I_0]], [[SIZE:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp slt i64 [[I_0]], [[SIZE:%.*]]
; CHECK-NEXT: br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
; CHECK: for.body: ; CHECK: for.body:
; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i8, ptr [[OUT:%.*]], i64 [[I_0]] ; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i8, ptr [[OUT:%.*]], i64 [[I_0]]
; CHECK-NEXT: [[ADD:%.*]] = add nsw i64 [[I_0]], [[SIZE]] ; CHECK-NEXT: [[ADD:%.*]] = add nsw i64 [[I_0]], [[SIZE]]
; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds i8, ptr [[OUT]], i64 [[ADD]] ; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds i8, ptr [[OUT]], i64 [[ADD]]
; CHECK-NEXT: [[TMP0:%.*]] = load i16, ptr [[ARRAYIDX1]], align 1, !llvm.access.group [[ACC_GRP0:![0-9]+]] ; CHECK-NEXT: [[TMP0:%.*]] = load <2 x i8>, ptr [[ARRAYIDX1]], align 1, !llvm.access.group [[ACC_GRP0:![0-9]+]]
; CHECK-NEXT: store i16 [[TMP0]], ptr [[ARRAYIDX]], align 1, !llvm.access.group [[ACC_GRP0]] ; CHECK-NEXT: store <2 x i8> [[TMP0]], ptr [[ARRAYIDX]], align 1, !llvm.access.group [[ACC_GRP0]]
; CHECK-NEXT: br label [[FOR_INC]] ; CHECK-NEXT: br label [[FOR_INC]]
; CHECK: for.inc: ; CHECK: for.inc:
; CHECK-NEXT: [[ADD2]] = add nuw nsw i64 [[I_0]], 2 ; CHECK-NEXT: [[ADD2]] = add nuw nsw i64 [[I_0]], 2
; CHECK-NEXT: br label [[FOR_COND]], !llvm.loop [[LOOP1:![0-9]+]] ; CHECK-NEXT: br label [[FOR_COND]], !llvm.loop [[LOOP1:![0-9]+]]
; CHECK: for.end: ; CHECK: for.end:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry: entry:
Show All 28 Lines

llvm/test/Transforms/InstCombine/memccpy.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -passes=instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
@hello = private constant [11 x i8] c"helloworld\00", align 1 @hello = private constant [11 x i8] c"helloworld\00", align 1
@NoNulTerminator = private constant [10 x i8] c"helloworld", align 1 @NoNulTerminator = private constant [10 x i8] c"helloworld", align 1
@StopCharAfterNulTerminator = private constant [12 x i8] c"helloworld\00x", align 1 @StopCharAfterNulTerminator = private constant [12 x i8] c"helloworld\00x", align 1
@StringWithEOF = constant [14 x i8] c"helloworld\FFab\00", align 1 @StringWithEOF = constant [14 x i8] c"helloworld\FFab\00", align 1
declare ptr @memccpy(ptr, ptr, i32, i64) declare ptr @memccpy(ptr, ptr, i32, i64)
define ptr @memccpy_to_memcpy(ptr %dst) { define ptr @memccpy_to_memcpy(ptr %dst) {
; CHECK-LABEL: @memccpy_to_memcpy( ; CHECK-LABEL: @memccpy_to_memcpy(
; CHECK-NEXT: store i64 8245940763182785896, ptr [[DST:%.*]], align 1 ; CHECK-NEXT: store <8 x i8> <i8 104, i8 101, i8 108, i8 108, i8 111, i8 119, i8 111, i8 114>, ptr [[DST:%.*]], align 1
; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 8 ; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 8
; CHECK-NEXT: ret ptr [[TMP2]] ; CHECK-NEXT: ret ptr [[TMP1]]
; ;
%call = call ptr @memccpy(ptr %dst, ptr @hello, i32 114, i64 12) ; 114 is 'r' %call = call ptr @memccpy(ptr %dst, ptr @hello, i32 114, i64 12) ; 114 is 'r'
ret ptr %call ret ptr %call
} }
define ptr @memccpy_to_memcpy2(ptr %dst) { define ptr @memccpy_to_memcpy2(ptr %dst) {
; CHECK-LABEL: @memccpy_to_memcpy2( ; CHECK-LABEL: @memccpy_to_memcpy2(
; CHECK-NEXT: store i64 8245940763182785896, ptr [[DST:%.*]], align 1 ; CHECK-NEXT: store <8 x i8> <i8 104, i8 101, i8 108, i8 108, i8 111, i8 119, i8 111, i8 114>, ptr [[DST:%.*]], align 1
; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 8 ; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 8
; CHECK-NEXT: ret ptr [[TMP2]] ; CHECK-NEXT: ret ptr [[TMP1]]
; ;
%call = call ptr @memccpy(ptr %dst, ptr @hello, i32 114, i64 8); ; 114 is 'r' %call = call ptr @memccpy(ptr %dst, ptr @hello, i32 114, i64 8); ; 114 is 'r'
ret ptr %call ret ptr %call
} }
define void @memccpy_to_memcpy3(ptr %dst) { define void @memccpy_to_memcpy3(ptr %dst) {
; CHECK-LABEL: @memccpy_to_memcpy3( ; CHECK-LABEL: @memccpy_to_memcpy3(
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(5) [[DST:%.*]], ptr noundef nonnull align 1 dereferenceable(5) @hello, i64 5, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(5) [[DST:%.*]], ptr noundef nonnull align 1 dereferenceable(5) @hello, i64 5, i1 false)
▲ Show 20 Lines • Show All 235 Lines • Show Last 20 Lines

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

Show All 14 Lines
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.memcpy.p0.p0.i32(ptr %d, ptr %s, i32 1, i1 false) call void @llvm.memcpy.p0.p0.i32(ptr %d, ptr %s, i32 1, i1 false)
ret void ret void
} }
define void @copy_2_bytes(ptr %d, ptr %s) { define void @copy_2_bytes(ptr %d, ptr %s) {
; CHECK-LABEL: @copy_2_bytes( ; CHECK-LABEL: @copy_2_bytes(
; CHECK-NEXT: [[TMP3:%.*]] = load i16, ptr [[S:%.*]], align 1 ; CHECK-NEXT: [[TMP1:%.*]] = load <2 x i8>, ptr [[S:%.*]], align 1
; CHECK-NEXT: store i16 [[TMP3]], ptr [[D:%.*]], align 1 ; CHECK-NEXT: store <2 x i8> [[TMP1]], ptr [[D:%.*]], align 1
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.memcpy.p0.p0.i32(ptr %d, ptr %s, i32 2, i1 false) call void @llvm.memcpy.p0.p0.i32(ptr %d, ptr %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(ptr %d, ptr %s) { define void @copy_3_bytes(ptr %d, ptr %s) {
; CHECK-LABEL: @copy_3_bytes( ; CHECK-LABEL: @copy_3_bytes(
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr noundef nonnull align 1 dereferenceable(3) [[D:%.*]], ptr noundef nonnull align 1 dereferenceable(3) [[S:%.*]], i32 3, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr noundef nonnull align 1 dereferenceable(3) [[D:%.*]], ptr noundef nonnull align 1 dereferenceable(3) [[S:%.*]], i32 3, i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.memcpy.p0.p0.i32(ptr %d, ptr %s, i32 3, i1 false) call void @llvm.memcpy.p0.p0.i32(ptr %d, ptr %s, i32 3, i1 false)
ret void ret void
} }
define void @copy_4_bytes(ptr %d, ptr %s) { define void @copy_4_bytes(ptr %d, ptr %s) {
; CHECK-LABEL: @copy_4_bytes( ; CHECK-LABEL: @copy_4_bytes(
; CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[S:%.*]], align 1 ; CHECK-NEXT: [[TMP1:%.*]] = load <4 x i8>, ptr [[S:%.*]], align 1
; CHECK-NEXT: store i32 [[TMP3]], ptr [[D:%.*]], align 1 ; CHECK-NEXT: store <4 x i8> [[TMP1]], ptr [[D:%.*]], align 1
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.memcpy.p0.p0.i32(ptr %d, ptr %s, i32 4, i1 false) call void @llvm.memcpy.p0.p0.i32(ptr %d, ptr %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(ptr %d, ptr %s) { define void @copy_5_bytes(ptr %d, ptr %s) {
; CHECK-LABEL: @copy_5_bytes( ; CHECK-LABEL: @copy_5_bytes(
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr noundef nonnull align 1 dereferenceable(5) [[D:%.*]], ptr noundef nonnull align 1 dereferenceable(5) [[S:%.*]], i32 5, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr noundef nonnull align 1 dereferenceable(5) [[D:%.*]], ptr noundef nonnull align 1 dereferenceable(5) [[S:%.*]], i32 5, i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.memcpy.p0.p0.i32(ptr %d, ptr %s, i32 5, i1 false) call void @llvm.memcpy.p0.p0.i32(ptr %d, ptr %s, i32 5, i1 false)
ret void ret void
} }
define void @copy_8_bytes(ptr %d, ptr %s) { define void @copy_8_bytes(ptr %d, ptr %s) {
; CHECK-LABEL: @copy_8_bytes( ; CHECK-LABEL: @copy_8_bytes(
; CHECK-NEXT: [[TMP3:%.*]] = load i64, ptr [[S:%.*]], align 1 ; CHECK-NEXT: [[TMP1:%.*]] = load <8 x i8>, ptr [[S:%.*]], align 1
; CHECK-NEXT: store i64 [[TMP3]], ptr [[D:%.*]], align 1 ; CHECK-NEXT: store <8 x i8> [[TMP1]], ptr [[D:%.*]], align 1
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.memcpy.p0.p0.i32(ptr %d, ptr %s, i32 8, i1 false) call void @llvm.memcpy.p0.p0.i32(ptr %d, ptr %s, i32 8, i1 false)
ret void ret void
} }
define void @copy_16_bytes(ptr %d, ptr %s) { define void @copy_16_bytes(ptr %d, ptr %s) {
; CHECK-LABEL: @copy_16_bytes( ; CHECK-LABEL: @copy_16_bytes(
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr noundef nonnull align 1 dereferenceable(16) [[D:%.*]], ptr noundef nonnull align 1 dereferenceable(16) [[S:%.*]], i32 16, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr noundef nonnull align 1 dereferenceable(16) [[D:%.*]], ptr noundef nonnull align 1 dereferenceable(16) [[S:%.*]], i32 16, i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.memcpy.p0.p0.i32(ptr %d, ptr %s, i32 16, i1 false) call void @llvm.memcpy.p0.p0.i32(ptr %d, ptr %s, i32 16, i1 false)
ret void ret void
} }

llvm/test/Transforms/InstCombine/memmove.ll

Show All 22 Lines
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.memmove.p0.p0.i32(ptr %A, ptr @S, i32 %N, i1 false) call void @llvm.memmove.p0.p0.i32(ptr %A, ptr @S, i32 %N, i1 false)
ret void ret void
} }
define i32 @test3(ptr %target) { ; arg: ptr> [#uses=1] define i32 @test3(ptr %target) { ; arg: ptr> [#uses=1]
; CHECK-LABEL: @test3( ; CHECK-LABEL: @test3(
; CHECK-NEXT: store i16 104, ptr [[TARGET:%.*]], align 2 ; CHECK-NEXT: store <2 x i8> <i8 104, i8 0>, ptr [[TARGET:%.*]], align 2
; CHECK-NEXT: store i32 7103848, ptr [[TARGET]], align 4 ; CHECK-NEXT: store <4 x i8> <i8 104, i8 101, i8 108, i8 0>, ptr [[TARGET]], align 4
; CHECK-NEXT: store i64 33037504440198504, ptr [[TARGET]], align 8 ; CHECK-NEXT: store <8 x i8> <i8 104, i8 101, i8 108, i8 108, i8 111, i8 95, i8 117, i8 0>, ptr [[TARGET]], align 8
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
; ;
%h_p = getelementptr [2 x i8], ptr @h, i32 0, i32 0 ; <ptr> [#uses=1] %h_p = getelementptr [2 x i8], ptr @h, i32 0, i32 0 ; <ptr> [#uses=1]
%hel_p = getelementptr [4 x i8], ptr @hel, i32 0, i32 0 ; <ptr> [#uses=1] %hel_p = getelementptr [4 x i8], ptr @hel, i32 0, i32 0 ; <ptr> [#uses=1]
%hello_u_p = getelementptr [8 x i8], ptr @hello_u, i32 0, i32 0 ; <ptr> [#uses=1] %hello_u_p = getelementptr [8 x i8], ptr @hello_u, i32 0, i32 0 ; <ptr> [#uses=1]
%target_p = getelementptr [1024 x i8], ptr %target, i32 0, i32 0 ; <ptr> [#uses=3] %target_p = getelementptr [1024 x i8], ptr %target, i32 0, i32 0 ; <ptr> [#uses=3]
call void @llvm.memmove.p0.p0.i32(ptr align 2 %target_p, ptr align 2 %h_p, i32 2, i1 false) call void @llvm.memmove.p0.p0.i32(ptr align 2 %target_p, ptr align 2 %h_p, i32 2, i1 false)
call void @llvm.memmove.p0.p0.i32(ptr align 4 %target_p, ptr align 4 %hel_p, i32 4, i1 false) call void @llvm.memmove.p0.p0.i32(ptr align 4 %target_p, ptr align 4 %hel_p, i32 4, i1 false)
Show All 25 Lines

llvm/test/Transforms/InstCombine/mempcpy.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 -passes=instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
define ptr @memcpy_nonconst_n(ptr %d, ptr nocapture readonly %s, i64 %n) { define ptr @memcpy_nonconst_n(ptr %d, ptr nocapture readonly %s, i64 %n) {
; CHECK-LABEL: @memcpy_nonconst_n( ; CHECK-LABEL: @memcpy_nonconst_n(
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 1 [[D:%.*]], ptr align 1 [[S:%.*]], i64 [[N:%.*]], i1 false) ; CHECK-NEXT: tail call void @llvm.memcpy.p0.p0.i64(ptr align 1 [[D:%.*]], ptr align 1 [[S:%.*]], i64 [[N:%.*]], i1 false)
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, ptr [[D]], i64 [[N]] ; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, ptr [[D]], i64 [[N]]
; CHECK-NEXT: ret ptr [[TMP1]] ; CHECK-NEXT: ret ptr [[TMP1]]
; ;
%r = tail call ptr @mempcpy(ptr %d, ptr %s, i64 %n) %r = tail call ptr @mempcpy(ptr %d, ptr %s, i64 %n)
ret ptr %r ret ptr %r
} }
define ptr @memcpy_nonconst_n_copy_attrs(ptr %d, ptr nocapture readonly %s, i64 %n) { define ptr @memcpy_nonconst_n_copy_attrs(ptr %d, ptr nocapture readonly %s, i64 %n) {
; CHECK-LABEL: @memcpy_nonconst_n_copy_attrs( ; CHECK-LABEL: @memcpy_nonconst_n_copy_attrs(
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 1 dereferenceable(16) [[D:%.*]], ptr align 1 [[S:%.*]], i64 [[N:%.*]], i1 false) ; CHECK-NEXT: tail call void @llvm.memcpy.p0.p0.i64(ptr align 1 dereferenceable(16) [[D:%.*]], ptr align 1 [[S:%.*]], i64 [[N:%.*]], i1 false)
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, ptr [[D]], i64 [[N]] ; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, ptr [[D]], i64 [[N]]
; CHECK-NEXT: ret ptr [[TMP1]] ; CHECK-NEXT: ret ptr [[TMP1]]
; ;
%r = tail call ptr @mempcpy(ptr dereferenceable(16) %d, ptr %s, i64 %n) %r = tail call ptr @mempcpy(ptr dereferenceable(16) %d, ptr %s, i64 %n)
ret ptr %r ret ptr %r
} }
define void @memcpy_nonconst_n_unused_retval(ptr %d, ptr nocapture readonly %s, i64 %n) { define void @memcpy_nonconst_n_unused_retval(ptr %d, ptr nocapture readonly %s, i64 %n) {
; CHECK-LABEL: @memcpy_nonconst_n_unused_retval( ; CHECK-LABEL: @memcpy_nonconst_n_unused_retval(
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 1 [[D:%.*]], ptr align 1 [[S:%.*]], i64 [[N:%.*]], i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 1 [[D:%.*]], ptr align 1 [[S:%.*]], i64 [[N:%.*]], i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call ptr @mempcpy(ptr %d, ptr %s, i64 %n) call ptr @mempcpy(ptr %d, ptr %s, i64 %n)
ret void ret void
} }
define ptr @memcpy_small_const_n(ptr %d, ptr nocapture readonly %s) { define ptr @memcpy_small_const_n(ptr %d, ptr nocapture readonly %s) {
; CHECK-LABEL: @memcpy_small_const_n( ; CHECK-LABEL: @memcpy_small_const_n(
; CHECK-NEXT: [[TMP3:%.*]] = load i64, ptr [[S:%.*]], align 1 ; CHECK-NEXT: [[TMP1:%.*]] = load <8 x i8>, ptr [[S:%.*]], align 1
; CHECK-NEXT: store i64 [[TMP3]], ptr [[D:%.*]], align 1 ; CHECK-NEXT: store <8 x i8> [[TMP1]], ptr [[D:%.*]], align 1
; CHECK-NEXT: [[TMP4:%.*]] = getelementptr inbounds i8, ptr [[D]], i64 8 ; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i8, ptr [[D]], i64 8
; CHECK-NEXT: ret ptr [[TMP4]] ; CHECK-NEXT: ret ptr [[TMP2]]
; ;
%r = tail call ptr @mempcpy(ptr %d, ptr %s, i64 8) %r = tail call ptr @mempcpy(ptr %d, ptr %s, i64 8)
ret ptr %r ret ptr %r
} }
define ptr @memcpy_big_const_n(ptr %d, ptr nocapture readonly %s) { define ptr @memcpy_big_const_n(ptr %d, ptr nocapture readonly %s) {
; CHECK-LABEL: @memcpy_big_const_n( ; CHECK-LABEL: @memcpy_big_const_n(
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(1024) [[D:%.*]], ptr noundef nonnull align 1 dereferenceable(1024) [[S:%.*]], i64 1024, i1 false) ; CHECK-NEXT: tail call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(1024) [[D:%.*]], ptr noundef nonnull align 1 dereferenceable(1024) [[S:%.*]], i64 1024, i1 false)
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, ptr [[D]], i64 1024 ; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, ptr [[D]], i64 1024
; CHECK-NEXT: ret ptr [[TMP1]] ; CHECK-NEXT: ret ptr [[TMP1]]
; ;
%r = tail call ptr @mempcpy(ptr %d, ptr %s, i64 1024) %r = tail call ptr @mempcpy(ptr %d, ptr %s, i64 1024)
ret ptr %r ret ptr %r
} }
; The original call may have attributes that can not propagate to memcpy. ; The original call may have attributes that can not propagate to memcpy.
define i32 @PR48810() { define i32 @PR48810() {
; CHECK-LABEL: @PR48810( ; CHECK-LABEL: @PR48810(
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 1 undef, ptr align 4294967296 null, i64 undef, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 1 undef, ptr align 4294967296 null, i64 undef, i1 false)
; CHECK-NEXT: ret i32 undef ; CHECK-NEXT: ret i32 undef
; ;
%r = call dereferenceable(1) ptr @mempcpy(ptr undef, ptr null, i64 undef) %r = call dereferenceable(1) ptr @mempcpy(ptr undef, ptr null, i64 undef)
ret i32 undef ret i32 undef
} }
define ptr @memcpy_no_simplify1(ptr %d, ptr nocapture readonly %s, i64 %n) { define ptr @memcpy_no_simplify1(ptr %d, ptr nocapture readonly %s, i64 %n) {
; CHECK-LABEL: @memcpy_no_simplify1( ; CHECK-LABEL: @memcpy_no_simplify1(
; CHECK-NEXT: %r = musttail call ptr @mempcpy(ptr %d, ptr %s, i64 %n) ; CHECK-NEXT: [[R:%.*]] = musttail call ptr @mempcpy(ptr [[D:%.*]], ptr [[S:%.*]], i64 [[N:%.*]])
; CHECK-NEXT: ret ptr %r ; CHECK-NEXT: ret ptr [[R]]
; ;
%r = musttail call ptr @mempcpy(ptr %d, ptr %s, i64 %n) %r = musttail call ptr @mempcpy(ptr %d, ptr %s, i64 %n)
ret ptr %r ret ptr %r
} }
declare ptr @mempcpy(ptr, ptr nocapture readonly, i64) declare ptr @mempcpy(ptr, ptr nocapture readonly, i64)

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

Show All 14 Lines
declare i32 @snprintf(ptr, i64, ptr, ...) declare i32 @snprintf(ptr, i64, ptr, ...)
; Verify that all snprintf calls with a bound between INT_MAX and down ; Verify that all snprintf calls with a bound between INT_MAX and down
; to 0 are transformed to memcpy. ; to 0 are transformed to memcpy.
define void @fold_snprintf_fmt() { define void @fold_snprintf_fmt() {
; BE-LABEL: @fold_snprintf_fmt( ; ANY-LABEL: @fold_snprintf_fmt(
; BE-NEXT: [[PDIMAX:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 2147483647), align 8 ; ANY-NEXT: [[PDIMAX:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 2147483647), align 8
; BE-NEXT: store i32 825373440, ptr [[PDIMAX]], align 1 ; ANY-NEXT: store <4 x i8> <i8 49, i8 50, i8 51, i8 0>, ptr [[PDIMAX]], align 1
; BE-NEXT: store i32 3, ptr @asiz, align 4 ; ANY-NEXT: store i32 3, ptr @asiz, align 4
; BE-NEXT: [[PD5:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 5), align 8 ; ANY-NEXT: [[PD5:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 5), align 8
; BE-NEXT: store i32 825373440, ptr [[PD5]], align 1 ; ANY-NEXT: store <4 x i8> <i8 49, i8 50, i8 51, i8 0>, ptr [[PD5]], align 1
; BE-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 5), align 4 ; ANY-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 5), align 4
; BE-NEXT: [[PD4:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 4), align 8 ; ANY-NEXT: [[PD4:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 4), align 8
; BE-NEXT: store i32 825373440, ptr [[PD4]], align 1 ; ANY-NEXT: store <4 x i8> <i8 49, i8 50, i8 51, i8 0>, ptr [[PD4]], align 1
; BE-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 4), align 4 ; ANY-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 4), align 4
; BE-NEXT: [[PD3:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 3), align 8 ; ANY-NEXT: [[PD3:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 3), align 8
; BE-NEXT: store i16 12594, ptr [[PD3]], align 1 ; ANY-NEXT: store <2 x i8> <i8 49, i8 50>, ptr [[PD3]], align 1
; BE-NEXT: [[ENDPTR:%.*]] = getelementptr inbounds i8, ptr [[PD3]], i64 2 ; ANY-NEXT: [[ENDPTR:%.*]] = getelementptr inbounds i8, ptr [[PD3]], i64 2
; BE-NEXT: store i8 0, ptr [[ENDPTR]], align 1 ; ANY-NEXT: store i8 0, ptr [[ENDPTR]], align 1
; BE-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 3), align 4 ; ANY-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 3), align 4
; BE-NEXT: [[PD2:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 2), align 8 ; ANY-NEXT: [[PD2:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 2), align 8
; BE-NEXT: store i8 49, ptr [[PD2]], align 1 ; ANY-NEXT: store i8 49, ptr [[PD2]], align 1
; BE-NEXT: [[ENDPTR1:%.*]] = getelementptr inbounds i8, ptr [[PD2]], i64 1 ; ANY-NEXT: [[ENDPTR1:%.*]] = getelementptr inbounds i8, ptr [[PD2]], i64 1
; BE-NEXT: store i8 0, ptr [[ENDPTR1]], align 1 ; ANY-NEXT: store i8 0, ptr [[ENDPTR1]], align 1
; BE-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 2), align 4 ; ANY-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 2), align 4
; BE-NEXT: [[PD1:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 1), align 8 ; ANY-NEXT: [[PD1:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 1), align 8
; BE-NEXT: store i8 0, ptr [[PD1]], align 1 ; ANY-NEXT: store i8 0, ptr [[PD1]], align 1
; BE-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 1), align 4 ; ANY-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 1), align 4
; BE-NEXT: store i32 3, ptr @asiz, align 4 ; ANY-NEXT: store i32 3, ptr @asiz, align 4
; BE-NEXT: ret void ; ANY-NEXT: ret void
;
; LE-LABEL: @fold_snprintf_fmt(
; LE-NEXT: [[PDIMAX:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 2147483647), align 8
; LE-NEXT: store i32 3355185, ptr [[PDIMAX]], align 1
; LE-NEXT: store i32 3, ptr @asiz, align 4
; LE-NEXT: [[PD5:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 5), align 8
; LE-NEXT: store i32 3355185, ptr [[PD5]], align 1
; LE-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 5), align 4
; LE-NEXT: [[PD4:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 4), align 8
; LE-NEXT: store i32 3355185, ptr [[PD4]], align 1
; LE-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 4), align 4
; LE-NEXT: [[PD3:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 3), align 8
; LE-NEXT: store i16 12849, ptr [[PD3]], align 1
; LE-NEXT: [[ENDPTR:%.*]] = getelementptr inbounds i8, ptr [[PD3]], i64 2
; LE-NEXT: store i8 0, ptr [[ENDPTR]], align 1
; LE-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 3), align 4
; LE-NEXT: [[PD2:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 2), align 8
; LE-NEXT: store i8 49, ptr [[PD2]], align 1
; LE-NEXT: [[ENDPTR1:%.*]] = getelementptr inbounds i8, ptr [[PD2]], i64 1
; LE-NEXT: store i8 0, ptr [[ENDPTR1]], align 1
; LE-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 2), align 4
; LE-NEXT: [[PD1:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 1), align 8
; LE-NEXT: store i8 0, ptr [[PD1]], align 1
; LE-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 1), align 4
; LE-NEXT: store i32 3, ptr @asiz, align 4
; LE-NEXT: ret void
; ;
%pdimax = load ptr, ptr getelementptr ([0 x ptr], ptr @adst, i32 0, i32 2147483647) %pdimax = load ptr, ptr getelementptr ([0 x ptr], ptr @adst, i32 0, i32 2147483647)
%nimax = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %pdimax, i64 2147483647, ptr @s) %nimax = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %pdimax, i64 2147483647, ptr @s)
store i32 %nimax, ptr @asiz store i32 %nimax, ptr @asiz
%pd5 = load ptr, ptr getelementptr ([0 x ptr], ptr @adst, i32 0, i32 5) %pd5 = load ptr, ptr getelementptr ([0 x ptr], ptr @adst, i32 0, i32 5)
%n5 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %pd5, i64 5, ptr @s) %n5 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %pd5, i64 5, ptr @s)
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines;
store i32 %nm1, ptr getelementptr ([0 x i32], ptr @asiz, i32 0, i32 1) store i32 %nm1, ptr getelementptr ([0 x i32], ptr @asiz, i32 0, i32 1)
%pdimaxp1 = load ptr, ptr @adst %pdimaxp1 = load ptr, ptr @adst
%nimaxp1 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %pdimaxp1, i64 2147483648, ptr @s) %nimaxp1 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %pdimaxp1, i64 2147483648, ptr @s)
store i32 %nimaxp1, ptr @asiz store i32 %nimaxp1, ptr @asiz
ret void ret void
} }
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; BE: {{.*}}
; LE: {{.*}}

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

Show All 15 Lines
declare i32 @snprintf(ptr, i64, ptr, ...) declare i32 @snprintf(ptr, i64, ptr, ...)
; Verify that all snprintf calls with a bound between INT_MAX and down ; Verify that all snprintf calls with a bound between INT_MAX and down
; to 0 are transformed to memcpy. ; to 0 are transformed to memcpy.
define void @fold_snprintf_pcnt_s() { define void @fold_snprintf_pcnt_s() {
; BE-LABEL: @fold_snprintf_pcnt_s( ; ANY-LABEL: @fold_snprintf_pcnt_s(
; BE-NEXT: [[PDIMAX:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 2147483647), align 8 ; ANY-NEXT: [[PDIMAX:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 2147483647), align 8
; BE-NEXT: store i32 825373440, ptr [[PDIMAX]], align 1 ; ANY-NEXT: store <4 x i8> <i8 49, i8 50, i8 51, i8 0>, ptr [[PDIMAX]], align 1
; BE-NEXT: store i32 3, ptr @asiz, align 4 ; ANY-NEXT: store i32 3, ptr @asiz, align 4
; BE-NEXT: [[PD5:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 5), align 8 ; ANY-NEXT: [[PD5:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 5), align 8
; BE-NEXT: store i32 825373440, ptr [[PD5]], align 1 ; ANY-NEXT: store <4 x i8> <i8 49, i8 50, i8 51, i8 0>, ptr [[PD5]], align 1
; BE-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 5), align 4 ; ANY-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 5), align 4
; BE-NEXT: [[PD4:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 4), align 8 ; ANY-NEXT: [[PD4:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 4), align 8
; BE-NEXT: store i32 825373440, ptr [[PD4]], align 1 ; ANY-NEXT: store <4 x i8> <i8 49, i8 50, i8 51, i8 0>, ptr [[PD4]], align 1
; BE-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 4), align 4 ; ANY-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 4), align 4
; BE-NEXT: [[PD3:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 3), align 8 ; ANY-NEXT: [[PD3:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 3), align 8
; BE-NEXT: store i16 12594, ptr [[PD3]], align 1 ; ANY-NEXT: store <2 x i8> <i8 49, i8 50>, ptr [[PD3]], align 1
; BE-NEXT: [[ENDPTR:%.*]] = getelementptr inbounds i8, ptr [[PD3]], i64 2 ; ANY-NEXT: [[ENDPTR:%.*]] = getelementptr inbounds i8, ptr [[PD3]], i64 2
; BE-NEXT: store i8 0, ptr [[ENDPTR]], align 1 ; ANY-NEXT: store i8 0, ptr [[ENDPTR]], align 1
; BE-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 3), align 4 ; ANY-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 3), align 4
; BE-NEXT: [[PD2:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 2), align 8 ; ANY-NEXT: [[PD2:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 2), align 8
; BE-NEXT: store i8 49, ptr [[PD2]], align 1 ; ANY-NEXT: store i8 49, ptr [[PD2]], align 1
; BE-NEXT: [[ENDPTR1:%.*]] = getelementptr inbounds i8, ptr [[PD2]], i64 1 ; ANY-NEXT: [[ENDPTR1:%.*]] = getelementptr inbounds i8, ptr [[PD2]], i64 1
; BE-NEXT: store i8 0, ptr [[ENDPTR1]], align 1 ; ANY-NEXT: store i8 0, ptr [[ENDPTR1]], align 1
; BE-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 2), align 4 ; ANY-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 2), align 4
; BE-NEXT: [[PD1:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 1), align 8 ; ANY-NEXT: [[PD1:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 1), align 8
; BE-NEXT: store i8 0, ptr [[PD1]], align 1 ; ANY-NEXT: store i8 0, ptr [[PD1]], align 1
; BE-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 1), align 4 ; ANY-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 1), align 4
; BE-NEXT: store i32 3, ptr @asiz, align 4 ; ANY-NEXT: store i32 3, ptr @asiz, align 4
; BE-NEXT: ret void ; ANY-NEXT: ret void
;
; LE-LABEL: @fold_snprintf_pcnt_s(
; LE-NEXT: [[PDIMAX:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 2147483647), align 8
; LE-NEXT: store i32 3355185, ptr [[PDIMAX]], align 1
; LE-NEXT: store i32 3, ptr @asiz, align 4
; LE-NEXT: [[PD5:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 5), align 8
; LE-NEXT: store i32 3355185, ptr [[PD5]], align 1
; LE-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 5), align 4
; LE-NEXT: [[PD4:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 4), align 8
; LE-NEXT: store i32 3355185, ptr [[PD4]], align 1
; LE-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 4), align 4
; LE-NEXT: [[PD3:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 3), align 8
; LE-NEXT: store i16 12849, ptr [[PD3]], align 1
; LE-NEXT: [[ENDPTR:%.*]] = getelementptr inbounds i8, ptr [[PD3]], i64 2
; LE-NEXT: store i8 0, ptr [[ENDPTR]], align 1
; LE-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 3), align 4
; LE-NEXT: [[PD2:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 2), align 8
; LE-NEXT: store i8 49, ptr [[PD2]], align 1
; LE-NEXT: [[ENDPTR1:%.*]] = getelementptr inbounds i8, ptr [[PD2]], i64 1
; LE-NEXT: store i8 0, ptr [[ENDPTR1]], align 1
; LE-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 2), align 4
; LE-NEXT: [[PD1:%.*]] = load ptr, ptr getelementptr inbounds ([0 x ptr], ptr @adst, i64 0, i64 1), align 8
; LE-NEXT: store i8 0, ptr [[PD1]], align 1
; LE-NEXT: store i32 3, ptr getelementptr inbounds ([0 x i32], ptr @asiz, i64 0, i64 1), align 4
; LE-NEXT: store i32 3, ptr @asiz, align 4
; LE-NEXT: ret void
; ;
%pdimax = load ptr, ptr getelementptr ([0 x ptr], ptr @adst, i32 0, i32 2147483647) %pdimax = load ptr, ptr getelementptr ([0 x ptr], ptr @adst, i32 0, i32 2147483647)
%nimax = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %pdimax, i64 2147483647, ptr @pcnt_s, ptr @s) %nimax = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %pdimax, i64 2147483647, ptr @pcnt_s, ptr @s)
store i32 %nimax, ptr @asiz store i32 %nimax, ptr @asiz
%pd5 = load ptr, ptr getelementptr ([0 x ptr], ptr @adst, i32 0, i32 5) %pd5 = load ptr, ptr getelementptr ([0 x ptr], ptr @adst, i32 0, i32 5)
%n5 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %pd5, i64 5, ptr @pcnt_s, ptr @s) %n5 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %pd5, i64 5, ptr @pcnt_s, ptr @s)
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines;
store i32 %nm1, ptr getelementptr ([0 x i32], ptr @asiz, i32 0, i32 1) store i32 %nm1, ptr getelementptr ([0 x i32], ptr @asiz, i32 0, i32 1)
%pdimaxp1 = load ptr, ptr @adst %pdimaxp1 = load ptr, ptr @adst
%nimaxp1 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %pdimaxp1, i64 2147483648, ptr @pcnt_s, ptr @s) %nimaxp1 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %pdimaxp1, i64 2147483648, ptr @pcnt_s, ptr @s)
store i32 %nimaxp1, ptr @asiz store i32 %nimaxp1, ptr @asiz
ret void ret void
} }
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; BE: {{.*}}
; LE: {{.*}}

llvm/test/Transforms/InstCombine/snprintf.ll

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
; ;
%call = call i32 (ptr, i64, ptr, ...) @snprintf(ptr null, i64 0, ptr @.str.1) #3 %call = call i32 (ptr, i64, ptr, ...) @snprintf(ptr null, i64 0, ptr @.str.1) #3
ret i32 %call ret i32 %call
} }
define void @test_correct_copy(ptr %buf) #0 { define void @test_correct_copy(ptr %buf) #0 {
; CHECK-LABEL: @test_correct_copy( ; CHECK-LABEL: @test_correct_copy(
; CHECK-NEXT: store i32 7500915, ptr [[BUF:%.*]], align 1 ; CHECK-NEXT: store <4 x i8> <i8 115, i8 116, i8 114, i8 0>, ptr [[BUF:%.*]], align 1
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%call = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %buf, i64 32, ptr @.str) #2 %call = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %buf, i64 32, ptr @.str) #2
ret void ret void
} }
define i32 @test_char_zero_size(ptr %buf) #0 { define i32 @test_char_zero_size(ptr %buf) #0 {
; CHECK-LABEL: @test_char_zero_size( ; CHECK-LABEL: @test_char_zero_size(
Show All 37 Lines
; CHECK-NEXT: ret i32 3 ; CHECK-NEXT: ret i32 3
; ;
%call = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %buf, i64 1, ptr @.str.3, ptr @.str) #2 %call = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %buf, i64 1, ptr @.str.3, ptr @.str) #2
ret i32 %call ret i32 %call
} }
define i32 @test_str_ok_size(ptr %buf) #0 { define i32 @test_str_ok_size(ptr %buf) #0 {
; CHECK-LABEL: @test_str_ok_size( ; CHECK-LABEL: @test_str_ok_size(
; CHECK-NEXT: store i32 7500915, ptr [[BUF:%.*]], align 1 ; CHECK-NEXT: store <4 x i8> <i8 115, i8 116, i8 114, i8 0>, ptr [[BUF:%.*]], align 1
; CHECK-NEXT: ret i32 3 ; CHECK-NEXT: ret i32 3
; ;
%call = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %buf, i64 32, ptr @.str.3, ptr @.str) #2 %call = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %buf, i64 32, ptr @.str.3, ptr @.str) #2
ret i32 %call ret i32 %call
} }
; snprintf(buf, 32, "") -> memcpy -> store ; snprintf(buf, 32, "") -> memcpy -> store
define i32 @test_str_ok_size_tail(ptr %buf) { define i32 @test_str_ok_size_tail(ptr %buf) {
Show All 12 Lines
; ;
%1 = musttail call i32 (ptr, i64, ptr, ...) @snprintf(ptr %buf, i64 8, ptr @.str.4, ...) %1 = musttail call i32 (ptr, i64, ptr, ...) @snprintf(ptr %buf, i64 8, ptr @.str.4, ...)
ret i32 %1 ret i32 %1
} }
; snprintf(buf, 32, "%s", "str") -> memcpy -> store ; snprintf(buf, 32, "%s", "str") -> memcpy -> store
define i32 @test_str_ok_size_tail2(ptr %buf) { define i32 @test_str_ok_size_tail2(ptr %buf) {
; CHECK-LABEL: @test_str_ok_size_tail2( ; CHECK-LABEL: @test_str_ok_size_tail2(
; CHECK-NEXT: store i32 7500915, ptr [[BUF:%.*]], align 1 ; CHECK-NEXT: store <4 x i8> <i8 115, i8 116, i8 114, i8 0>, ptr [[BUF:%.*]], align 1
; CHECK-NEXT: ret i32 3 ; CHECK-NEXT: ret i32 3
; ;
%1 = tail call i32 (ptr, i64, ptr, ...) @snprintf(ptr %buf, i64 8, ptr @.str.3, ptr @.str) %1 = tail call i32 (ptr, i64, ptr, ...) @snprintf(ptr %buf, i64 8, ptr @.str.3, ptr @.str)
ret i32 %1 ret i32 %1
} }
define i32 @test_str_ok_size_musttail2(ptr %buf, i64 %x, ptr %y, ...) { define i32 @test_str_ok_size_musttail2(ptr %buf, i64 %x, ptr %y, ...) {
; CHECK-LABEL: @test_str_ok_size_musttail2( ; CHECK-LABEL: @test_str_ok_size_musttail2(
; CHECK-NEXT: [[TMP1:%.*]] = musttail call i32 (ptr, i64, ptr, ...) @snprintf(ptr [[BUF:%.*]], i64 8, ptr nonnull @.str.3, ptr nonnull @.str, ...) ; CHECK-NEXT: [[TMP1:%.*]] = musttail call i32 (ptr, i64, ptr, ...) @snprintf(ptr [[BUF:%.*]], i64 8, ptr nonnull @.str.3, ptr nonnull @.str, ...)
; CHECK-NEXT: ret i32 [[TMP1]] ; CHECK-NEXT: ret i32 [[TMP1]]
; ;
%1 = musttail call i32 (ptr, i64, ptr, ...) @snprintf(ptr %buf, i64 8, ptr @.str.3, ptr @.str, ...) %1 = musttail call i32 (ptr, i64, ptr, ...) @snprintf(ptr %buf, i64 8, ptr @.str.3, ptr @.str, ...)
ret i32 %1 ret i32 %1
} }

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

Show First 20 Lines • Show All 99 Lines • ▼ Show 20 Lines
; WITHSTPCPY-NEXT: [[TMP3:%.*]] = sub i32 [[TMP1]], [[TMP2]] ; WITHSTPCPY-NEXT: [[TMP3:%.*]] = sub i32 [[TMP1]], [[TMP2]]
; WITHSTPCPY-NEXT: ret i32 [[TMP3]] ; WITHSTPCPY-NEXT: ret i32 [[TMP3]]
; ;
; NOSTPCPY-LABEL: @test_simplify7( ; NOSTPCPY-LABEL: @test_simplify7(
; NOSTPCPY-NEXT: [[STRLEN:%.*]] = call i32 @strlen(ptr noundef nonnull dereferenceable(1) [[STR:%.*]]) ; NOSTPCPY-NEXT: [[STRLEN:%.*]] = call i32 @strlen(ptr noundef nonnull dereferenceable(1) [[STR:%.*]])
; NOSTPCPY-NEXT: [[LENINC:%.*]] = add i32 [[STRLEN]], 1 ; NOSTPCPY-NEXT: [[LENINC:%.*]] = add i32 [[STRLEN]], 1
; NOSTPCPY-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[DST:%.*]], ptr align 1 [[STR]], i32 [[LENINC]], i1 false) ; NOSTPCPY-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[DST:%.*]], ptr align 1 [[STR]], i32 [[LENINC]], i1 false)
; NOSTPCPY-NEXT: ret i32 [[STRLEN]] ; NOSTPCPY-NEXT: ret i32 [[STRLEN]]
;
%r = call i32 (ptr, ptr, ...) @sprintf(ptr %dst, ptr @percent_s, ptr %str) %r = call i32 (ptr, ptr, ...) @sprintf(ptr %dst, ptr @percent_s, ptr %str)
ret i32 %r ret i32 %r
} }
; 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 i32 @test_simplify8(ptr %dst) { define i32 @test_simplify8(ptr %dst) {
; CHECK-LABEL: @test_simplify8( ; CHECK-LABEL: @test_simplify8(
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr noundef nonnull align 1 dereferenceable(13) [[DST:%.*]], ptr noundef nonnull align 1 dereferenceable(13) @hello_world, i32 13, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr noundef nonnull align 1 dereferenceable(13) [[DST:%.*]], ptr noundef nonnull align 1 dereferenceable(13) @hello_world, i32 13, i1 false)
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 132 Lines • ▼ Show 20 Lines; Transform stpncpy(D, "", n) to memset(D, 0, n), D.
ret void ret void
} }
; Verify that stpncpy(D, "4", N) calls are transformed to the equivalent ; Verify that stpncpy(D, "4", N) calls are transformed to the equivalent
; of strncpy(D, "4", N) and the result folded to D + (N != 0). ; of strncpy(D, "4", N) and the result folded to D + (N != 0).
define void @fold_stpncpy_s1(ptr %dst) { define void @fold_stpncpy_s1(ptr %dst) {
; BE-LABEL: @fold_stpncpy_s1( ; ANY-LABEL: @fold_stpncpy_s1(
; BE-NEXT: call void @sink(ptr [[DST:%.*]], ptr [[DST]]) ; ANY-NEXT: call void @sink(ptr [[DST:%.*]], ptr [[DST]])
; BE-NEXT: store i8 52, ptr [[DST]], align 1 ; ANY-NEXT: store i8 52, ptr [[DST]], align 1
; BE-NEXT: [[STPNCPY_END:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1 ; ANY-NEXT: [[STPNCPY_END:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1
; BE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[STPNCPY_END]]) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[STPNCPY_END]])
; BE-NEXT: store i16 13312, ptr [[DST]], align 1 ; ANY-NEXT: store <2 x i8> <i8 52, i8 0>, ptr [[DST]], align 1
; BE-NEXT: [[ENDPTR:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1 ; ANY-NEXT: [[ENDPTR:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1
; BE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR]]) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR]])
; BE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(3) [[DST]], ptr noundef nonnull align 1 dereferenceable(3) @str.6, i64 3, i1 false) ; ANY-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(3) [[DST]], ptr noundef nonnull align 1 dereferenceable(3) @str.6, i64 3, i1 false)
; BE-NEXT: [[ENDPTR1:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1 ; ANY-NEXT: [[ENDPTR1:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1
; BE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR1]]) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR1]])
; BE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(9) [[DST]], ptr noundef nonnull align 1 dereferenceable(9) @str.7, i64 9, i1 false) ; ANY-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(9) [[DST]], ptr noundef nonnull align 1 dereferenceable(9) @str.7, i64 9, i1 false)
; BE-NEXT: [[ENDPTR2:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1 ; ANY-NEXT: [[ENDPTR2:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1
; BE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR2]]) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR2]])
; BE-NEXT: ret void ; ANY-NEXT: ret void
;
; LE-LABEL: @fold_stpncpy_s1(
; LE-NEXT: call void @sink(ptr [[DST:%.*]], ptr [[DST]])
; LE-NEXT: store i8 52, ptr [[DST]], align 1
; LE-NEXT: [[STPNCPY_END:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1
; LE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[STPNCPY_END]])
; LE-NEXT: store i16 52, ptr [[DST]], align 1
; LE-NEXT: [[ENDPTR:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1
; LE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR]])
; LE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(3) [[DST]], ptr noundef nonnull align 1 dereferenceable(3) @str.6, i64 3, i1 false)
; LE-NEXT: [[ENDPTR1:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1
; LE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR1]])
; LE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(9) [[DST]], ptr noundef nonnull align 1 dereferenceable(9) @str.7, i64 9, i1 false)
; LE-NEXT: [[ENDPTR2:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1
; LE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR2]])
; LE-NEXT: ret void
; ;
%ps1 = getelementptr [5 x i8], ptr @s4, i32 0, i32 3 %ps1 = getelementptr [5 x i8], ptr @s4, i32 0, i32 3
; Fold stpncpy(D, "4", 0) to just D. ; Fold stpncpy(D, "4", 0) to just D.
%es1_0 = call ptr @stpncpy(ptr %dst, ptr %ps1, i64 0) %es1_0 = call ptr @stpncpy(ptr %dst, ptr %ps1, i64 0)
call void @sink(ptr %dst, ptr %es1_0) call void @sink(ptr %dst, ptr %es1_0)
; Transform stpncpy(D, "4", 1) to *D = '4', D + 1. ; Transform stpncpy(D, "4", 1) to *D = '4', D + 1.
Show All 16 Lines; Transform stpncpy(D, "4", 9) to strncpy(D, "4", 9) + 1.
ret void ret void
} }
; Verify that stpncpy(D, "1234", N) calls are transformed to the equivalent ; Verify that stpncpy(D, "1234", N) calls are transformed to the equivalent
; of strncpy(D, "1234", N) and the result folded to D + min(4, N). ; of strncpy(D, "1234", N) and the result folded to D + min(4, N).
define void @fold_stpncpy_s4(ptr %dst, i64 %n) { define void @fold_stpncpy_s4(ptr %dst, i64 %n) {
; BE-LABEL: @fold_stpncpy_s4( ; ANY-LABEL: @fold_stpncpy_s4(
; BE-NEXT: call void @sink(ptr [[DST:%.*]], ptr [[DST]]) ; ANY-NEXT: call void @sink(ptr [[DST:%.*]], ptr [[DST]])
; BE-NEXT: store i8 49, ptr [[DST]], align 1 ; ANY-NEXT: store i8 49, ptr [[DST]], align 1
; BE-NEXT: [[STPNCPY_END:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1 ; ANY-NEXT: [[STPNCPY_END:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1
; BE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[STPNCPY_END]]) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[STPNCPY_END]])
; BE-NEXT: store i16 12594, ptr [[DST]], align 1 ; ANY-NEXT: store <2 x i8> <i8 49, i8 50>, ptr [[DST]], align 1
; BE-NEXT: [[ENDPTR:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 2 ; ANY-NEXT: [[ENDPTR:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 2
; BE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR]]) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR]])
; BE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(3) [[DST]], ptr noundef nonnull align 1 dereferenceable(5) @s4, i64 3, i1 false) ; ANY-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(3) [[DST]], ptr noundef nonnull align 1 dereferenceable(5) @s4, i64 3, i1 false)
; BE-NEXT: [[ENDPTR1:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 3 ; ANY-NEXT: [[ENDPTR1:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 3
; BE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR1]]) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR1]])
; BE-NEXT: store i32 825373492, ptr [[DST]], align 1 ; ANY-NEXT: store <4 x i8> <i8 49, i8 50, i8 51, i8 52>, ptr [[DST]], align 1
; BE-NEXT: [[ENDPTR2:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 4 ; ANY-NEXT: [[ENDPTR2:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 4
; BE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR2]]) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR2]])
; BE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(9) [[DST]], ptr noundef nonnull align 1 dereferenceable(9) @str.8, i64 9, i1 false) ; ANY-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(9) [[DST]], ptr noundef nonnull align 1 dereferenceable(9) @str.8, i64 9, i1 false)
; BE-NEXT: [[ENDPTR3:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 4 ; ANY-NEXT: [[ENDPTR3:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 4
; BE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR3]]) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR3]])
; BE-NEXT: ret void ; ANY-NEXT: ret void
;
; LE-LABEL: @fold_stpncpy_s4(
; LE-NEXT: call void @sink(ptr [[DST:%.*]], ptr [[DST]])
; LE-NEXT: store i8 49, ptr [[DST]], align 1
; LE-NEXT: [[STPNCPY_END:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1
; LE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[STPNCPY_END]])
; LE-NEXT: store i16 12849, ptr [[DST]], align 1
; LE-NEXT: [[ENDPTR:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 2
; LE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR]])
; LE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(3) [[DST]], ptr noundef nonnull align 1 dereferenceable(5) @s4, i64 3, i1 false)
; LE-NEXT: [[ENDPTR1:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 3
; LE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR1]])
; LE-NEXT: store i32 875770417, ptr [[DST]], align 1
; LE-NEXT: [[ENDPTR2:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 4
; LE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR2]])
; LE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(9) [[DST]], ptr noundef nonnull align 1 dereferenceable(9) @str.8, i64 9, i1 false)
; LE-NEXT: [[ENDPTR3:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 4
; LE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR3]])
; LE-NEXT: ret void
; ;
; Fold stpncpy(D, "1234", 0) to just D. ; Fold stpncpy(D, "1234", 0) to just D.
%es4_0 = call ptr @stpncpy(ptr %dst, ptr @s4, i64 0) %es4_0 = call ptr @stpncpy(ptr %dst, ptr @s4, i64 0)
call void @sink(ptr %dst, ptr %es4_0) call void @sink(ptr %dst, ptr %es4_0)
; Transform stpncpy(D, "1234", 1) to *D = '4', D + 1. ; Transform stpncpy(D, "1234", 1) to *D = '4', D + 1.
%es4_1 = call ptr @stpncpy(ptr %dst, ptr @s4, i64 1) %es4_1 = call ptr @stpncpy(ptr %dst, ptr @s4, i64 1)
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines; Likewise, do not transform stpncpy(D, "1234", N) when N is unknown.
ret void ret void
} }
; Verify that stpncpy(D, (char[4]){"1234"}, N) calls with an unterminated ; Verify that stpncpy(D, (char[4]){"1234"}, N) calls with an unterminated
; source array are transformed to the equivalent strncpy call and the result ; source array are transformed to the equivalent strncpy call and the result
; folded to D + min(4, N). ; folded to D + min(4, N).
define void @fold_stpncpy_a4(ptr %dst, i64 %n) { define void @fold_stpncpy_a4(ptr %dst, i64 %n) {
; BE-LABEL: @fold_stpncpy_a4( ; ANY-LABEL: @fold_stpncpy_a4(
; BE-NEXT: call void @sink(ptr [[DST:%.*]], ptr [[DST]]) ; ANY-NEXT: call void @sink(ptr [[DST:%.*]], ptr [[DST]])
; BE-NEXT: store i8 49, ptr [[DST]], align 1 ; ANY-NEXT: store i8 49, ptr [[DST]], align 1
; BE-NEXT: [[STPNCPY_END:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1 ; ANY-NEXT: [[STPNCPY_END:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1
; BE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[STPNCPY_END]]) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[STPNCPY_END]])
; BE-NEXT: store i16 12594, ptr [[DST]], align 1 ; ANY-NEXT: store <2 x i8> <i8 49, i8 50>, ptr [[DST]], align 1
; BE-NEXT: [[ENDPTR:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 2 ; ANY-NEXT: [[ENDPTR:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 2
; BE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR]]) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR]])
; BE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(3) [[DST]], ptr noundef nonnull align 1 dereferenceable(5) @a4, i64 3, i1 false) ; ANY-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(3) [[DST]], ptr noundef nonnull align 1 dereferenceable(5) @a4, i64 3, i1 false)
; BE-NEXT: [[ENDPTR1:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 3 ; ANY-NEXT: [[ENDPTR1:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 3
; BE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR1]]) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR1]])
; BE-NEXT: store i32 825373492, ptr [[DST]], align 1 ; ANY-NEXT: store <4 x i8> <i8 49, i8 50, i8 51, i8 52>, ptr [[DST]], align 1
; BE-NEXT: [[ENDPTR2:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 4 ; ANY-NEXT: [[ENDPTR2:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 4
; BE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR2]]) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR2]])
; BE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(5) [[DST]], ptr noundef nonnull align 1 dereferenceable(5) @a4, i64 5, i1 false) ; ANY-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(5) [[DST]], ptr noundef nonnull align 1 dereferenceable(5) @a4, i64 5, i1 false)
; BE-NEXT: [[ENDPTR3:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 4 ; ANY-NEXT: [[ENDPTR3:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 4
; BE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR3]]) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR3]])
; BE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(9) [[DST]], ptr noundef nonnull align 1 dereferenceable(9) @str.9, i64 9, i1 false) ; ANY-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(9) [[DST]], ptr noundef nonnull align 1 dereferenceable(9) @str.9, i64 9, i1 false)
; BE-NEXT: [[ENDPTR4:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 4 ; ANY-NEXT: [[ENDPTR4:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 4
; BE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR4]]) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR4]])
; BE-NEXT: ret void ; ANY-NEXT: ret void
;
; LE-LABEL: @fold_stpncpy_a4(
; LE-NEXT: call void @sink(ptr [[DST:%.*]], ptr [[DST]])
; LE-NEXT: store i8 49, ptr [[DST]], align 1
; LE-NEXT: [[STPNCPY_END:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1
; LE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[STPNCPY_END]])
; LE-NEXT: store i16 12849, ptr [[DST]], align 1
; LE-NEXT: [[ENDPTR:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 2
; LE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR]])
; LE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(3) [[DST]], ptr noundef nonnull align 1 dereferenceable(5) @a4, i64 3, i1 false)
; LE-NEXT: [[ENDPTR1:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 3
; LE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR1]])
; LE-NEXT: store i32 875770417, ptr [[DST]], align 1
; LE-NEXT: [[ENDPTR2:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 4
; LE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR2]])
; LE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(5) [[DST]], ptr noundef nonnull align 1 dereferenceable(5) @a4, i64 5, i1 false)
; LE-NEXT: [[ENDPTR3:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 4
; LE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR3]])
; LE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(9) [[DST]], ptr noundef nonnull align 1 dereferenceable(9) @str.9, i64 9, i1 false)
; LE-NEXT: [[ENDPTR4:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 4
; LE-NEXT: call void @sink(ptr nonnull [[DST]], ptr nonnull [[ENDPTR4]])
; LE-NEXT: ret void
; ;
; Fold stpncpy(D, A4, 0) to just D. ; Fold stpncpy(D, A4, 0) to just D.
%ea4_0 = call ptr @stpncpy(ptr %dst, ptr @a4, i64 0) %ea4_0 = call ptr @stpncpy(ptr %dst, ptr @a4, i64 0)
call void @sink(ptr %dst, ptr %ea4_0) call void @sink(ptr %dst, ptr %ea4_0)
; Transform stpncpy(D, A4, 1) to *D = '4', D + 1. ; Transform stpncpy(D, A4, 1) to *D = '4', D + 1.
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Lines; of the value of N. See https://reviews.llvm.org/D124633.
call void @sink(ptr %dst, ptr %es_n) call void @sink(ptr %dst, ptr %es_n)
ret void ret void
} }
;. ;.
; ANY: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: write) } ; ANY: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: write) }
; ANY: attributes #[[ATTR1:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } ; ANY: attributes #[[ATTR1:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; BE: {{.*}}
; LE: {{.*}}

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

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
} }
; Verify that strlcpy(D, "4", N) calls are transformed to a store to ; Verify that strlcpy(D, "4", N) calls are transformed to a store to
; D[0] for nonzero N (and a nul store to D[1] for N greater than 1) ; D[0] for nonzero N (and a nul store to D[1] for N greater than 1)
; and folded to 1 for all values of N. ; and folded to 1 for all values of N.
define void @fold_strlcpy_s1(ptr %dst) { define void @fold_strlcpy_s1(ptr %dst) {
; BE-LABEL: @fold_strlcpy_s1( ; ANY-LABEL: @fold_strlcpy_s1(
; BE-NEXT: call void @sink(ptr [[DST:%.*]], i64 1) ; ANY-NEXT: call void @sink(ptr [[DST:%.*]], i64 1)
; BE-NEXT: store i8 0, ptr [[DST]], align 1 ; ANY-NEXT: store i8 0, ptr [[DST]], align 1
; BE-NEXT: call void @sink(ptr nonnull [[DST]], i64 1) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], i64 1)
; BE-NEXT: store i16 13312, ptr [[DST]], align 1 ; ANY-NEXT: store <2 x i8> <i8 52, i8 0>, ptr [[DST]], align 1
; BE-NEXT: call void @sink(ptr nonnull [[DST]], i64 1) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], i64 1)
; BE-NEXT: store i16 13312, ptr [[DST]], align 1 ; ANY-NEXT: store <2 x i8> <i8 52, i8 0>, ptr [[DST]], align 1
; BE-NEXT: call void @sink(ptr nonnull [[DST]], i64 1) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], i64 1)
; BE-NEXT: store i16 13312, ptr [[DST]], align 1 ; ANY-NEXT: store <2 x i8> <i8 52, i8 0>, ptr [[DST]], align 1
; BE-NEXT: call void @sink(ptr nonnull [[DST]], i64 1) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], i64 1)
; BE-NEXT: ret void ; ANY-NEXT: ret void
;
; LE-LABEL: @fold_strlcpy_s1(
; LE-NEXT: call void @sink(ptr [[DST:%.*]], i64 1)
; LE-NEXT: store i8 0, ptr [[DST]], align 1
; LE-NEXT: call void @sink(ptr nonnull [[DST]], i64 1)
; LE-NEXT: store i16 52, ptr [[DST]], align 1
; LE-NEXT: call void @sink(ptr nonnull [[DST]], i64 1)
; LE-NEXT: store i16 52, ptr [[DST]], align 1
; LE-NEXT: call void @sink(ptr nonnull [[DST]], i64 1)
; LE-NEXT: store i16 52, ptr [[DST]], align 1
; LE-NEXT: call void @sink(ptr nonnull [[DST]], i64 1)
; LE-NEXT: ret void
; ;
%ps1 = getelementptr [5 x i8], ptr @s4, i32 0, i32 3 %ps1 = getelementptr [5 x i8], ptr @s4, i32 0, i32 3
; Fold strlcpy(D, "4", 0) to 1. ; Fold strlcpy(D, "4", 0) to 1.
%ns1_0 = call i64 @strlcpy(ptr %dst, ptr %ps1, i64 0) %ns1_0 = call i64 @strlcpy(ptr %dst, ptr %ps1, i64 0)
call void @sink(ptr %dst, i64 %ns1_0) call void @sink(ptr %dst, i64 %ns1_0)
; Transform strlcpy(D, "4", 1) to *D = '\0', 1. ; Transform strlcpy(D, "4", 1) to *D = '\0', 1.
Show All 16 Lines
} }
; Verify that strlcpy(D, "1234", N) calls are transformed to a copy of ; Verify that strlcpy(D, "1234", N) calls are transformed to a copy of
; the N - 1 leading characters of the string to D and folded to 4 for ; the N - 1 leading characters of the string to D and folded to 4 for
; all values of N. ; all values of N.
define void @fold_strlcpy_s5(ptr %dst) { define void @fold_strlcpy_s5(ptr %dst) {
; BE-LABEL: @fold_strlcpy_s5( ; ANY-LABEL: @fold_strlcpy_s5(
; BE-NEXT: call void @sink(ptr [[DST:%.*]], i64 4) ; ANY-NEXT: call void @sink(ptr [[DST:%.*]], i64 4)
; BE-NEXT: store i8 0, ptr [[DST]], align 1 ; ANY-NEXT: store i8 0, ptr [[DST]], align 1
; BE-NEXT: call void @sink(ptr nonnull [[DST]], i64 4) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], i64 4)
; BE-NEXT: store i8 49, ptr [[DST]], align 1 ; ANY-NEXT: store i8 49, ptr [[DST]], align 1
; BE-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1 ; ANY-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1
; BE-NEXT: store i8 0, ptr [[TMP1]], align 1 ; ANY-NEXT: store i8 0, ptr [[TMP1]], align 1
; BE-NEXT: call void @sink(ptr nonnull [[DST]], i64 4) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], i64 4)
; BE-NEXT: store i16 12594, ptr [[DST]], align 1 ; ANY-NEXT: store <2 x i8> <i8 49, i8 50>, ptr [[DST]], align 1
; BE-NEXT: [[TMP2:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 2 ; ANY-NEXT: [[TMP2:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 2
; BE-NEXT: store i8 0, ptr [[TMP2]], align 1 ; ANY-NEXT: store i8 0, ptr [[TMP2]], align 1
; BE-NEXT: call void @sink(ptr nonnull [[DST]], i64 4) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], i64 4)
; BE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(3) [[DST]], ptr noundef nonnull align 1 dereferenceable(3) @s4, i64 3, i1 false) ; ANY-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(3) [[DST]], ptr noundef nonnull align 1 dereferenceable(3) @s4, i64 3, i1 false)
; BE-NEXT: [[TMP3:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 3 ; ANY-NEXT: [[TMP3:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 3
; BE-NEXT: store i8 0, ptr [[TMP3]], align 1 ; ANY-NEXT: store i8 0, ptr [[TMP3]], align 1
; BE-NEXT: call void @sink(ptr nonnull [[DST]], i64 4) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], i64 4)
; BE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(5) [[DST]], ptr noundef nonnull align 1 dereferenceable(5) @s4, i64 5, i1 false) ; ANY-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(5) [[DST]], ptr noundef nonnull align 1 dereferenceable(5) @s4, i64 5, i1 false)
; BE-NEXT: call void @sink(ptr nonnull [[DST]], i64 4) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], i64 4)
; BE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(5) [[DST]], ptr noundef nonnull align 1 dereferenceable(5) @s4, i64 5, i1 false) ; ANY-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(5) [[DST]], ptr noundef nonnull align 1 dereferenceable(5) @s4, i64 5, i1 false)
; BE-NEXT: call void @sink(ptr nonnull [[DST]], i64 4) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], i64 4)
; BE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(5) [[DST]], ptr noundef nonnull align 1 dereferenceable(5) @s4, i64 5, i1 false) ; ANY-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(5) [[DST]], ptr noundef nonnull align 1 dereferenceable(5) @s4, i64 5, i1 false)
; BE-NEXT: call void @sink(ptr nonnull [[DST]], i64 4) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], i64 4)
; BE-NEXT: ret void ; ANY-NEXT: ret void
;
; LE-LABEL: @fold_strlcpy_s5(
; LE-NEXT: call void @sink(ptr [[DST:%.*]], i64 4)
; LE-NEXT: store i8 0, ptr [[DST]], align 1
; LE-NEXT: call void @sink(ptr nonnull [[DST]], i64 4)
; LE-NEXT: store i8 49, ptr [[DST]], align 1
; LE-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1
; LE-NEXT: store i8 0, ptr [[TMP1]], align 1
; LE-NEXT: call void @sink(ptr nonnull [[DST]], i64 4)
; LE-NEXT: store i16 12849, ptr [[DST]], align 1
; LE-NEXT: [[TMP2:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 2
; LE-NEXT: store i8 0, ptr [[TMP2]], align 1
; LE-NEXT: call void @sink(ptr nonnull [[DST]], i64 4)
; LE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(3) [[DST]], ptr noundef nonnull align 1 dereferenceable(3) @s4, i64 3, i1 false)
; LE-NEXT: [[TMP3:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 3
; LE-NEXT: store i8 0, ptr [[TMP3]], align 1
; LE-NEXT: call void @sink(ptr nonnull [[DST]], i64 4)
; LE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(5) [[DST]], ptr noundef nonnull align 1 dereferenceable(5) @s4, i64 5, i1 false)
; LE-NEXT: call void @sink(ptr nonnull [[DST]], i64 4)
; LE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(5) [[DST]], ptr noundef nonnull align 1 dereferenceable(5) @s4, i64 5, i1 false)
; LE-NEXT: call void @sink(ptr nonnull [[DST]], i64 4)
; LE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(5) [[DST]], ptr noundef nonnull align 1 dereferenceable(5) @s4, i64 5, i1 false)
; LE-NEXT: call void @sink(ptr nonnull [[DST]], i64 4)
; LE-NEXT: ret void
; ;
; Fold strlcpy(D, "1234", 0) to 4. ; Fold strlcpy(D, "1234", 0) to 4.
%ns4_0 = call i64 @strlcpy(ptr %dst, ptr @s4, i64 0) %ns4_0 = call i64 @strlcpy(ptr %dst, ptr @s4, i64 0)
call void @sink(ptr %dst, i64 %ns4_0) call void @sink(ptr %dst, i64 %ns4_0)
; Transform strlcpy(D, "1234", 1) to *D = '\0', 4. ; Transform strlcpy(D, "1234", 1) to *D = '\0', 4.
%ns4_1 = call i64 @strlcpy(ptr %dst, ptr @s4, i64 1) %ns4_1 = call i64 @strlcpy(ptr %dst, ptr @s4, i64 1)
▲ Show 20 Lines • Show All 111 Lines • ▼ Show 20 Lines
; Verify that the transformation behaves reasonably even when the source ; Verify that the transformation behaves reasonably even when the source
; array is not a nul-terminated string as it's required to be (and doesn't ; array is not a nul-terminated string as it's required to be (and doesn't
; for example attempt to read past its end). All the calls below are ; for example attempt to read past its end). All the calls below are
; undefined so technically reading past the end would be fine but it's ; undefined so technically reading past the end would be fine but it's
; easy to avoid. ; easy to avoid.
define void @fold_strlcpy_a5(ptr %dst, i64 %n) { define void @fold_strlcpy_a5(ptr %dst, i64 %n) {
; BE-LABEL: @fold_strlcpy_a5( ; ANY-LABEL: @fold_strlcpy_a5(
; BE-NEXT: call void @sink(ptr [[DST:%.*]], i64 5) ; ANY-NEXT: call void @sink(ptr [[DST:%.*]], i64 5)
; BE-NEXT: store i8 0, ptr [[DST]], align 1 ; ANY-NEXT: store i8 0, ptr [[DST]], align 1
; BE-NEXT: call void @sink(ptr nonnull [[DST]], i64 5) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], i64 5)
; BE-NEXT: store i8 49, ptr [[DST]], align 1 ; ANY-NEXT: store i8 49, ptr [[DST]], align 1
; BE-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1 ; ANY-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1
; BE-NEXT: store i8 0, ptr [[TMP1]], align 1 ; ANY-NEXT: store i8 0, ptr [[TMP1]], align 1
; BE-NEXT: call void @sink(ptr nonnull [[DST]], i64 5) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], i64 5)
; BE-NEXT: store i32 825373492, ptr [[DST]], align 1 ; ANY-NEXT: store <4 x i8> <i8 49, i8 50, i8 51, i8 52>, ptr [[DST]], align 1
; BE-NEXT: [[TMP2:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 4 ; ANY-NEXT: [[TMP2:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 4
; BE-NEXT: store i8 0, ptr [[TMP2]], align 1 ; ANY-NEXT: store i8 0, ptr [[TMP2]], align 1
; BE-NEXT: call void @sink(ptr nonnull [[DST]], i64 5) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], i64 5)
; BE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(5) [[DST]], ptr noundef nonnull align 1 dereferenceable(5) @a5, i64 5, i1 false) ; ANY-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(5) [[DST]], ptr noundef nonnull align 1 dereferenceable(5) @a5, i64 5, i1 false)
; BE-NEXT: [[TMP3:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 5 ; ANY-NEXT: [[TMP3:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 5
; BE-NEXT: store i8 0, ptr [[TMP3]], align 1 ; ANY-NEXT: store i8 0, ptr [[TMP3]], align 1
; BE-NEXT: call void @sink(ptr nonnull [[DST]], i64 5) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], i64 5)
; BE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(5) [[DST]], ptr noundef nonnull align 1 dereferenceable(5) @a5, i64 5, i1 false) ; ANY-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(5) [[DST]], ptr noundef nonnull align 1 dereferenceable(5) @a5, i64 5, i1 false)
; BE-NEXT: [[TMP4:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 5 ; ANY-NEXT: [[TMP4:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 5
; BE-NEXT: store i8 0, ptr [[TMP4]], align 1 ; ANY-NEXT: store i8 0, ptr [[TMP4]], align 1
; BE-NEXT: call void @sink(ptr nonnull [[DST]], i64 5) ; ANY-NEXT: call void @sink(ptr nonnull [[DST]], i64 5)
; BE-NEXT: ret void ; ANY-NEXT: ret void
;
; LE-LABEL: @fold_strlcpy_a5(
; LE-NEXT: call void @sink(ptr [[DST:%.*]], i64 5)
; LE-NEXT: store i8 0, ptr [[DST]], align 1
; LE-NEXT: call void @sink(ptr nonnull [[DST]], i64 5)
; LE-NEXT: store i8 49, ptr [[DST]], align 1
; LE-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 1
; LE-NEXT: store i8 0, ptr [[TMP1]], align 1
; LE-NEXT: call void @sink(ptr nonnull [[DST]], i64 5)
; LE-NEXT: store i32 875770417, ptr [[DST]], align 1
; LE-NEXT: [[TMP2:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 4
; LE-NEXT: store i8 0, ptr [[TMP2]], align 1
; LE-NEXT: call void @sink(ptr nonnull [[DST]], i64 5)
; LE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(5) [[DST]], ptr noundef nonnull align 1 dereferenceable(5) @a5, i64 5, i1 false)
; LE-NEXT: [[TMP3:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 5
; LE-NEXT: store i8 0, ptr [[TMP3]], align 1
; LE-NEXT: call void @sink(ptr nonnull [[DST]], i64 5)
; LE-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(5) [[DST]], ptr noundef nonnull align 1 dereferenceable(5) @a5, i64 5, i1 false)
; LE-NEXT: [[TMP4:%.*]] = getelementptr inbounds i8, ptr [[DST]], i64 5
; LE-NEXT: store i8 0, ptr [[TMP4]], align 1
; LE-NEXT: call void @sink(ptr nonnull [[DST]], i64 5)
; LE-NEXT: ret void
; ;
%na5_0 = call i64 @strlcpy(ptr %dst, ptr @a5, i64 0) %na5_0 = call i64 @strlcpy(ptr %dst, ptr @a5, i64 0)
call void @sink(ptr %dst, i64 %na5_0) call void @sink(ptr %dst, i64 %na5_0)
%na5_1 = call i64 @strlcpy(ptr %dst, ptr @a5, i64 1) %na5_1 = call i64 @strlcpy(ptr %dst, ptr @a5, i64 1)
call void @sink(ptr %dst, i64 %na5_1) call void @sink(ptr %dst, i64 %na5_1)
%na5_2 = call i64 @strlcpy(ptr %dst, ptr @a5, i64 2) %na5_2 = call i64 @strlcpy(ptr %dst, ptr @a5, i64 2)
call void @sink(ptr %dst, i64 %na5_2) call void @sink(ptr %dst, i64 %na5_2)
%na5_5 = call i64 @strlcpy(ptr %dst, ptr @a5, i64 5) %na5_5 = call i64 @strlcpy(ptr %dst, ptr @a5, i64 5)
call void @sink(ptr %dst, i64 %na5_5) call void @sink(ptr %dst, i64 %na5_5)
%na5_6 = call i64 @strlcpy(ptr %dst, ptr @a5, i64 6) %na5_6 = call i64 @strlcpy(ptr %dst, ptr @a5, i64 6)
call void @sink(ptr %dst, i64 %na5_6) call void @sink(ptr %dst, i64 %na5_6)
%na5_9 = call i64 @strlcpy(ptr %dst, ptr @a5, i64 9) %na5_9 = call i64 @strlcpy(ptr %dst, ptr @a5, i64 9)
call void @sink(ptr %dst, i64 %na5_9) call void @sink(ptr %dst, i64 %na5_9)
ret void ret void
} }
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; BE: {{.*}}
; LE: {{.*}}

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

Show First 20 Lines • Show All 155 Lines • ▼ Show 20 Lines
; ;
call ptr @strncpy(ptr @a, ptr @b, i32 32) call ptr @strncpy(ptr @a, ptr @b, i32 32)
ret void ret void
} }
define void @test_no_simplify2() { define void @test_no_simplify2() {
; CHECK-LABEL: @test_no_simplify2( ; CHECK-LABEL: @test_no_simplify2(
; CHECK-NEXT: store i64 478560413032, ptr @a, align 1 ; CHECK-NEXT: store <8 x i8> <i8 104, i8 101, i8 108, i8 108, i8 111, i8 0, i8 0, i8 0>, ptr @a, align 1
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call ptr @strncpy(ptr @a, ptr @hello, i32 8) call ptr @strncpy(ptr @a, ptr @hello, i32 8)
ret void ret void
} }
define ptr @test_no_simplify3(ptr %dst, ptr %src, i32 %count) { define ptr @test_no_simplify3(ptr %dst, ptr %src, i32 %count) {
Show All 27 Lines

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

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -passes=instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
@str = constant [2 x i8] c"a\00" @str = constant [2 x i8] c"a\00"
@str2 = constant [3 x i8] c"abc" @str2 = constant [3 x i8] c"abc"
@str3 = constant [4 x i8] c"abcd" @str3 = constant [4 x i8] c"abcd"
declare ptr @strncpy(ptr, ptr, i64) declare ptr @strncpy(ptr, ptr, i64)
define void @fill_with_zeros(ptr %dst) { define void @fill_with_zeros(ptr %dst) {
; CHECK-LABEL: @fill_with_zeros( ; CHECK-LABEL: @fill_with_zeros(
; CHECK-NEXT: store i32 97, ptr [[DST:%.*]], align 1 ; CHECK-NEXT: store <4 x i8> <i8 97, i8 0, i8 0, i8 0>, ptr [[DST:%.*]], align 1
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
tail call ptr @strncpy(ptr %dst, ptr @str, i64 4) tail call ptr @strncpy(ptr %dst, ptr @str, i64 4)
ret void ret void
} }
define void @fill_with_zeros2(ptr %dst) { define void @fill_with_zeros2(ptr %dst) {
; CHECK-LABEL: @fill_with_zeros2( ; CHECK-LABEL: @fill_with_zeros2(
; CHECK-NEXT: store i32 6513249, ptr [[DST:%.*]], align 1 ; CHECK-NEXT: store <4 x i8> <i8 97, i8 98, i8 99, i8 0>, ptr [[DST:%.*]], align 1
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
tail call ptr @strncpy(ptr %dst, ptr @str2, i64 4) tail call ptr @strncpy(ptr %dst, ptr @str2, i64 4)
ret void ret void
} }
define void @fill_with_zeros3(ptr %dst) { define void @fill_with_zeros3(ptr %dst) {
; CHECK-LABEL: @fill_with_zeros3( ; CHECK-LABEL: @fill_with_zeros3(
; CHECK-NEXT: store i32 1684234849, ptr [[DST:%.*]], align 1 ; CHECK-NEXT: store <4 x i8> <i8 97, i8 98, i8 99, i8 100>, ptr [[DST:%.*]], align 1
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
tail call ptr @strncpy(ptr %dst, ptr @str3, i64 4) tail call ptr @strncpy(ptr %dst, ptr @str3, i64 4)
ret void ret void
} }
define void @fill_with_zeros4(ptr %dst) { define void @fill_with_zeros4(ptr %dst) {
; CHECK-LABEL: @fill_with_zeros4( ; CHECK-LABEL: @fill_with_zeros4(
Show All 15 Lines

llvm/test/Transforms/InstCombine/struct-assign-tbaa-new.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-globals
; RUN: opt -passes=instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
; ;
; Verify that instcombine preserves TBAA tags when converting a memcpy into ; Verify that instcombine preserves TBAA tags when converting a memcpy into
; a scalar load and store. ; a scalar load and store.
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind
%A = type { float } %A = type { float }
define void @test1(ptr %a1, ptr %a2) { define void @test1(ptr %a1, ptr %a2) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[A2:%.*]], align 4, !tbaa [[TBAA0:![0-9]+]] ; CHECK-NEXT: [[TMP0:%.*]] = load <4 x i8>, ptr [[A2:%.*]], align 4, !tbaa [[TBAA0:![0-9]+]]
; CHECK-NEXT: store i32 [[TMP0]], ptr [[A1:%.*]], align 4, !tbaa [[TBAA0]] ; CHECK-NEXT: store <4 x i8> [[TMP0]], ptr [[A1:%.*]], align 4, !tbaa [[TBAA0]]
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry: entry:
tail call void @llvm.memcpy.p0.p0.i64(ptr align 4 %a1, ptr align 4 %a2, i64 4, i1 false), !tbaa !4 ; TAG_A tail call void @llvm.memcpy.p0.p0.i64(ptr align 4 %a1, ptr align 4 %a2, i64 4, i1 false), !tbaa !4 ; TAG_A
ret void ret void
} }
%B = type { ptr } %B = type { ptr }
define ptr @test2() { define ptr @test2() {
; CHECK-LABEL: @test2( ; CHECK-LABEL: @test2(
; CHECK-NEXT: [[TMP:%.*]] = alloca [[B:%.*]], align 8 ; CHECK-NEXT: [[TMP:%.*]] = alloca [[B:%.*]], align 8
; CHECK-NEXT: store i64 poison, ptr null, align 4294967296 ; CHECK-NEXT: store <8 x i8> poison, ptr null, align 4294967296
; CHECK-NEXT: ret ptr [[TMP]] ; CHECK-NEXT: ret ptr [[TMP]]
; ;
%tmp = alloca %B, align 8 %tmp = alloca %B, align 8
call void @llvm.memcpy.p0.p0.i64(ptr align 8 %tmp, ptr align 8 undef, i64 8, i1 false), !tbaa !7 ; TAG_B call void @llvm.memcpy.p0.p0.i64(ptr align 8 %tmp, ptr align 8 undef, i64 8, i1 false), !tbaa !7 ; TAG_B
%tmp3 = load ptr, ptr %tmp %tmp3 = load ptr, ptr %tmp
ret ptr %tmp ret ptr %tmp
} }
Show All 21 Lines

llvm/test/Transforms/InstCombine/struct-assign-tbaa.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-globals
; RUN: opt -passes=instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind
; Verify that instcombine preserves TBAA tags when converting a memcpy into ; Verify that instcombine preserves TBAA tags when converting a memcpy into
; a scalar load and store. ; a scalar load and store.
%struct.test1 = type { float } %struct.test1 = type { float }
define void @test1(ptr nocapture %a, ptr nocapture %b) { define void @test1(ptr nocapture %a, ptr nocapture %b) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[B:%.*]], align 4, !tbaa [[TBAA0:![0-9]+]] ; CHECK-NEXT: [[TMP0:%.*]] = load <4 x i8>, ptr [[B:%.*]], align 4, !tbaa [[TBAA0:![0-9]+]]
; CHECK-NEXT: store i32 [[TMP0]], ptr [[A:%.*]], align 4, !tbaa [[TBAA0]] ; CHECK-NEXT: store <4 x i8> [[TMP0]], ptr [[A:%.*]], align 4, !tbaa [[TBAA0]]
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry: entry:
tail call void @llvm.memcpy.p0.p0.i64(ptr align 4 %a, ptr align 4 %b, i64 4, i1 false), !tbaa.struct !3 tail call void @llvm.memcpy.p0.p0.i64(ptr align 4 %a, ptr align 4 %b, i64 4, i1 false), !tbaa.struct !3
ret void ret void
} }
%struct.test2 = type { ptr } %struct.test2 = type { ptr }
define ptr @test2() { define ptr @test2() {
; CHECK-LABEL: @test2( ; CHECK-LABEL: @test2(
; CHECK-NEXT: [[TMP:%.*]] = alloca [[STRUCT_TEST2:%.*]], align 8 ; CHECK-NEXT: [[TMP:%.*]] = alloca [[STRUCT_TEST2:%.*]], align 8
; CHECK-NEXT: store i64 poison, ptr null, align 4294967296 ; CHECK-NEXT: store <8 x i8> poison, ptr null, align 4294967296
; CHECK-NEXT: ret ptr [[TMP]] ; CHECK-NEXT: ret ptr [[TMP]]
; ;
%tmp = alloca %struct.test2, align 8 %tmp = alloca %struct.test2, align 8
call void @llvm.memcpy.p0.p0.i64(ptr align 8 %tmp, ptr align 8 undef, i64 8, i1 false), !tbaa.struct !4 call void @llvm.memcpy.p0.p0.i64(ptr align 8 %tmp, ptr align 8 undef, i64 8, i1 false), !tbaa.struct !4
%tmp3 = load ptr, ptr %tmp %tmp3 = load ptr, ptr %tmp
ret ptr %tmp ret ptr %tmp
} }
Show All 14 Lines

llvm/test/Transforms/PhaseOrdering/X86/SROA-after-final-loop-unrolling-2.ll

Show All 21 Lines
define dso_local void @foo(i32 noundef %arg, ptr noundef nonnull align 4 dereferenceable(8) %arg1) #0 { define dso_local void @foo(i32 noundef %arg, ptr noundef nonnull align 4 dereferenceable(8) %arg1) #0 {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: bb: ; CHECK-NEXT: bb:
; CHECK-NEXT: [[I9:%.*]] = sdiv i32 [[ARG:%.*]], 128 ; CHECK-NEXT: [[I9:%.*]] = sdiv i32 [[ARG:%.*]], 128
; CHECK-NEXT: [[I10:%.*]] = shl nsw i32 [[I9]], 7 ; CHECK-NEXT: [[I10:%.*]] = shl nsw i32 [[I9]], 7
; CHECK-NEXT: [[ARG_OFF:%.*]] = add i32 [[ARG]], 127 ; CHECK-NEXT: [[ARG_OFF:%.*]] = add i32 [[ARG]], 127
; CHECK-NEXT: [[TMP0:%.*]] = icmp ult i32 [[ARG_OFF]], 255 ; CHECK-NEXT: [[TMP0:%.*]] = icmp ult i32 [[ARG_OFF]], 255
; CHECK-NEXT: br i1 [[TMP0]], label [[BB12:%.*]], label [[BB13:%.*]] ; CHECK-NEXT: br i1 [[TMP0]], label [[BB12:%.*]], label [[BB13:%.*]]
; CHECK: bb12.loopexit:
; CHECK-NEXT: [[I3_SROA_8_0_INSERT_EXT:%.*]] = zext i32 [[I21_3:%.*]] to i64
; CHECK-NEXT: [[I3_SROA_8_0_INSERT_SHIFT:%.*]] = shl nuw i64 [[I3_SROA_8_0_INSERT_EXT]], 32
; CHECK-NEXT: [[I3_SROA_0_0_INSERT_EXT:%.*]] = zext i32 [[I21_2:%.*]] to i64
; CHECK-NEXT: [[I3_SROA_0_0_INSERT_INSERT:%.*]] = or i64 [[I3_SROA_8_0_INSERT_SHIFT]], [[I3_SROA_0_0_INSERT_EXT]]
; CHECK-NEXT: br label [[BB12]]
; CHECK: bb12: ; CHECK: bb12:
; CHECK-NEXT: [[TMP1:%.*]] = phi i64 [ [[I3_SROA_0_0_INSERT_INSERT]], [[BB12_LOOPEXIT:%.*]] ], [ 180388626456, [[BB:%.*]] ] ; CHECK-NEXT: [[TMP1:%.*]] = phi <8 x i8> [ <i8 24, i8 0, i8 0, i8 0, i8 42, i8 0, i8 0, i8 0>, [[BB:%.*]] ], [ [[I3_SROA_0_4_VECBLEND24:%.*]], [[BB13]] ]
; CHECK-NEXT: store i64 [[TMP1]], ptr [[ARG1:%.*]], align 4, !tbaa [[TBAA5:![0-9]+]] ; CHECK-NEXT: store <8 x i8> [[TMP1]], ptr [[ARG1:%.*]], align 4, !tbaa [[TBAA5:![0-9]+]]
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; CHECK: bb13: ; CHECK: bb13:
; CHECK-NEXT: [[I3_SROA_8_0:%.*]] = phi i32 [ [[I21_3]], [[BB13]] ], [ 42, [[BB]] ] ; CHECK-NEXT: [[I3_SROA_0_0:%.*]] = phi <8 x i8> [ [[I3_SROA_0_4_VECBLEND24]], [[BB13]] ], [ <i8 24, i8 0, i8 0, i8 0, i8 42, i8 0, i8 0, i8 0>, [[BB]] ]
; CHECK-NEXT: [[I3_SROA_0_0:%.*]] = phi i32 [ [[I21_2]], [[BB13]] ], [ 24, [[BB]] ]
; CHECK-NEXT: [[I4_05:%.*]] = phi i32 [ [[I24_3:%.*]], [[BB13]] ], [ 0, [[BB]] ] ; CHECK-NEXT: [[I4_05:%.*]] = phi i32 [ [[I24_3:%.*]], [[BB13]] ], [ 0, [[BB]] ]
; CHECK-NEXT: [[I21:%.*]] = mul nsw i32 [[I3_SROA_0_0]], [[I4_05]] ; CHECK-NEXT: [[I3_SROA_0_0_VEC_EXTRACT_BC:%.*]] = bitcast <8 x i8> [[I3_SROA_0_0]] to <2 x i32>
; CHECK-NEXT: [[I3_SROA_0_0_VEC_EXTRACT_EXTRACT:%.*]] = extractelement <2 x i32> [[I3_SROA_0_0_VEC_EXTRACT_BC]], i64 0
; CHECK-NEXT: [[I21:%.*]] = mul nsw i32 [[I3_SROA_0_0_VEC_EXTRACT_EXTRACT]], [[I4_05]]
; CHECK-NEXT: [[TMP2:%.*]] = bitcast i32 [[I21]] to <4 x i8>
; CHECK-NEXT: [[I3_SROA_0_0_VEC_EXPAND:%.*]] = shufflevector <4 x i8> [[TMP2]], <4 x i8> poison, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef>
; CHECK-NEXT: [[I3_SROA_0_0_VECBLEND:%.*]] = shufflevector <8 x i8> [[I3_SROA_0_0_VEC_EXPAND]], <8 x i8> [[I3_SROA_0_0]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 12, i32 13, i32 14, i32 15>
; CHECK-NEXT: [[I24:%.*]] = or i32 [[I4_05]], 1 ; CHECK-NEXT: [[I24:%.*]] = or i32 [[I4_05]], 1
; CHECK-NEXT: [[I21_1:%.*]] = mul nsw i32 [[I3_SROA_8_0]], [[I24]] ; CHECK-NEXT: [[I3_SROA_0_4_VEC_EXTRACT_BC:%.*]] = bitcast <8 x i8> [[I3_SROA_0_0_VECBLEND]] to <2 x i32>
; CHECK-NEXT: [[I3_SROA_0_4_VEC_EXTRACT_EXTRACT:%.*]] = extractelement <2 x i32> [[I3_SROA_0_4_VEC_EXTRACT_BC]], i64 1
; CHECK-NEXT: [[I21_1:%.*]] = mul nsw i32 [[I3_SROA_0_4_VEC_EXTRACT_EXTRACT]], [[I24]]
; CHECK-NEXT: [[TMP3:%.*]] = bitcast i32 [[I21_1]] to <4 x i8>
; CHECK-NEXT: [[I3_SROA_0_4_VEC_EXPAND:%.*]] = shufflevector <4 x i8> [[TMP3]], <4 x i8> poison, <8 x i32> <i32 undef, i32 undef, i32 undef, i32 undef, i32 0, i32 1, i32 2, i32 3>
; CHECK-NEXT: [[I3_SROA_0_4_VECBLEND:%.*]] = shufflevector <8 x i8> [[I3_SROA_0_0_VECBLEND]], <8 x i8> [[I3_SROA_0_4_VEC_EXPAND]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 12, i32 13, i32 14, i32 15>
; CHECK-NEXT: [[I24_1:%.*]] = or i32 [[I4_05]], 2 ; CHECK-NEXT: [[I24_1:%.*]] = or i32 [[I4_05]], 2
; CHECK-NEXT: [[I21_2]] = mul nsw i32 [[I21]], [[I24_1]] ; CHECK-NEXT: [[I3_SROA_0_0_VEC_EXTRACT18_BC:%.*]] = bitcast <8 x i8> [[I3_SROA_0_4_VECBLEND]] to <2 x i32>
; CHECK-NEXT: [[I3_SROA_0_0_VEC_EXTRACT18_EXTRACT:%.*]] = extractelement <2 x i32> [[I3_SROA_0_0_VEC_EXTRACT18_BC]], i64 0
; CHECK-NEXT: [[I21_2:%.*]] = mul nsw i32 [[I3_SROA_0_0_VEC_EXTRACT18_EXTRACT]], [[I24_1]]
; CHECK-NEXT: [[TMP4:%.*]] = bitcast i32 [[I21_2]] to <4 x i8>
; CHECK-NEXT: [[I3_SROA_0_0_VEC_EXPAND15:%.*]] = shufflevector <4 x i8> [[TMP4]], <4 x i8> poison, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef>
; CHECK-NEXT: [[I3_SROA_0_0_VECBLEND16:%.*]] = shufflevector <8 x i8> [[I3_SROA_0_0_VEC_EXPAND15]], <8 x i8> [[I3_SROA_0_4_VECBLEND]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 12, i32 13, i32 14, i32 15>
; CHECK-NEXT: [[I24_2:%.*]] = or i32 [[I4_05]], 3 ; CHECK-NEXT: [[I24_2:%.*]] = or i32 [[I4_05]], 3
; CHECK-NEXT: [[I21_3]] = mul nsw i32 [[I21_1]], [[I24_2]] ; CHECK-NEXT: [[I3_SROA_0_4_VEC_EXTRACT21_BC:%.*]] = bitcast <8 x i8> [[I3_SROA_0_0_VECBLEND16]] to <2 x i32>
; CHECK-NEXT: [[I3_SROA_0_4_VEC_EXTRACT21_EXTRACT:%.*]] = extractelement <2 x i32> [[I3_SROA_0_4_VEC_EXTRACT21_BC]], i64 1
; CHECK-NEXT: [[I21_3:%.*]] = mul nsw i32 [[I3_SROA_0_4_VEC_EXTRACT21_EXTRACT]], [[I24_2]]
; CHECK-NEXT: [[TMP5:%.*]] = bitcast i32 [[I21_3]] to <4 x i8>
; CHECK-NEXT: [[I3_SROA_0_4_VEC_EXPAND23:%.*]] = shufflevector <4 x i8> [[TMP5]], <4 x i8> poison, <8 x i32> <i32 undef, i32 undef, i32 undef, i32 undef, i32 0, i32 1, i32 2, i32 3>
; CHECK-NEXT: [[I3_SROA_0_4_VECBLEND24]] = shufflevector <8 x i8> [[I3_SROA_0_0_VECBLEND16]], <8 x i8> [[I3_SROA_0_4_VEC_EXPAND23]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 12, i32 13, i32 14, i32 15>
; CHECK-NEXT: [[I24_3]] = add nuw nsw i32 [[I4_05]], 4 ; CHECK-NEXT: [[I24_3]] = add nuw nsw i32 [[I4_05]], 4
; CHECK-NEXT: [[I11_NOT_3:%.*]] = icmp eq i32 [[I24_3]], [[I10]] ; CHECK-NEXT: [[I11_NOT_3:%.*]] = icmp eq i32 [[I24_3]], [[I10]]
; CHECK-NEXT: br i1 [[I11_NOT_3]], label [[BB12_LOOPEXIT]], label [[BB13]], !llvm.loop [[LOOP8:![0-9]+]] ; CHECK-NEXT: br i1 [[I11_NOT_3]], label [[BB12]], label [[BB13]], !llvm.loop [[LOOP8:![0-9]+]]
; ;
bb: bb:
%i = alloca i32, align 4 %i = alloca i32, align 4
%i2 = alloca ptr, align 8 %i2 = alloca ptr, align 8
%i3 = alloca %t0, align 4 %i3 = alloca %t0, align 4
%i4 = alloca i32, align 4 %i4 = alloca i32, align 4
%i5 = alloca ptr, align 8 %i5 = alloca ptr, align 8
store i32 %arg, ptr %i, align 4, !tbaa !5 store i32 %arg, ptr %i, align 4, !tbaa !5
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines