This is an archive of the discontinued LLVM Phabricator instance.

Differential D31041

Add address space mangling to lifetime intrinsics
ClosedPublic

Authored by arsenm on Mar 16 2017, 10:52 AM.

Details

Reviewers
rjmccall
craig.topper
mehdi_amini
javed.absar
efriedma
Summary

In preparation for allowing allocas to have non-0 addrspace.

Diff Detail

Event Timeline

arsenm created this revision.Mar 16 2017, 10:52 AM
Herald added a reviewer: javed.absar. · View Herald TranscriptMar 16 2017, 10:53 AM
Herald added subscribers: nhaehnle, wdng, nemanjai and 3 others. · View Herald Transcript
arsenm added a child revision: D31043: Update for lifetime intrinsic signature change.Mar 16 2017, 10:55 AM
arsenm added a child revision: D31044: Update for alloca construction changes.
arsenm added a comment.Mar 21 2017, 9:19 AM

ping

arsenm added a reviewer: efriedma.Mar 23 2017, 11:23 AM
efriedma added reviewers: craig.topper, mehdi_amini.Mar 24 2017, 12:15 PM
arsenm mentioned this in D31042: Allow DataLayout to specify addrspace for allocas..Mar 27 2017, 2:26 PM
arsenm added a reviewer: rjmccall.Apr 4 2017, 12:10 PM
yaxunl added a subscriber: yaxunl.Apr 6 2017, 8:33 AM
t-tye added a subscriber: t-tye.Apr 6 2017, 8:45 AM
arsenm added a comment.Apr 10 2017, 11:47 AM

ping

rjmccall accepted this revision.Apr 10 2017, 12:45 PM

I don't normally do code review for non-Clang patches, just design review, but this one seems to only touch code that I feel comfortable signing off on. LGTM.

This revision is now accepted and ready to land.Apr 10 2017, 12:45 PM
arsenm closed this revision.Apr 10 2017, 1:31 PM

r299876

Revision Contents

PathSize
include/
llvm/
IR/
14 lines
lib/
IR/
29 lines
6 lines
test/
Analysis/
BasicAA/
6 lines
LazyValueAnalysis/
8 lines
Assembler/
19 lines
CodeGen/
AArch64/
GlobalISel/
8 lines
8 lines
AMDGPU/
8 lines
8 lines
ARM/
4 lines
8 lines
8 lines
BPF/
12 lines
Hexagon/
4 lines
12 lines
36 lines
8 lines
4 lines
8 lines
8 lines
12 lines
Mips/
8 lines
4 lines
NVPTX/
8 lines
PowerPC/
4 lines
8 lines
12 lines
16 lines
20 lines
8 lines
6 lines
28 lines
SystemZ/
8 lines
Thumb/
16 lines
10 lines
8 lines
Thumb2/
4 lines
8 lines
X86/
8 lines
194 lines
12 lines
12 lines
8 lines
4 lines
12 lines
12 lines
8 lines
4 lines
4 lines
36 lines
4 lines
10 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
Instrumentation/
AddressSanitizer/
12 lines
8 lines
34 lines
28 lines
28 lines
12 lines
MemorySanitizer/
AArch64/
8 lines
Mips/
8 lines
8 lines
PowerPC/
8 lines
8 lines
Transforms/
AddDiscriminators/
8 lines
AtomicExpand/
SPARC/
44 lines
BBVectorize/
X86/
8 lines
CodeGenPrepare/
20 lines
Coroutines/
4 lines
CorrelatedValuePropagation/
8 lines
DeadStoreElimination/
6 lines
10 lines
GVN/
8 lines
8 lines
GVNHoist/
4 lines
IndVarSimplify/
8 lines
Inline/
8 lines
4 lines
4 lines
40 lines
InstCombine/
12 lines
8 lines
8 lines
8 lines
12 lines
40 lines
8 lines
4 lines
12 lines
LoopVectorize/
24 lines
Mem2Reg/
12 lines
MemCpyOpt/
8 lines
12 lines
6 lines
16 lines
NewGVN/
8 lines
8 lines
SROA/
26 lines
4 lines
8 lines
SafeStack/
X86/
8 lines
12 lines
16 lines
162 lines
4 lines
16 lines
SampleProfile/
12 lines
SimplifyCFG/
4 lines
8 lines
8 lines
Util/
MemorySSA/
12 lines

Diff 92020

include/llvm/IR/Intrinsics.td

Show First 20 Lines • Show All 595 Lines • ▼ Show 20 Linesdef int_smul_with_overflow : Intrinsic<[llvm_anyint_ty, llvm_i1_ty],
[IntrNoMem]>; [IntrNoMem]>;
def int_umul_with_overflow : Intrinsic<[llvm_anyint_ty, llvm_i1_ty], def int_umul_with_overflow : Intrinsic<[llvm_anyint_ty, llvm_i1_ty],
[LLVMMatchType<0>, LLVMMatchType<0>], [LLVMMatchType<0>, LLVMMatchType<0>],
[IntrNoMem]>; [IntrNoMem]>;
//===------------------------- Memory Use Markers -------------------------===// //===------------------------- Memory Use Markers -------------------------===//
// //
def int_lifetime_start : Intrinsic<[], def int_lifetime_start : Intrinsic<[],
[llvm_i64_ty, llvm_ptr_ty], [llvm_i64_ty, llvm_anyptr_ty],
[IntrArgMemOnly, NoCapture<1>]>; [IntrArgMemOnly, NoCapture<1>]>;
def int_lifetime_end : Intrinsic<[], def int_lifetime_end : Intrinsic<[],
[llvm_i64_ty, llvm_ptr_ty], [llvm_i64_ty, llvm_anyptr_ty],
[IntrArgMemOnly, NoCapture<1>]>; [IntrArgMemOnly, NoCapture<1>]>;
def int_invariant_start : Intrinsic<[llvm_descriptor_ty], def int_invariant_start : Intrinsic<[llvm_descriptor_ty],
[llvm_i64_ty, llvm_anyptr_ty], [llvm_i64_ty, llvm_anyptr_ty],
[IntrArgMemOnly, NoCapture<1>]>; [IntrArgMemOnly, NoCapture<1>]>;
def int_invariant_end : Intrinsic<[], def int_invariant_end : Intrinsic<[],
[llvm_descriptor_ty, llvm_i64_ty, [llvm_descriptor_ty, llvm_i64_ty,
llvm_anyptr_ty], llvm_anyptr_ty],
[IntrArgMemOnly, NoCapture<2>]>; [IntrArgMemOnly, NoCapture<2>]>;
Show All 34 Linesdef int_experimental_gc_relocate : Intrinsic<[llvm_any_ty],
[llvm_token_ty, llvm_i32_ty, llvm_i32_ty], [llvm_token_ty, llvm_i32_ty, llvm_i32_ty],
[IntrReadMem]>; [IntrReadMem]>;
//===------------------------ Coroutine Intrinsics ---------------===// //===------------------------ Coroutine Intrinsics ---------------===//
// These are documented in docs/Coroutines.rst // These are documented in docs/Coroutines.rst
// Coroutine Structure Intrinsics. // Coroutine Structure Intrinsics.
def int_coro_id : Intrinsic<[llvm_token_ty], [llvm_i32_ty, llvm_ptr_ty, def int_coro_id : Intrinsic<[llvm_token_ty], [llvm_i32_ty, llvm_ptr_ty,
llvm_ptr_ty, llvm_ptr_ty], llvm_ptr_ty, llvm_ptr_ty],
[IntrArgMemOnly, IntrReadMem, [IntrArgMemOnly, IntrReadMem,
ReadNone<1>, ReadOnly<2>, NoCapture<2>]>; ReadNone<1>, ReadOnly<2>, NoCapture<2>]>;
def int_coro_alloc : Intrinsic<[llvm_i1_ty], [llvm_token_ty], []>; def int_coro_alloc : Intrinsic<[llvm_i1_ty], [llvm_token_ty], []>;
def int_coro_begin : Intrinsic<[llvm_ptr_ty], [llvm_token_ty, llvm_ptr_ty], def int_coro_begin : Intrinsic<[llvm_ptr_ty], [llvm_token_ty, llvm_ptr_ty],
[WriteOnly<1>]>; [WriteOnly<1>]>;
def int_coro_free : Intrinsic<[llvm_ptr_ty], [llvm_token_ty, llvm_ptr_ty], def int_coro_free : Intrinsic<[llvm_ptr_ty], [llvm_token_ty, llvm_ptr_ty],
[IntrReadMem, IntrArgMemOnly, ReadOnly<1>, [IntrReadMem, IntrArgMemOnly, ReadOnly<1>,
NoCapture<1>]>; NoCapture<1>]>;
def int_coro_end : Intrinsic<[llvm_i1_ty], [llvm_ptr_ty, llvm_i1_ty], []>; def int_coro_end : Intrinsic<[llvm_i1_ty], [llvm_ptr_ty, llvm_i1_ty], []>;
def int_coro_frame : Intrinsic<[llvm_ptr_ty], [], [IntrNoMem]>; def int_coro_frame : Intrinsic<[llvm_ptr_ty], [], [IntrNoMem]>;
def int_coro_size : Intrinsic<[llvm_anyint_ty], [], [IntrNoMem]>; def int_coro_size : Intrinsic<[llvm_anyint_ty], [], [IntrNoMem]>;
def int_coro_save : Intrinsic<[llvm_token_ty], [llvm_ptr_ty], []>; def int_coro_save : Intrinsic<[llvm_token_ty], [llvm_ptr_ty], []>;
def int_coro_suspend : Intrinsic<[llvm_i8_ty], [llvm_token_ty, llvm_i1_ty], []>; def int_coro_suspend : Intrinsic<[llvm_i8_ty], [llvm_token_ty, llvm_i1_ty], []>;
▲ Show 20 Lines • Show All 128 Lines • Show Last 20 Lines

lib/IR/AutoUpgrade.cpp

Show First 20 Lines • Show All 405 Lines • ▼ Show 20 Lines case 'c': {
if (Name.startswith("cttz.") && F->arg_size() == 1) { if (Name.startswith("cttz.") && F->arg_size() == 1) {
rename(F); rename(F);
NewFn = Intrinsic::getDeclaration(F->getParent(), Intrinsic::cttz, NewFn = Intrinsic::getDeclaration(F->getParent(), Intrinsic::cttz,
F->arg_begin()->getType()); F->arg_begin()->getType());
return true; return true;
} }
break; break;
} }
case 'i': { case 'i':
if (Name.startswith("invariant.start")) { case 'l': {
bool IsLifetimeStart = Name.startswith("lifetime.start");
if (IsLifetimeStart || Name.startswith("invariant.start")) {
Intrinsic::ID ID = IsLifetimeStart ?
Intrinsic::lifetime_start : Intrinsic::invariant_start;
auto Args = F->getFunctionType()->params(); auto Args = F->getFunctionType()->params();
Type* ObjectPtr[1] = {Args[1]}; Type* ObjectPtr[1] = {Args[1]};
if (F->getName() != if (F->getName() != Intrinsic::getName(ID, ObjectPtr)) {
Intrinsic::getName(Intrinsic::invariant_start, ObjectPtr)) {
rename(F); rename(F);
NewFn = Intrinsic::getDeclaration( NewFn = Intrinsic::getDeclaration(F->getParent(), ID, ObjectPtr);
F->getParent(), Intrinsic::invariant_start, ObjectPtr);
return true; return true;
} }
} }
if (Name.startswith("invariant.end")) {
bool IsLifetimeEnd = Name.startswith("lifetime.end");
if (IsLifetimeEnd || Name.startswith("invariant.end")) {
Intrinsic::ID ID = IsLifetimeEnd ?
Intrinsic::lifetime_end : Intrinsic::invariant_end;
auto Args = F->getFunctionType()->params(); auto Args = F->getFunctionType()->params();
Type* ObjectPtr[1] = {Args[2]}; Type* ObjectPtr[1] = {Args[IsLifetimeEnd ? 1 : 2]};
if (F->getName() != if (F->getName() != Intrinsic::getName(ID, ObjectPtr)) {
Intrinsic::getName(Intrinsic::invariant_end, ObjectPtr)) {
rename(F); rename(F);
NewFn = Intrinsic::getDeclaration(F->getParent(), NewFn = Intrinsic::getDeclaration(F->getParent(), ID, ObjectPtr);
Intrinsic::invariant_end, ObjectPtr);
return true; return true;
} }
} }
break; break;
} }
case 'm': { case 'm': {
if (Name.startswith("masked.load.")) { if (Name.startswith("masked.load.")) {
Type *Tys[] = { F->getReturnType(), F->arg_begin()->getType() }; Type *Tys[] = { F->getReturnType(), F->arg_begin()->getType() };
▲ Show 20 Lines • Show All 1,801 Lines • Show Last 20 Lines

lib/IR/IRBuilder.cpp

Show First 20 Lines • Show All 166 Lines • ▼ Show 20 LinesCallInst *IRBuilderBase::CreateLifetimeStart(Value *Ptr, ConstantInt *Size) {
Ptr = getCastedInt8PtrValue(Ptr); Ptr = getCastedInt8PtrValue(Ptr);
if (!Size) if (!Size)
Size = getInt64(-1); Size = getInt64(-1);
else else
assert(Size->getType() == getInt64Ty() && assert(Size->getType() == getInt64Ty() &&
"lifetime.start requires the size to be an i64"); "lifetime.start requires the size to be an i64");
Value *Ops[] = { Size, Ptr }; Value *Ops[] = { Size, Ptr };
Module *M = BB->getParent()->getParent(); Module *M = BB->getParent()->getParent();
Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::lifetime_start); Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::lifetime_start,
{ Ptr->getType() });
return createCallHelper(TheFn, Ops, this); return createCallHelper(TheFn, Ops, this);
} }
CallInst *IRBuilderBase::CreateLifetimeEnd(Value *Ptr, ConstantInt *Size) { CallInst *IRBuilderBase::CreateLifetimeEnd(Value *Ptr, ConstantInt *Size) {
assert(isa<PointerType>(Ptr->getType()) && assert(isa<PointerType>(Ptr->getType()) &&
"lifetime.end only applies to pointers."); "lifetime.end only applies to pointers.");
Ptr = getCastedInt8PtrValue(Ptr); Ptr = getCastedInt8PtrValue(Ptr);
if (!Size) if (!Size)
Size = getInt64(-1); Size = getInt64(-1);
else else
assert(Size->getType() == getInt64Ty() && assert(Size->getType() == getInt64Ty() &&
"lifetime.end requires the size to be an i64"); "lifetime.end requires the size to be an i64");
Value *Ops[] = { Size, Ptr }; Value *Ops[] = { Size, Ptr };
Module *M = BB->getParent()->getParent(); Module *M = BB->getParent()->getParent();
Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::lifetime_end); Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::lifetime_end,
{ Ptr->getType() });
return createCallHelper(TheFn, Ops, this); return createCallHelper(TheFn, Ops, this);
} }
CallInst *IRBuilderBase::CreateInvariantStart(Value *Ptr, ConstantInt *Size) { CallInst *IRBuilderBase::CreateInvariantStart(Value *Ptr, ConstantInt *Size) {
assert(isa<PointerType>(Ptr->getType()) && assert(isa<PointerType>(Ptr->getType()) &&
"invariant.start only applies to pointers."); "invariant.start only applies to pointers.");
Ptr = getCastedInt8PtrValue(Ptr); Ptr = getCastedInt8PtrValue(Ptr);
▲ Show 20 Lines • Show All 294 Lines • Show Last 20 Lines

test/Analysis/BasicAA/modref.ll

; RUN: opt < %s -basicaa -gvn -dse -S | FileCheck %s ; RUN: opt < %s -basicaa -gvn -dse -S | FileCheck %s
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
declare void @external(i32*) declare void @external(i32*)
define i32 @test0(i8* %P) { define i32 @test0(i8* %P) {
%A = alloca i32 %A = alloca i32
call void @external(i32* %A) call void @external(i32* %A)
store i32 0, i32* %A store i32 0, i32* %A
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
; CHECK-LABEL: @test3 ; CHECK-LABEL: @test3
; CHECK-NOT: store ; CHECK-NOT: store
; CHECK-NOT: %Y ; CHECK-NOT: %Y
%Y = add i8 %X, 1 ;; Dead, because the only use (the store) is dead. %Y = add i8 %X, 1 ;; Dead, because the only use (the store) is dead.
%P2 = getelementptr i8, i8* %P, i32 2 %P2 = getelementptr i8, i8* %P, i32 2
store i8 %Y, i8* %P2 ;; Not read by lifetime.end, should be removed. store i8 %Y, i8* %P2 ;; Not read by lifetime.end, should be removed.
; CHECK: store i8 2, i8* %P2 ; CHECK: store i8 2, i8* %P2
call void @llvm.lifetime.end(i64 1, i8* %P) call void @llvm.lifetime.end.p0i8(i64 1, i8* %P)
store i8 2, i8* %P2 store i8 2, i8* %P2
; CHECK-NOT: store ; CHECK-NOT: store
ret void ret void
; CHECK: ret void ; CHECK: ret void
} }
define void @test3a(i8* %P, i8 %X) { define void @test3a(i8* %P, i8 %X) {
; CHECK-LABEL: @test3a ; CHECK-LABEL: @test3a
%Y = add i8 %X, 1 ;; Dead, because the only use (the store) is dead. %Y = add i8 %X, 1 ;; Dead, because the only use (the store) is dead.
%P2 = getelementptr i8, i8* %P, i32 2 %P2 = getelementptr i8, i8* %P, i32 2
store i8 %Y, i8* %P2 store i8 %Y, i8* %P2
; CHECK-NEXT: call void @llvm.lifetime.end ; CHECK-NEXT: call void @llvm.lifetime.end
call void @llvm.lifetime.end(i64 10, i8* %P) call void @llvm.lifetime.end.p0i8(i64 10, i8* %P)
ret void ret void
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
} }
@G1 = external global i32 @G1 = external global i32
@G2 = external global [4000 x i32] @G2 = external global [4000 x i32]
define i32 @test4(i8* %P) { define i32 @test4(i8* %P) {
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

test/Analysis/LazyValueAnalysis/invalidation.ll

Show All 23 Lines
; CHECK-DT-INVALIDATE: Invalidating analysis: LazyValueAnalysis ; CHECK-DT-INVALIDATE: Invalidating analysis: LazyValueAnalysis
; CHECK-AC-INVALIDATE: Running pass: RequireAnalysisPass ; CHECK-AC-INVALIDATE: Running pass: RequireAnalysisPass
; CHECK-DT-INVALIDATE: Running analysis: LazyValueAnalysis ; CHECK-DT-INVALIDATE: Running analysis: LazyValueAnalysis
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@.str = private unnamed_addr constant [8 x i8] c"a = %l\0A\00", align 1 @.str = private unnamed_addr constant [8 x i8] c"a = %l\0A\00", align 1
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @hoo(i64*) declare void @hoo(i64*)
declare i32 @printf(i8* nocapture readonly, ...) declare i32 @printf(i8* nocapture readonly, ...)
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
define void @goo(i32 %N, i64* %b) { define void @goo(i32 %N, i64* %b) {
entry: entry:
%a.i = alloca i64, align 8 %a.i = alloca i64, align 8
%tmp = bitcast i64* %a.i to i8* %tmp = bitcast i64* %a.i to i8*
%c = getelementptr inbounds i64, i64* %b, i64 0 %c = getelementptr inbounds i64, i64* %b, i64 0
br label %for.cond br label %for.cond
for.cond: ; preds = %for.body, %entry for.cond: ; preds = %for.body, %entry
%i.0 = phi i32 [ 0, %entry ], [ %inc, %for.body ] %i.0 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
%cmp = icmp slt i32 %i.0, %N %cmp = icmp slt i32 %i.0, %N
br i1 %cmp, label %for.body, label %for.end br i1 %cmp, label %for.body, label %for.end
for.body: ; preds = %for.cond for.body: ; preds = %for.cond
call void @llvm.lifetime.start(i64 8, i8* %tmp) call void @llvm.lifetime.start.p0i8(i64 8, i8* %tmp)
call void @hoo(i64* %a.i) call void @hoo(i64* %a.i)
call void @hoo(i64* %c) call void @hoo(i64* %c)
%tmp1 = load volatile i64, i64* %a.i, align 8 %tmp1 = load volatile i64, i64* %a.i, align 8
%call.i = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i64 %tmp1) %call.i = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i64 %tmp1)
call void @llvm.lifetime.end(i64 8, i8* %tmp) call void @llvm.lifetime.end.p0i8(i64 8, i8* %tmp)
%inc = add nsw i32 %i.0, 1 %inc = add nsw i32 %i.0, 1
br label %for.cond br label %for.cond
for.end: ; preds = %for.cond for.end: ; preds = %for.cond
ret void ret void
} }

test/Assembler/auto_upgrade_intrinsics.ll

Show First 20 Lines • Show All 95 Lines • ▼ Show 20 Lines
define void @test.stackprotectorcheck() { define void @test.stackprotectorcheck() {
; CHECK-LABEL: @test.stackprotectorcheck( ; CHECK-LABEL: @test.stackprotectorcheck(
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
call void @llvm.stackprotectorcheck(i8** @__stack_chk_guard) call void @llvm.stackprotectorcheck(i8** @__stack_chk_guard)
ret void ret void
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) nounwind readonly
declare void @llvm.lifetime.end(i64, i8* nocapture) nounwind
define void @tests.lifetime.start.end() {
; CHECK-LABEL: @tests.lifetime.start.end(
%a = alloca i8
call void @llvm.lifetime.start(i64 1, i8* %a)
; CHECK: call void @llvm.lifetime.start.p0i8(i64 1, i8* %a)
store i8 0, i8* %a
call void @llvm.lifetime.end(i64 1, i8* %a)
; CHECK: call void @llvm.lifetime.end.p0i8(i64 1, i8* %a)
ret void
}
; This is part of @test.objectsize(), since llvm.objectsize declaration gets ; This is part of @test.objectsize(), since llvm.objectsize declaration gets
; emitted at the end. ; emitted at the end.
; CHECK: declare i32 @llvm.objectsize.i32.p0i8 ; CHECK: declare i32 @llvm.objectsize.i32.p0i8
; CHECK: declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
; CHECK: declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)

test/CodeGen/AArch64/GlobalISel/arm64-irtranslator.ll

Show First 20 Lines • Show All 1,216 Lines • ▼ Show 20 Lines
; CHECK: [[LHS:%[0-9]+]](s32) = COPY %s0 ; CHECK: [[LHS:%[0-9]+]](s32) = COPY %s0
; CHECK: [[RHS:%[0-9]+]](s32) = COPY %s1 ; CHECK: [[RHS:%[0-9]+]](s32) = COPY %s1
; CHECK: [[RES:%[0-9]+]](s32) = G_FPOW [[LHS]], [[RHS]] ; CHECK: [[RES:%[0-9]+]](s32) = G_FPOW [[LHS]], [[RHS]]
; CHECK: %s0 = COPY [[RES]] ; CHECK: %s0 = COPY [[RES]]
%res = call float @llvm.pow.f32(float %l, float %r) %res = call float @llvm.pow.f32(float %l, float %r)
ret float %res ret float %res
} }
declare void @llvm.lifetime.start(i64, i8*) declare void @llvm.lifetime.start.p0i8(i64, i8*)
declare void @llvm.lifetime.end(i64, i8*) declare void @llvm.lifetime.end.p0i8(i64, i8*)
define void @test_lifetime_intrin() { define void @test_lifetime_intrin() {
; CHECK-LABEL: name: test_lifetime_intrin ; CHECK-LABEL: name: test_lifetime_intrin
; CHECK: RET_ReallyLR ; CHECK: RET_ReallyLR
%slot = alloca i8, i32 4 %slot = alloca i8, i32 4
call void @llvm.lifetime.start(i64 0, i8* %slot) call void @llvm.lifetime.start.p0i8(i64 0, i8* %slot)
call void @llvm.lifetime.end(i64 0, i8* %slot) call void @llvm.lifetime.end.p0i8(i64 0, i8* %slot)
ret void ret void
} }
define void @test_load_store_atomics(i8* %addr) { define void @test_load_store_atomics(i8* %addr) {
; CHECK-LABEL: name: test_load_store_atomics ; CHECK-LABEL: name: test_load_store_atomics
; CHECK: [[ADDR:%[0-9]+]](p0) = COPY %x0 ; CHECK: [[ADDR:%[0-9]+]](p0) = COPY %x0
; CHECK: [[V0:%[0-9]+]](s8) = G_LOAD [[ADDR]](p0) :: (load unordered 1 from %ir.addr) ; CHECK: [[V0:%[0-9]+]](s8) = G_LOAD [[ADDR]](p0) :: (load unordered 1 from %ir.addr)
; CHECK: G_STORE [[V0]](s8), [[ADDR]](p0) :: (store monotonic 1 into %ir.addr) ; CHECK: G_STORE [[V0]](s8), [[ADDR]](p0) :: (store monotonic 1 into %ir.addr)
▲ Show 20 Lines • Show All 163 Lines • Show Last 20 Lines

test/CodeGen/AArch64/stack_guard_remat.ll

Show All 23 Lines
; STATIC-SMALL: foo2 ; STATIC-SMALL: foo2
; STATIC-SMALL: adrp [[R0:x[0-9]+]], __stack_chk_guard ; STATIC-SMALL: adrp [[R0:x[0-9]+]], __stack_chk_guard
; STATIC-SMALL: ldr {{x[0-9]+}}, {{\[}}[[R0]], :lo12:__stack_chk_guard{{\]}} ; STATIC-SMALL: ldr {{x[0-9]+}}, {{\[}}[[R0]], :lo12:__stack_chk_guard{{\]}}
define i32 @test_stack_guard_remat() #0 { define i32 @test_stack_guard_remat() #0 {
entry: entry:
%a1 = alloca [256 x i32], align 4 %a1 = alloca [256 x i32], align 4
%0 = bitcast [256 x i32]* %a1 to i8* %0 = bitcast [256 x i32]* %a1 to i8*
call void @llvm.lifetime.start(i64 1024, i8* %0) call void @llvm.lifetime.start.p0i8(i64 1024, i8* %0)
%arraydecay = getelementptr inbounds [256 x i32], [256 x i32]* %a1, i64 0, i64 0 %arraydecay = getelementptr inbounds [256 x i32], [256 x i32]* %a1, i64 0, i64 0
call void @foo3(i32* %arraydecay) call void @foo3(i32* %arraydecay)
call void asm sideeffect "foo2", "~{w0},~{w1},~{w2},~{w3},~{w4},~{w5},~{w6},~{w7},~{w8},~{w9},~{w10},~{w11},~{w12},~{w13},~{w14},~{w15},~{w16},~{w17},~{w18},~{w19},~{w20},~{w21},~{w22},~{w23},~{w24},~{w25},~{w26},~{w27},~{w28},~{w29},~{w30}"() call void asm sideeffect "foo2", "~{w0},~{w1},~{w2},~{w3},~{w4},~{w5},~{w6},~{w7},~{w8},~{w9},~{w10},~{w11},~{w12},~{w13},~{w14},~{w15},~{w16},~{w17},~{w18},~{w19},~{w20},~{w21},~{w22},~{w23},~{w24},~{w25},~{w26},~{w27},~{w28},~{w29},~{w30}"()
call void @llvm.lifetime.end(i64 1024, i8* %0) call void @llvm.lifetime.end.p0i8(i64 1024, i8* %0)
ret i32 0 ret i32 0
} }
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @foo3(i32*) declare void @foo3(i32*)
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
attributes #0 = { nounwind sspstrong "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #0 = { nounwind sspstrong "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }

test/CodeGen/AMDGPU/captured-frame-index.ll

; RUN: llc -mtriple=amdgcn-- -mattr=-promote-alloca -amdgpu-sroa=0 -verify-machineinstrs < %s | FileCheck -check-prefix=GCN %s ; RUN: llc -mtriple=amdgcn-- -mattr=-promote-alloca -amdgpu-sroa=0 -verify-machineinstrs < %s | FileCheck -check-prefix=GCN %s
; GCN-LABEL: {{^}}store_fi_lifetime: ; GCN-LABEL: {{^}}store_fi_lifetime:
; GCN: v_mov_b32_e32 [[FI:v[0-9]+]], 4{{$}} ; GCN: v_mov_b32_e32 [[FI:v[0-9]+]], 4{{$}}
; GCN: buffer_store_dword [[FI]] ; GCN: buffer_store_dword [[FI]]
define void @store_fi_lifetime(i32 addrspace(1)* %out, i32 %in) #0 { define void @store_fi_lifetime(i32 addrspace(1)* %out, i32 %in) #0 {
entry: entry:
%b = alloca i8 %b = alloca i8
call void @llvm.lifetime.start(i64 1, i8* %b) call void @llvm.lifetime.start.p0i8(i64 1, i8* %b)
store volatile i8* %b, i8* addrspace(1)* undef store volatile i8* %b, i8* addrspace(1)* undef
call void @llvm.lifetime.end(i64 1, i8* %b) call void @llvm.lifetime.end.p0i8(i64 1, i8* %b)
ret void ret void
} }
; GCN-LABEL: {{^}}stored_fi_to_lds: ; GCN-LABEL: {{^}}stored_fi_to_lds:
; GCN: s_load_dword [[LDSPTR:s[0-9]+]] ; GCN: s_load_dword [[LDSPTR:s[0-9]+]]
; GCN: buffer_store_dword v{{[0-9]+}}, off, ; GCN: buffer_store_dword v{{[0-9]+}}, off,
; GCN: v_mov_b32_e32 [[ZERO0:v[0-9]+]], 4{{$}} ; GCN: v_mov_b32_e32 [[ZERO0:v[0-9]+]], 4{{$}}
; GCN: v_mov_b32_e32 [[VLDSPTR:v[0-9]+]], [[LDSPTR]] ; GCN: v_mov_b32_e32 [[VLDSPTR:v[0-9]+]], [[LDSPTR]]
▲ Show 20 Lines • Show All 171 Lines • ▼ Show 20 Linesentry:
%b = alloca i32, align 4 %b = alloca i32, align 4
%tmp1 = load volatile i32*, i32* addrspace(1)* @g1, align 4 %tmp1 = load volatile i32*, i32* addrspace(1)* @g1, align 4
%arrayidx = getelementptr inbounds i32, i32* %tmp1, i32 %idx %arrayidx = getelementptr inbounds i32, i32* %tmp1, i32 %idx
%tmp2 = load i32, i32* %arrayidx, align 4 %tmp2 = load i32, i32* %arrayidx, align 4
store volatile i32* %b, i32* addrspace(1)* undef store volatile i32* %b, i32* addrspace(1)* undef
ret void ret void
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
attributes #0 = { nounwind } attributes #0 = { nounwind }
attributes #1 = { argmemonly nounwind } attributes #1 = { argmemonly nounwind }

test/CodeGen/AMDGPU/promote-alloca-lifetime.ll

; RUN: opt -S -mtriple=amdgcn-unknown-amdhsa -amdgpu-promote-alloca %s | FileCheck -check-prefix=OPT %s ; RUN: opt -S -mtriple=amdgcn-unknown-amdhsa -amdgpu-promote-alloca %s | FileCheck -check-prefix=OPT %s
declare void @llvm.lifetime.start(i64, i8* nocapture) #0 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #0
declare void @llvm.lifetime.end(i64, i8* nocapture) #0 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #0
; OPT-LABEL: @use_lifetime_promotable_lds( ; OPT-LABEL: @use_lifetime_promotable_lds(
; OPT-NOT: alloca i32 ; OPT-NOT: alloca i32
; OPT-NOT: llvm.lifetime ; OPT-NOT: llvm.lifetime
; OPT: store i32 %tmp3, i32 addrspace(3)* ; OPT: store i32 %tmp3, i32 addrspace(3)*
define void @use_lifetime_promotable_lds(i32 addrspace(1)* %arg) #2 { define void @use_lifetime_promotable_lds(i32 addrspace(1)* %arg) #2 {
bb: bb:
%tmp = alloca i32, align 4 %tmp = alloca i32, align 4
%tmp1 = bitcast i32* %tmp to i8* %tmp1 = bitcast i32* %tmp to i8*
call void @llvm.lifetime.start(i64 4, i8* %tmp1) call void @llvm.lifetime.start.p0i8(i64 4, i8* %tmp1)
%tmp2 = getelementptr inbounds i32, i32 addrspace(1)* %arg, i64 1 %tmp2 = getelementptr inbounds i32, i32 addrspace(1)* %arg, i64 1
%tmp3 = load i32, i32 addrspace(1)* %tmp2 %tmp3 = load i32, i32 addrspace(1)* %tmp2
store i32 %tmp3, i32* %tmp store i32 %tmp3, i32* %tmp
call void @llvm.lifetime.end(i64 4, i8* %tmp1) call void @llvm.lifetime.end.p0i8(i64 4, i8* %tmp1)
ret void ret void
} }
attributes #0 = { argmemonly nounwind } attributes #0 = { argmemonly nounwind }
attributes #1 = { nounwind readnone } attributes #1 = { nounwind readnone }
attributes #2 = { nounwind } attributes #2 = { nounwind }

test/CodeGen/ARM/interval-update-remat.ll

Show First 20 Lines • Show All 103 Lines • ▼ Show 20 Lines
_ZN7MessageD1Ev.exit: ; preds = %if.then.i.i.i.i, %if.end _ZN7MessageD1Ev.exit: ; preds = %if.then.i.i.i.i, %if.end
%connect_.i.i = getelementptr inbounds %class.StaticSocketDataProvider.6.231.281.1306.2331, %class.StaticSocketDataProvider.6.231.281.1306.2331* %socket_data, i32 0, i32 1 %connect_.i.i = getelementptr inbounds %class.StaticSocketDataProvider.6.231.281.1306.2331, %class.StaticSocketDataProvider.6.231.281.1306.2331* %socket_data, i32 0, i32 1
%tmp3 = bitcast %struct.MockConnect.5.230.280.1305.2330* %connect_.i.i to %"class.(anonymous namespace)::__vector_base.21.246.296.1321.2346"* %tmp3 = bitcast %struct.MockConnect.5.230.280.1305.2330* %connect_.i.i to %"class.(anonymous namespace)::__vector_base.21.246.296.1321.2346"*
%call.i.i.i.i.i.i.i.i.i.i = call %"class.(anonymous namespace)::__vector_base.21.246.296.1321.2346"* @_ZN12_GLOBAL__N_113__vector_baseD2Ev(%"class.(anonymous namespace)::__vector_base.21.246.296.1321.2346"* %tmp3) %call.i.i.i.i.i.i.i.i.i.i = call %"class.(anonymous namespace)::__vector_base.21.246.296.1321.2346"* @_ZN12_GLOBAL__N_113__vector_baseD2Ev(%"class.(anonymous namespace)::__vector_base.21.246.296.1321.2346"* %tmp3)
ret void ret void
} }
; Function Attrs: argmemonly nounwind ; Function Attrs: argmemonly nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) #0 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #0
declare %class.StaticSocketDataProvider.6.231.281.1306.2331* @_ZN24StaticSocketDataProviderC1EP13MockReadWritejS1_j(%class.StaticSocketDataProvider.6.231.281.1306.2331* returned, %struct.MockReadWrite.7.232.282.1307.2332*, i32, %struct.MockReadWrite.7.232.282.1307.2332*, i32) unnamed_addr declare %class.StaticSocketDataProvider.6.231.281.1306.2331* @_ZN24StaticSocketDataProviderC1EP13MockReadWritejS1_j(%class.StaticSocketDataProvider.6.231.281.1306.2331* returned, %struct.MockReadWrite.7.232.282.1307.2332*, i32, %struct.MockReadWrite.7.232.282.1307.2332*, i32) unnamed_addr
declare void @_ZN24StaticSocketDataProvider5m_fn8E11MockConnect(%class.StaticSocketDataProvider.6.231.281.1306.2331*, %struct.MockConnect.5.230.280.1305.2330*) declare void @_ZN24StaticSocketDataProvider5m_fn8E11MockConnect(%class.StaticSocketDataProvider.6.231.281.1306.2331*, %struct.MockConnect.5.230.280.1305.2330*)
declare %struct.MockConnect.5.230.280.1305.2330* @_ZN11MockConnectC1Ev(%struct.MockConnect.5.230.280.1305.2330* returned) unnamed_addr declare %struct.MockConnect.5.230.280.1305.2330* @_ZN11MockConnectC1Ev(%struct.MockConnect.5.230.280.1305.2330* returned) unnamed_addr
declare %class.TestCompletionCallback.9.234.284.1309.2334* @_ZN22TestCompletionCallbackC1Ev(%class.TestCompletionCallback.9.234.284.1309.2334* returned) unnamed_addr declare %class.TestCompletionCallback.9.234.284.1309.2334* @_ZN22TestCompletionCallbackC1Ev(%class.TestCompletionCallback.9.234.284.1309.2334* returned) unnamed_addr
declare i32 @_ZN29MockTransportClientSocketPool5m_fn9Ev(%class.MockTransportClientSocketPool.0.225.275.1300.2325*) declare i32 @_ZN29MockTransportClientSocketPool5m_fn9Ev(%class.MockTransportClientSocketPool.0.225.275.1300.2325*)
declare %class.AssertHelper.10.235.285.1310.2335* @_ZN12AssertHelperC1EPKc(%class.AssertHelper.10.235.285.1310.2335* returned, i8*) unnamed_addr declare %class.AssertHelper.10.235.285.1310.2335* @_ZN12AssertHelperC1EPKc(%class.AssertHelper.10.235.285.1310.2335* returned, i8*) unnamed_addr
declare void @_ZN12AssertHelperaSE7Message(%class.AssertHelper.10.235.285.1310.2335*, %class.Message.13.238.288.1313.2338*) declare void @_ZN12AssertHelperaSE7Message(%class.AssertHelper.10.235.285.1310.2335*, %class.Message.13.238.288.1313.2338*)
declare %class.Message.13.238.288.1313.2338* @_ZN7MessageC1Ev(%class.Message.13.238.288.1313.2338* returned) unnamed_addr declare %class.Message.13.238.288.1313.2338* @_ZN7MessageC1Ev(%class.Message.13.238.288.1313.2338* returned) unnamed_addr
declare %class.AssertHelper.10.235.285.1310.2335* @_ZN12AssertHelperD1Ev(%class.AssertHelper.10.235.285.1310.2335* returned) unnamed_addr declare %class.AssertHelper.10.235.285.1310.2335* @_ZN12AssertHelperD1Ev(%class.AssertHelper.10.235.285.1310.2335* returned) unnamed_addr
; Function Attrs: argmemonly nounwind ; Function Attrs: argmemonly nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) #0 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #0
declare void @_ZN18ClientSocketHandle5m_fn3IPiEEvRK25Trans_NS___1_basic_stringIciiE13scoped_refptr15RequestPriorityN16ClientSocketPool13RespectLimitsERiT_11BoundNetLog(%class.ClientSocketHandle.14.239.289.1314.2339*, %class.Trans_NS___1_basic_string.18.243.293.1318.2343* dereferenceable(12), %class.scoped_refptr.19.244.294.1319.2344*, i32, i32, i32* dereferenceable(4), i32*, %class.BoundNetLog.20.245.295.1320.2345*) declare void @_ZN18ClientSocketHandle5m_fn3IPiEEvRK25Trans_NS___1_basic_stringIciiE13scoped_refptr15RequestPriorityN16ClientSocketPool13RespectLimitsERiT_11BoundNetLog(%class.ClientSocketHandle.14.239.289.1314.2339*, %class.Trans_NS___1_basic_string.18.243.293.1318.2343* dereferenceable(12), %class.scoped_refptr.19.244.294.1319.2344*, i32, i32, i32* dereferenceable(4), i32*, %class.BoundNetLog.20.245.295.1320.2345*)
declare void @_Z19CreateSOCKSv5Paramsv(%class.scoped_refptr.19.244.294.1319.2344* sret) declare void @_Z19CreateSOCKSv5Paramsv(%class.scoped_refptr.19.244.294.1319.2344* sret)
; Function Attrs: argmemonly nounwind ; Function Attrs: argmemonly nounwind
declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i32, i1) #0 declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i32, i1) #0
Show All 21 Lines

test/CodeGen/ARM/ldrd.ll

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
entry: entry:
; A8: movw [[BASE:r[0-9]+]], :lower16:{{.*}}TestVar{{.*}} ; A8: movw [[BASE:r[0-9]+]], :lower16:{{.*}}TestVar{{.*}}
; A8: movt [[BASE]], :upper16:{{.*}}TestVar{{.*}} ; A8: movt [[BASE]], :upper16:{{.*}}TestVar{{.*}}
; A8: ldrd [[FIELD1:r[0-9]+]], [[FIELD2:r[0-9]+]], {{\[}}[[BASE]], #4] ; A8: ldrd [[FIELD1:r[0-9]+]], [[FIELD2:r[0-9]+]], {{\[}}[[BASE]], #4]
; A8-NEXT: add [[FIELD1]], [[FIELD2]] ; A8-NEXT: add [[FIELD1]], [[FIELD2]]
; A8-NEXT: str [[FIELD1]], {{\[}}[[BASE]]{{\]}} ; A8-NEXT: str [[FIELD1]], {{\[}}[[BASE]]{{\]}}
; CONSERVATIVE-NOT: ldrd ; CONSERVATIVE-NOT: ldrd
%orig_blocks = alloca [256 x i16], align 2 %orig_blocks = alloca [256 x i16], align 2
%0 = bitcast [256 x i16]* %orig_blocks to i8*call void @llvm.lifetime.start(i64 512, i8* %0) nounwind %0 = bitcast [256 x i16]* %orig_blocks to i8*call void @llvm.lifetime.start.p0i8(i64 512, i8* %0) nounwind
%tmp1 = load i32, i32* getelementptr inbounds (%struct.Test, %struct.Test* @TestVar, i32 0, i32 1), align 4 %tmp1 = load i32, i32* getelementptr inbounds (%struct.Test, %struct.Test* @TestVar, i32 0, i32 1), align 4
%tmp2 = load i32, i32* getelementptr inbounds (%struct.Test, %struct.Test* @TestVar, i32 0, i32 2), align 4 %tmp2 = load i32, i32* getelementptr inbounds (%struct.Test, %struct.Test* @TestVar, i32 0, i32 2), align 4
%add = add nsw i32 %tmp2, %tmp1 %add = add nsw i32 %tmp2, %tmp1
store i32 %add, i32* getelementptr inbounds (%struct.Test, %struct.Test* @TestVar, i32 0, i32 0), align 4 store i32 %add, i32* getelementptr inbounds (%struct.Test, %struct.Test* @TestVar, i32 0, i32 0), align 4
call void @llvm.lifetime.end(i64 512, i8* %0) nounwind call void @llvm.lifetime.end.p0i8(i64 512, i8* %0) nounwind
ret void ret void
} }
declare void @extfunc(i32, i32, i32, i32) declare void @extfunc(i32, i32, i32, i32)
; CHECK-LABEL: Func2: ; CHECK-LABEL: Func2:
; CONSERVATIVE-NOT: ldrd ; CONSERVATIVE-NOT: ldrd
; A8: ldrd ; A8: ldrd
▲ Show 20 Lines • Show All 79 Lines • ▼ Show 20 Lines
define i32* @strd_postupdate_inc(i32* %p0, i32 %v0, i32 %v1) "no-frame-pointer-elim"="true" { define i32* @strd_postupdate_inc(i32* %p0, i32 %v0, i32 %v1) "no-frame-pointer-elim"="true" {
%p0.1 = getelementptr i32, i32* %p0, i32 1 %p0.1 = getelementptr i32, i32* %p0, i32 1
store i32 %v0, i32* %p0 store i32 %v0, i32* %p0
store i32 %v1, i32* %p0.1 store i32 %v1, i32* %p0.1
%p1 = getelementptr i32, i32* %p0, i32 2 %p1 = getelementptr i32, i32* %p0, i32 2
ret i32* %p1 ret i32* %p1
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) nounwind declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) nounwind declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) nounwind

test/CodeGen/ARM/stack_guard_remat.ll

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
;DYNAMIC-NO-PIC-V7: L___stack_chk_guard$non_lazy_ptr: ;DYNAMIC-NO-PIC-V7: L___stack_chk_guard$non_lazy_ptr:
;DYNAMIC-NO-PIC-V7: .indirect_symbol ___stack_chk_guard ;DYNAMIC-NO-PIC-V7: .indirect_symbol ___stack_chk_guard
; Function Attrs: nounwind ssp ; Function Attrs: nounwind ssp
define i32 @test_stack_guard_remat() #0 { define i32 @test_stack_guard_remat() #0 {
%a1 = alloca [256 x i32], align 4 %a1 = alloca [256 x i32], align 4
%1 = bitcast [256 x i32]* %a1 to i8* %1 = bitcast [256 x i32]* %a1 to i8*
call void @llvm.lifetime.start(i64 1024, i8* %1) call void @llvm.lifetime.start.p0i8(i64 1024, i8* %1)
%2 = getelementptr inbounds [256 x i32], [256 x i32]* %a1, i32 0, i32 0 %2 = getelementptr inbounds [256 x i32], [256 x i32]* %a1, i32 0, i32 0
call void @foo3(i32* %2) #3 call void @foo3(i32* %2) #3
call void asm sideeffect "foo2", "~{r0},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{sp},~{lr}"() call void asm sideeffect "foo2", "~{r0},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{sp},~{lr}"()
call void @llvm.lifetime.end(i64 1024, i8* %1) call void @llvm.lifetime.end.p0i8(i64 1024, i8* %1)
ret i32 0 ret i32 0
} }
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @foo3(i32*) declare void @foo3(i32*)
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
attributes #0 = { nounwind ssp "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #0 = { nounwind ssp "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }

test/CodeGen/BPF/warn-stack.ll

; RUN: not llc -march=bpfel < %s 2>&1 >/dev/null | FileCheck %s ; RUN: not llc -march=bpfel < %s 2>&1 >/dev/null | FileCheck %s
;; CHECK-NOT: nowarn ;; CHECK-NOT: nowarn
define void @nowarn() local_unnamed_addr #0 !dbg !6 { define void @nowarn() local_unnamed_addr #0 !dbg !6 {
%1 = alloca [504 x i8], align 1 %1 = alloca [504 x i8], align 1
%2 = getelementptr inbounds [504 x i8], [504 x i8]* %1, i64 0, i64 0, !dbg !15 %2 = getelementptr inbounds [504 x i8], [504 x i8]* %1, i64 0, i64 0, !dbg !15
call void @llvm.lifetime.start(i64 504, i8* nonnull %2) #4, !dbg !15 call void @llvm.lifetime.start.p0i8(i64 504, i8* nonnull %2) #4, !dbg !15
tail call void @llvm.dbg.declare(metadata [504 x i8]* %1, metadata !10, metadata !16), !dbg !17 tail call void @llvm.dbg.declare(metadata [504 x i8]* %1, metadata !10, metadata !16), !dbg !17
call void @doit(i8* nonnull %2) #4, !dbg !18 call void @doit(i8* nonnull %2) #4, !dbg !18
call void @llvm.lifetime.end(i64 504, i8* nonnull %2) #4, !dbg !19 call void @llvm.lifetime.end.p0i8(i64 504, i8* nonnull %2) #4, !dbg !19
ret void, !dbg !19 ret void, !dbg !19
} }
; Function Attrs: argmemonly nounwind ; Function Attrs: argmemonly nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
; Function Attrs: nounwind readnone ; Function Attrs: nounwind readnone
declare void @llvm.dbg.declare(metadata, metadata, metadata) #2 declare void @llvm.dbg.declare(metadata, metadata, metadata) #2
declare void @doit(i8*) local_unnamed_addr #3 declare void @doit(i8*) local_unnamed_addr #3
; Function Attrs: argmemonly nounwind ; Function Attrs: argmemonly nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
; CHECK: error: warn_stack.c ; CHECK: error: warn_stack.c
; CHECK: BPF stack limit ; CHECK: BPF stack limit
define void @warn() local_unnamed_addr #0 !dbg !20 { define void @warn() local_unnamed_addr #0 !dbg !20 {
%1 = alloca [512 x i8], align 1 %1 = alloca [512 x i8], align 1
%2 = getelementptr inbounds [512 x i8], [512 x i8]* %1, i64 0, i64 0, !dbg !26 %2 = getelementptr inbounds [512 x i8], [512 x i8]* %1, i64 0, i64 0, !dbg !26
call void @llvm.lifetime.start(i64 512, i8* nonnull %2) #4, !dbg !26 call void @llvm.lifetime.start.p0i8(i64 512, i8* nonnull %2) #4, !dbg !26
tail call void @llvm.dbg.declare(metadata [512 x i8]* %1, metadata !22, metadata !16), !dbg !27 tail call void @llvm.dbg.declare(metadata [512 x i8]* %1, metadata !22, metadata !16), !dbg !27
call void @doit(i8* nonnull %2) #4, !dbg !28 call void @doit(i8* nonnull %2) #4, !dbg !28
call void @llvm.lifetime.end(i64 512, i8* nonnull %2) #4, !dbg !29 call void @llvm.lifetime.end.p0i8(i64 512, i8* nonnull %2) #4, !dbg !29
ret void, !dbg !29 ret void, !dbg !29
} }
attributes #0 = { nounwind "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #0 = { nounwind "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { argmemonly nounwind } attributes #1 = { argmemonly nounwind }
attributes #2 = { nounwind readnone } attributes #2 = { nounwind readnone }
attributes #3 = { "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #3 = { "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #4 = { nounwind } attributes #4 = { nounwind }
Show All 35 Lines

test/CodeGen/Hexagon/bit-rie.ll

Show First 20 Lines • Show All 181 Lines • ▼ Show 20 Lines
declare i32 @llvm.hexagon.A2.zxth(i32) #2 declare i32 @llvm.hexagon.A2.zxth(i32) #2
declare i32 @llvm.hexagon.M2.hmmpyl.s1(i32, i32) #2 declare i32 @llvm.hexagon.M2.hmmpyl.s1(i32, i32) #2
declare i32 @llvm.hexagon.M2.mpy.acc.sat.ll.s0(i32, i32, i32) #2 declare i32 @llvm.hexagon.M2.mpy.acc.sat.ll.s0(i32, i32, i32) #2
declare i32 @llvm.hexagon.S2.asl.r.r.sat(i32, i32) #2 declare i32 @llvm.hexagon.S2.asl.r.r.sat(i32, i32) #2
declare i32 @llvm.hexagon.S2.asr.r.r.sat(i32, i32) #2 declare i32 @llvm.hexagon.S2.asr.r.r.sat(i32, i32) #2
declare i32 @llvm.hexagon.S2.clbnorm(i32) #2 declare i32 @llvm.hexagon.S2.clbnorm(i32) #2
declare i32 @llvm.hexagon.S2.lsr.r.r(i32, i32) #2 declare i32 @llvm.hexagon.S2.lsr.r.r(i32, i32) #2
declare i64 @llvm.hexagon.M2.mpyd.ll.s1(i32, i32) #2 declare i64 @llvm.hexagon.M2.mpyd.ll.s1(i32, i32) #2
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
attributes #0 = { norecurse nounwind "target-cpu"="hexagonv60" "target-features"="+hvx,-hvx-double" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #0 = { norecurse nounwind "target-cpu"="hexagonv60" "target-features"="+hvx,-hvx-double" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { argmemonly nounwind } attributes #1 = { argmemonly nounwind }
attributes #2 = { nounwind readnone } attributes #2 = { nounwind readnone }
!1 = !{!2, !2, i64 0} !1 = !{!2, !2, i64 0}
!2 = !{!"int", !3, i64 0} !2 = !{!"int", !3, i64 0}
Show All 9 Lines

test/CodeGen/Hexagon/hwloop-loop1.ll

; RUN: llc -march=hexagon -mcpu=hexagonv5 < %s | FileCheck %s ; RUN: llc -march=hexagon -mcpu=hexagonv5 < %s | FileCheck %s
; ;
; Generate loop1 instruction for double loop sequence. ; Generate loop1 instruction for double loop sequence.
; CHECK: loop1(.LBB{{.}}_{{.}},#100) ; CHECK: loop1(.LBB{{.}}_{{.}},#100)
; CHECK: loop0(.LBB{{.}}_{{.}},#100) ; CHECK: loop0(.LBB{{.}}_{{.}},#100)
; CHECK: endloop0 ; CHECK: endloop0
; CHECK: endloop1 ; CHECK: endloop1
define i32 @main() #0 { define i32 @main() #0 {
entry: entry:
%array = alloca [100 x i32], align 8 %array = alloca [100 x i32], align 8
%doublearray = alloca [100 x [100 x i32]], align 8 %doublearray = alloca [100 x [100 x i32]], align 8
%0 = bitcast [100 x i32]* %array to i8* %0 = bitcast [100 x i32]* %array to i8*
call void @llvm.lifetime.start(i64 400, i8* %0) #1 call void @llvm.lifetime.start.p0i8(i64 400, i8* %0) #1
%1 = bitcast [100 x [100 x i32]]* %doublearray to i8* %1 = bitcast [100 x [100 x i32]]* %doublearray to i8*
call void @llvm.lifetime.start(i64 40000, i8* %1) #1 call void @llvm.lifetime.start.p0i8(i64 40000, i8* %1) #1
%arrayidx1 = getelementptr inbounds [100 x [100 x i32]], [100 x [100 x i32]]* %doublearray, i32 0, i32 10, i32 10 %arrayidx1 = getelementptr inbounds [100 x [100 x i32]], [100 x [100 x i32]]* %doublearray, i32 0, i32 10, i32 10
%arrayidx2.gep = getelementptr [100 x i32], [100 x i32]* %array, i32 0, i32 0 %arrayidx2.gep = getelementptr [100 x i32], [100 x i32]* %array, i32 0, i32 0
br label %for.body br label %for.body
for.body: for.body:
%2 = phi i32 [ undef, %entry ], [ %.pre, %for.body.for.body_crit_edge ] %2 = phi i32 [ undef, %entry ], [ %.pre, %for.body.for.body_crit_edge ]
%sum.031 = phi i32 [ undef, %entry ], [ %add, %for.body.for.body_crit_edge ] %sum.031 = phi i32 [ undef, %entry ], [ %add, %for.body.for.body_crit_edge ]
%arrayidx2.phi = phi i32* [ %arrayidx2.gep, %entry ], [ %arrayidx2.inc, %for.body.for.body_crit_edge ] %arrayidx2.phi = phi i32* [ %arrayidx2.gep, %entry ], [ %arrayidx2.inc, %for.body.for.body_crit_edge ]
Show All 25 Lines
for.inc15: for.inc15:
%inc16 = add nsw i32 %i.129, 1 %inc16 = add nsw i32 %i.129, 1
%exitcond32 = icmp eq i32 %inc16, 100 %exitcond32 = icmp eq i32 %inc16, 100
br i1 %exitcond32, label %for.end17, label %for.cond7.preheader br i1 %exitcond32, label %for.end17, label %for.cond7.preheader
for.end17: for.end17:
%3 = load i32, i32* %arrayidx1, align 8 %3 = load i32, i32* %arrayidx1, align 8
call void @llvm.lifetime.end(i64 40000, i8* %1) #1 call void @llvm.lifetime.end.p0i8(i64 40000, i8* %1) #1
call void @llvm.lifetime.end(i64 400, i8* %0) #1 call void @llvm.lifetime.end.p0i8(i64 400, i8* %0) #1
ret i32 %3 ret i32 %3
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1

test/CodeGen/Hexagon/memops-stack.ll

; RUN: llc -march=hexagon < %s | FileCheck %s ; RUN: llc -march=hexagon < %s | FileCheck %s
target datalayout = "e-m:e-p:32:32:32-a:0-n16:32-i64:64:64-i32:32:32-i16:16:16-i1:8:8-f32:32:32-f64:64:64-v32:32:32-v64:64:64-v512:512:512-v1024:1024:1024-v2048:2048:2048" target datalayout = "e-m:e-p:32:32:32-a:0-n16:32-i64:64:64-i32:32:32-i16:16:16-i1:8:8-f32:32:32-f64:64:64-v32:32:32-v64:64:64-v512:512:512-v1024:1024:1024-v2048:2048:2048"
target triple = "hexagon" target triple = "hexagon"
; CHECK-LABEL: test0 ; CHECK-LABEL: test0
; CHECK: memw(r29+#{{[0-9]+}}) += #1 ; CHECK: memw(r29+#{{[0-9]+}}) += #1
define void @test0() #0 { define void @test0() #0 {
entry: entry:
%x = alloca i32, align 4 %x = alloca i32, align 4
%0 = bitcast i32* %x to i8* %0 = bitcast i32* %x to i8*
call void @llvm.lifetime.start(i64 4, i8* %0) #3 call void @llvm.lifetime.start.p0i8(i64 4, i8* %0) #3
call void @foo(i32* nonnull %x) #3 call void @foo(i32* nonnull %x) #3
%1 = load i32, i32* %x, align 4, !tbaa !1 %1 = load i32, i32* %x, align 4, !tbaa !1
%inc = add nsw i32 %1, 1 %inc = add nsw i32 %1, 1
store i32 %inc, i32* %x, align 4, !tbaa !1 store i32 %inc, i32* %x, align 4, !tbaa !1
call void @foo(i32* nonnull %x) #3 call void @foo(i32* nonnull %x) #3
call void @llvm.lifetime.end(i64 4, i8* %0) #3 call void @llvm.lifetime.end.p0i8(i64 4, i8* %0) #3
ret void ret void
} }
; CHECK-LABEL: test1 ; CHECK-LABEL: test1
; CHECK: memw(r29+#{{[0-9]+}}) -= #1 ; CHECK: memw(r29+#{{[0-9]+}}) -= #1
define void @test1() #0 { define void @test1() #0 {
entry: entry:
%x = alloca i32, align 4 %x = alloca i32, align 4
%0 = bitcast i32* %x to i8* %0 = bitcast i32* %x to i8*
call void @llvm.lifetime.start(i64 4, i8* %0) #3 call void @llvm.lifetime.start.p0i8(i64 4, i8* %0) #3
call void @foo(i32* nonnull %x) #3 call void @foo(i32* nonnull %x) #3
%1 = load i32, i32* %x, align 4, !tbaa !1 %1 = load i32, i32* %x, align 4, !tbaa !1
%inc = sub nsw i32 %1, 1 %inc = sub nsw i32 %1, 1
store i32 %inc, i32* %x, align 4, !tbaa !1 store i32 %inc, i32* %x, align 4, !tbaa !1
call void @foo(i32* nonnull %x) #3 call void @foo(i32* nonnull %x) #3
call void @llvm.lifetime.end(i64 4, i8* %0) #3 call void @llvm.lifetime.end.p0i8(i64 4, i8* %0) #3
ret void ret void
} }
; CHECK-LABEL: test2 ; CHECK-LABEL: test2
; CHECK: memw(r29+#{{[0-9]+}}) = setbit(#0) ; CHECK: memw(r29+#{{[0-9]+}}) = setbit(#0)
define void @test2() #0 { define void @test2() #0 {
entry: entry:
%x = alloca i32, align 4 %x = alloca i32, align 4
%0 = bitcast i32* %x to i8* %0 = bitcast i32* %x to i8*
call void @llvm.lifetime.start(i64 4, i8* %0) #3 call void @llvm.lifetime.start.p0i8(i64 4, i8* %0) #3
call void @foo(i32* nonnull %x) #3 call void @foo(i32* nonnull %x) #3
%1 = load i32, i32* %x, align 4, !tbaa !1 %1 = load i32, i32* %x, align 4, !tbaa !1
%inc = or i32 %1, 1 %inc = or i32 %1, 1
store i32 %inc, i32* %x, align 4, !tbaa !1 store i32 %inc, i32* %x, align 4, !tbaa !1
call void @foo(i32* nonnull %x) #3 call void @foo(i32* nonnull %x) #3
call void @llvm.lifetime.end(i64 4, i8* %0) #3 call void @llvm.lifetime.end.p0i8(i64 4, i8* %0) #3
ret void ret void
} }
; CHECK-LABEL: test3 ; CHECK-LABEL: test3
; CHECK: memw(r29+#{{[0-9]+}}) = clrbit(#0) ; CHECK: memw(r29+#{{[0-9]+}}) = clrbit(#0)
define void @test3() #0 { define void @test3() #0 {
entry: entry:
%x = alloca i32, align 4 %x = alloca i32, align 4
%0 = bitcast i32* %x to i8* %0 = bitcast i32* %x to i8*
call void @llvm.lifetime.start(i64 4, i8* %0) #3 call void @llvm.lifetime.start.p0i8(i64 4, i8* %0) #3
call void @foo(i32* nonnull %x) #3 call void @foo(i32* nonnull %x) #3
%1 = load i32, i32* %x, align 4, !tbaa !1 %1 = load i32, i32* %x, align 4, !tbaa !1
%inc = and i32 %1, -2 %inc = and i32 %1, -2
store i32 %inc, i32* %x, align 4, !tbaa !1 store i32 %inc, i32* %x, align 4, !tbaa !1
call void @foo(i32* nonnull %x) #3 call void @foo(i32* nonnull %x) #3
call void @llvm.lifetime.end(i64 4, i8* %0) #3 call void @llvm.lifetime.end.p0i8(i64 4, i8* %0) #3
ret void ret void
} }
; CHECK-LABEL: test4 ; CHECK-LABEL: test4
; CHECK: memw(r29+#{{[0-9]+}}) += r ; CHECK: memw(r29+#{{[0-9]+}}) += r
define void @test4(i32 %a) #0 { define void @test4(i32 %a) #0 {
entry: entry:
%x = alloca i32, align 4 %x = alloca i32, align 4
%0 = bitcast i32* %x to i8* %0 = bitcast i32* %x to i8*
call void @llvm.lifetime.start(i64 4, i8* %0) #3 call void @llvm.lifetime.start.p0i8(i64 4, i8* %0) #3
call void @foo(i32* nonnull %x) #3 call void @foo(i32* nonnull %x) #3
%1 = load i32, i32* %x, align 4, !tbaa !1 %1 = load i32, i32* %x, align 4, !tbaa !1
%inc = add nsw i32 %1, %a %inc = add nsw i32 %1, %a
store i32 %inc, i32* %x, align 4, !tbaa !1 store i32 %inc, i32* %x, align 4, !tbaa !1
call void @foo(i32* nonnull %x) #3 call void @foo(i32* nonnull %x) #3
call void @llvm.lifetime.end(i64 4, i8* %0) #3 call void @llvm.lifetime.end.p0i8(i64 4, i8* %0) #3
ret void ret void
} }
; CHECK-LABEL: test5 ; CHECK-LABEL: test5
; CHECK: memw(r29+#{{[0-9]+}}) -= r ; CHECK: memw(r29+#{{[0-9]+}}) -= r
define void @test5(i32 %a) #0 { define void @test5(i32 %a) #0 {
entry: entry:
%x = alloca i32, align 4 %x = alloca i32, align 4
%0 = bitcast i32* %x to i8* %0 = bitcast i32* %x to i8*
call void @llvm.lifetime.start(i64 4, i8* %0) #3 call void @llvm.lifetime.start.p0i8(i64 4, i8* %0) #3
call void @foo(i32* nonnull %x) #3 call void @foo(i32* nonnull %x) #3
%1 = load i32, i32* %x, align 4, !tbaa !1 %1 = load i32, i32* %x, align 4, !tbaa !1
%inc = sub nsw i32 %1, %a %inc = sub nsw i32 %1, %a
store i32 %inc, i32* %x, align 4, !tbaa !1 store i32 %inc, i32* %x, align 4, !tbaa !1
call void @foo(i32* nonnull %x) #3 call void @foo(i32* nonnull %x) #3
call void @llvm.lifetime.end(i64 4, i8* %0) #3 call void @llvm.lifetime.end.p0i8(i64 4, i8* %0) #3
ret void ret void
} }
; CHECK-LABEL: test6 ; CHECK-LABEL: test6
; CHECK: memw(r29+#{{[0-9]+}}) |= r ; CHECK: memw(r29+#{{[0-9]+}}) |= r
define void @test6(i32 %a) #0 { define void @test6(i32 %a) #0 {
entry: entry:
%x = alloca i32, align 4 %x = alloca i32, align 4
%0 = bitcast i32* %x to i8* %0 = bitcast i32* %x to i8*
call void @llvm.lifetime.start(i64 4, i8* %0) #3 call void @llvm.lifetime.start.p0i8(i64 4, i8* %0) #3
call void @foo(i32* nonnull %x) #3 call void @foo(i32* nonnull %x) #3
%1 = load i32, i32* %x, align 4, !tbaa !1 %1 = load i32, i32* %x, align 4, !tbaa !1
%inc = or i32 %1, %a %inc = or i32 %1, %a
store i32 %inc, i32* %x, align 4, !tbaa !1 store i32 %inc, i32* %x, align 4, !tbaa !1
call void @foo(i32* nonnull %x) #3 call void @foo(i32* nonnull %x) #3
call void @llvm.lifetime.end(i64 4, i8* %0) #3 call void @llvm.lifetime.end.p0i8(i64 4, i8* %0) #3
ret void ret void
} }
; CHECK-LABEL: test7 ; CHECK-LABEL: test7
; CHECK: memw(r29+#{{[0-9]+}}) &= r ; CHECK: memw(r29+#{{[0-9]+}}) &= r
define void @test7(i32 %a) #0 { define void @test7(i32 %a) #0 {
entry: entry:
%x = alloca i32, align 4 %x = alloca i32, align 4
%0 = bitcast i32* %x to i8* %0 = bitcast i32* %x to i8*
call void @llvm.lifetime.start(i64 4, i8* %0) #3 call void @llvm.lifetime.start.p0i8(i64 4, i8* %0) #3
call void @foo(i32* nonnull %x) #3 call void @foo(i32* nonnull %x) #3
%1 = load i32, i32* %x, align 4, !tbaa !1 %1 = load i32, i32* %x, align 4, !tbaa !1
%inc = and i32 %1, %a %inc = and i32 %1, %a
store i32 %inc, i32* %x, align 4, !tbaa !1 store i32 %inc, i32* %x, align 4, !tbaa !1
call void @foo(i32* nonnull %x) #3 call void @foo(i32* nonnull %x) #3
call void @llvm.lifetime.end(i64 4, i8* %0) #3 call void @llvm.lifetime.end.p0i8(i64 4, i8* %0) #3
ret void ret void
} }
declare void @foo(i32*) #2 declare void @foo(i32*) #2
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
attributes #0 = { nounwind "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="hexagonv60" "target-features"="+hvx,-hvx-double" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #0 = { nounwind "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="hexagonv60" "target-features"="+hvx,-hvx-double" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { argmemonly nounwind } attributes #1 = { argmemonly nounwind }
attributes #2 = { "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="hexagonv60" "target-features"="+hvx,-hvx-double" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #2 = { "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="hexagonv60" "target-features"="+hvx,-hvx-double" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #3 = { nounwind } attributes #3 = { nounwind }
!1 = !{!2, !2, i64 0} !1 = !{!2, !2, i64 0}
!2 = !{!"int", !3, i64 0} !2 = !{!"int", !3, i64 0}
!3 = !{!"omnipotent char", !4, i64 0} !3 = !{!"omnipotent char", !4, i64 0}
!4 = !{!"Simple C/C++ TBAA"} !4 = !{!"Simple C/C++ TBAA"}

test/CodeGen/Hexagon/opt-spill-volatile.ll

; RUN: llc -march=hexagon < %s | FileCheck %s ; RUN: llc -march=hexagon < %s | FileCheck %s
; Check that the load/store to the volatile stack object has not been ; Check that the load/store to the volatile stack object has not been
; optimized away. ; optimized away.
target triple = "hexagon" target triple = "hexagon"
; CHECK-LABEL: foo ; CHECK-LABEL: foo
; CHECK: memw(r29+#4) = ; CHECK: memw(r29+#4) =
; CHECK: = memw(r29+#4) ; CHECK: = memw(r29+#4)
define i32 @foo(i32 %a) #0 { define i32 @foo(i32 %a) #0 {
entry: entry:
%x = alloca i32, align 4 %x = alloca i32, align 4
%x.0.x.0..sroa_cast = bitcast i32* %x to i8* %x.0.x.0..sroa_cast = bitcast i32* %x to i8*
call void @llvm.lifetime.start(i64 4, i8* %x.0.x.0..sroa_cast) call void @llvm.lifetime.start.p0i8(i64 4, i8* %x.0.x.0..sroa_cast)
store volatile i32 0, i32* %x, align 4 store volatile i32 0, i32* %x, align 4
%call = tail call i32 bitcast (i32 (...)* @bar to i32 ()*)() #0 %call = tail call i32 bitcast (i32 (...)* @bar to i32 ()*)() #0
%x.0.x.0. = load volatile i32, i32* %x, align 4 %x.0.x.0. = load volatile i32, i32* %x, align 4
%add = add nsw i32 %x.0.x.0., %a %add = add nsw i32 %x.0.x.0., %a
call void @llvm.lifetime.end(i64 4, i8* %x.0.x.0..sroa_cast) call void @llvm.lifetime.end.p0i8(i64 4, i8* %x.0.x.0..sroa_cast)
ret i32 %add ret i32 %add
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
declare i32 @bar(...) #0 declare i32 @bar(...) #0
attributes #0 = { nounwind } attributes #0 = { nounwind }
attributes #1 = { argmemonly nounwind } attributes #1 = { argmemonly nounwind }

test/CodeGen/Hexagon/rdf-copy-undef2.ll

; RUN: llc -march=hexagon < %s ; RUN: llc -march=hexagon < %s
; REQUIRES: asserts ; REQUIRES: asserts
target triple = "hexagon" target triple = "hexagon"
declare void @llvm.lifetime.start(i64, i8* nocapture) #0 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #0
declare void @llvm.lifetime.end(i64, i8* nocapture) #0 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #0
declare signext i16 @cat(i16 signext) #1 declare signext i16 @cat(i16 signext) #1
declare void @danny(i16 signext, i16 signext, i16 signext, i16* nocapture readonly, i16 signext, i16* nocapture) #1 declare void @danny(i16 signext, i16 signext, i16 signext, i16* nocapture readonly, i16 signext, i16* nocapture) #1
declare void @sammy(i16* nocapture readonly, i16* nocapture readonly, i16* nocapture readonly, i32* nocapture, i16* nocapture, i16 signext, i16 signext, i16 signext) #1 declare void @sammy(i16* nocapture readonly, i16* nocapture readonly, i16* nocapture readonly, i32* nocapture, i16* nocapture, i16 signext, i16 signext, i16 signext) #1
declare i8* @llvm.stacksave() #2 declare i8* @llvm.stacksave() #2
declare void @llvm.stackrestore(i8*) #2 declare void @llvm.stackrestore(i8*) #2
define i32 @fred(i16 signext %p0, i16 signext %p1, i16* nocapture readonly %p2, i16 signext %p3, i16* nocapture readonly %p4, i16* nocapture %p5) #1 { define i32 @fred(i16 signext %p0, i16 signext %p1, i16* nocapture readonly %p2, i16 signext %p3, i16* nocapture readonly %p4, i16* nocapture %p5) #1 {
entry: entry:
Show All 40 Lines

test/CodeGen/Hexagon/rdf-inline-asm-fixed.ll

; RUN: llc -march=hexagon < %s | FileCheck %s ; RUN: llc -march=hexagon < %s | FileCheck %s
; CHECK: r0 = #24 ; CHECK: r0 = #24
; CHECK-NEXT: r1 = ; CHECK-NEXT: r1 =
; // R2 should be assigned a value from R3+. ; // R2 should be assigned a value from R3+.
; CHECK-NEXT: r2 = r{{[3-9]}} ; CHECK-NEXT: r2 = r{{[3-9]}}
; CHECK-NEXT: trap0 ; CHECK-NEXT: trap0
target datalayout = "e-m:e-p:32:32:32-i64:64:64-i32:32:32-i16:16:16-i1:8:8-f64:64:64-f32:32:32-v64:64:64-v32:32:32-a:0-n16:32" target datalayout = "e-m:e-p:32:32:32-i64:64:64-i32:32:32-i16:16:16-i1:8:8-f64:64:64-f32:32:32-v64:64:64-v32:32:32-a:0-n16:32"
target triple = "hexagon" target triple = "hexagon"
; Function Attrs: nounwind ; Function Attrs: nounwind
define i32 @foo(i32 %status) #0 { define i32 @foo(i32 %status) #0 {
entry: entry:
%arg1 = alloca i32, align 4 %arg1 = alloca i32, align 4
%0 = bitcast i32* %arg1 to i8* %0 = bitcast i32* %arg1 to i8*
call void @llvm.lifetime.start(i64 4, i8* %0) #2 call void @llvm.lifetime.start.p0i8(i64 4, i8* %0) #2
store i32 %status, i32* %arg1, align 4, !tbaa !1 store i32 %status, i32* %arg1, align 4, !tbaa !1
%1 = call i32 asm sideeffect "r0 = #$1\0Ar1 = $2\0Ar2 = $4\0Atrap0 (#0)\0A$0 = r0", "=r,i,r,*m,r,~{r0},~{r1},~{r2}"(i32 24, i32* nonnull %arg1, i32* nonnull %arg1, i32 %status) #2, !srcloc !5 %1 = call i32 asm sideeffect "r0 = #$1\0Ar1 = $2\0Ar2 = $4\0Atrap0 (#0)\0A$0 = r0", "=r,i,r,*m,r,~{r0},~{r1},~{r2}"(i32 24, i32* nonnull %arg1, i32* nonnull %arg1, i32 %status) #2, !srcloc !5
call void @llvm.lifetime.end(i64 4, i8* %0) #2 call void @llvm.lifetime.end.p0i8(i64 4, i8* %0) #2
ret i32 %1 ret i32 %1
} }
; Function Attrs: argmemonly nounwind ; Function Attrs: argmemonly nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
; Function Attrs: argmemonly nounwind ; Function Attrs: argmemonly nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
attributes #0 = { nounwind "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="hexagonv5" "target-features"="-hvx,-hvx-double" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #0 = { nounwind "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="hexagonv5" "target-features"="-hvx,-hvx-double" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { argmemonly nounwind } attributes #1 = { argmemonly nounwind }
attributes #2 = { nounwind } attributes #2 = { nounwind }
!1 = !{!2, !2, i64 0} !1 = !{!2, !2, i64 0}
!2 = !{!"int", !3, i64 0} !2 = !{!"int", !3, i64 0}
!3 = !{!"omnipotent char", !4, i64 0} !3 = !{!"omnipotent char", !4, i64 0}
!4 = !{!"Simple C/C++ TBAA"} !4 = !{!"Simple C/C++ TBAA"}
!5 = !{i32 110, i32 129, i32 146, i32 163, i32 183} !5 = !{i32 110, i32 129, i32 146, i32 163, i32 183}

test/CodeGen/Hexagon/rdf-phi-up.ll

; RUN: llc -march=hexagon -verify-machineinstrs < %s | FileCheck %s ; RUN: llc -march=hexagon -verify-machineinstrs < %s | FileCheck %s
; Check that this testcase compiles successfully. ; Check that this testcase compiles successfully.
; CHECK-LABEL: fred: ; CHECK-LABEL: fred:
; CHECK: call foo ; CHECK: call foo
target triple = "hexagon" target triple = "hexagon"
%struct.0 = type { i32, i16, i8* } %struct.0 = type { i32, i16, i8* }
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
define i32 @fred(i8* readonly %p0, i32* %p1) local_unnamed_addr #0 { define i32 @fred(i8* readonly %p0, i32* %p1) local_unnamed_addr #0 {
entry: entry:
%v0 = alloca i16, align 2 %v0 = alloca i16, align 2
%v1 = icmp eq i8* %p0, null %v1 = icmp eq i8* %p0, null
br i1 %v1, label %if.then, label %lor.lhs.false br i1 %v1, label %if.then, label %lor.lhs.false
lor.lhs.false: ; preds = %entry lor.lhs.false: ; preds = %entry
%v2 = bitcast i8* %p0 to %struct.0** %v2 = bitcast i8* %p0 to %struct.0**
%v3 = load %struct.0*, %struct.0** %v2, align 4 %v3 = load %struct.0*, %struct.0** %v2, align 4
%v4 = icmp eq %struct.0* %v3, null %v4 = icmp eq %struct.0* %v3, null
br i1 %v4, label %if.then, label %if.else br i1 %v4, label %if.then, label %if.else
if.then: ; preds = %lor.lhs.false, %ent if.then: ; preds = %lor.lhs.false, %ent
%v5 = icmp eq i32* %p1, null %v5 = icmp eq i32* %p1, null
br i1 %v5, label %cleanup, label %if.then3 br i1 %v5, label %cleanup, label %if.then3
if.then3: ; preds = %if.then if.then3: ; preds = %if.then
store i32 0, i32* %p1, align 4 store i32 0, i32* %p1, align 4
br label %cleanup br label %cleanup
if.else: ; preds = %lor.lhs.false if.else: ; preds = %lor.lhs.false
%v6 = bitcast i16* %v0 to i8* %v6 = bitcast i16* %v0 to i8*
call void @llvm.lifetime.start(i64 2, i8* nonnull %v6) #0 call void @llvm.lifetime.start.p0i8(i64 2, i8* nonnull %v6) #0
store i16 0, i16* %v0, align 2 store i16 0, i16* %v0, align 2
%v7 = call i32 @foo(%struct.0* nonnull %v3, i16* nonnull %v0) #0 %v7 = call i32 @foo(%struct.0* nonnull %v3, i16* nonnull %v0) #0
%v8 = icmp eq i32* %p1, null %v8 = icmp eq i32* %p1, null
br i1 %v8, label %if.end7, label %if.then6 br i1 %v8, label %if.end7, label %if.then6
if.then6: ; preds = %if.else if.then6: ; preds = %if.else
%v9 = load i16, i16* %v0, align 2 %v9 = load i16, i16* %v0, align 2
%v10 = zext i16 %v9 to i32 %v10 = zext i16 %v9 to i32
store i32 %v10, i32* %p1, align 4 store i32 %v10, i32* %p1, align 4
br label %if.end7 br label %if.end7
if.end7: ; preds = %if.else, %if.then6 if.end7: ; preds = %if.else, %if.then6
call void @llvm.lifetime.end(i64 2, i8* nonnull %v6) #0 call void @llvm.lifetime.end.p0i8(i64 2, i8* nonnull %v6) #0
br label %cleanup br label %cleanup
cleanup: ; preds = %if.then3, %if.then, cleanup: ; preds = %if.then3, %if.then,
%v11 = phi i32 [ %v7, %if.end7 ], [ -2147024809, %if.then ], [ -2147024809, %if.then3 ] %v11 = phi i32 [ %v7, %if.end7 ], [ -2147024809, %if.then ], [ -2147024809, %if.then3 ]
ret i32 %v11 ret i32 %v11
} }
declare i32 @foo(%struct.0*, i16*) local_unnamed_addr #0 declare i32 @foo(%struct.0*, i16*) local_unnamed_addr #0
attributes #0 = { nounwind } attributes #0 = { nounwind }
attributes #1 = { argmemonly nounwind } attributes #1 = { argmemonly nounwind }

test/CodeGen/Hexagon/runtime-stkchk.ll

; RUN: llc -march=hexagon -mcpu=hexagonv55 -enable-stackovf-sanitizer < %s | FileCheck %s ; RUN: llc -march=hexagon -mcpu=hexagonv55 -enable-stackovf-sanitizer < %s | FileCheck %s
; CHECK-LABEL: foo_1 ; CHECK-LABEL: foo_1
; CHECK: __runtime_stack_check ; CHECK: __runtime_stack_check
define i32 @foo_1(i32 %n) #0 { define i32 @foo_1(i32 %n) #0 {
entry: entry:
%local = alloca [1024 x i32], align 8 %local = alloca [1024 x i32], align 8
%0 = bitcast [1024 x i32]* %local to i8* %0 = bitcast [1024 x i32]* %local to i8*
call void @llvm.lifetime.start(i64 4096, i8* %0) #1 call void @llvm.lifetime.start.p0i8(i64 4096, i8* %0) #1
%arraydecay = getelementptr inbounds [1024 x i32], [1024 x i32]* %local, i32 0, i32 0 %arraydecay = getelementptr inbounds [1024 x i32], [1024 x i32]* %local, i32 0, i32 0
call void @baz_1(i32* %arraydecay) #3 call void @baz_1(i32* %arraydecay) #3
%arrayidx = getelementptr inbounds [1024 x i32], [1024 x i32]* %local, i32 0, i32 %n %arrayidx = getelementptr inbounds [1024 x i32], [1024 x i32]* %local, i32 0, i32 %n
%1 = load i32, i32* %arrayidx, align 4 %1 = load i32, i32* %arrayidx, align 4
call void @llvm.lifetime.end(i64 4096, i8* %0) #1 call void @llvm.lifetime.end.p0i8(i64 4096, i8* %0) #1
ret i32 %1 ret i32 %1
} }
; CHECK-LABEL: foo_2 ; CHECK-LABEL: foo_2
; CHECK: __save_r16_through_r19_stkchk ; CHECK: __save_r16_through_r19_stkchk
define i32 @foo_2(i32 %n, i32* %y) #0 { define i32 @foo_2(i32 %n, i32* %y) #0 {
entry: entry:
%local = alloca [2048 x i32], align 8 %local = alloca [2048 x i32], align 8
%0 = bitcast [2048 x i32]* %local to i8* %0 = bitcast [2048 x i32]* %local to i8*
call void @llvm.lifetime.start(i64 8192, i8* %0) #1 call void @llvm.lifetime.start.p0i8(i64 8192, i8* %0) #1
%arraydecay = getelementptr inbounds [2048 x i32], [2048 x i32]* %local, i32 0, i32 0 %arraydecay = getelementptr inbounds [2048 x i32], [2048 x i32]* %local, i32 0, i32 0
call void @baz_2(i32* %y, i32* %arraydecay) #3 call void @baz_2(i32* %y, i32* %arraydecay) #3
%1 = load i32, i32* %y, align 4 %1 = load i32, i32* %y, align 4
%add = add nsw i32 %n, %1 %add = add nsw i32 %n, %1
%arrayidx = getelementptr inbounds [2048 x i32], [2048 x i32]* %local, i32 0, i32 %add %arrayidx = getelementptr inbounds [2048 x i32], [2048 x i32]* %local, i32 0, i32 %add
%2 = load i32, i32* %arrayidx, align 4 %2 = load i32, i32* %arrayidx, align 4
call void @llvm.lifetime.end(i64 8192, i8* %0) #1 call void @llvm.lifetime.end.p0i8(i64 8192, i8* %0) #1
ret i32 %2 ret i32 %2
} }
declare void @baz_1(i32*) #2 declare void @baz_1(i32*) #2
declare void @baz_2(i32*, i32*) #2 declare void @baz_2(i32*, i32*) #2
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
attributes #0 = { nounwind optsize "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #0 = { nounwind optsize "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { nounwind } attributes #1 = { nounwind }
attributes #2 = { optsize "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #2 = { optsize "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #3 = { optsize } attributes #3 = { optsize }

test/CodeGen/Mips/stackcoloring.ll

; RUN: llc -march=mipsel -relocation-model=pic < %s | FileCheck %s ; RUN: llc -march=mipsel -relocation-model=pic < %s | FileCheck %s
@g1 = external global i32* @g1 = external global i32*
; CHECK-LABEL: foo1: ; CHECK-LABEL: foo1:
; CHECK: lw ${{[0-9]+}}, %got(g1) ; CHECK: lw ${{[0-9]+}}, %got(g1)
; CHECK: # %for.body ; CHECK: # %for.body
; CHECK: # %for.end ; CHECK: # %for.end
define i32 @foo1() { define i32 @foo1() {
entry: entry:
%b = alloca [16 x i32], align 4 %b = alloca [16 x i32], align 4
%0 = bitcast [16 x i32]* %b to i8* %0 = bitcast [16 x i32]* %b to i8*
call void @llvm.lifetime.start(i64 64, i8* %0) call void @llvm.lifetime.start.p0i8(i64 64, i8* %0)
%arraydecay = getelementptr inbounds [16 x i32], [16 x i32]* %b, i32 0, i32 0 %arraydecay = getelementptr inbounds [16 x i32], [16 x i32]* %b, i32 0, i32 0
br label %for.body br label %for.body
for.body: ; preds = %for.body, %entry for.body: ; preds = %for.body, %entry
%i.05 = phi i32 [ 0, %entry ], [ %inc, %for.body ] %i.05 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
%v.04 = phi i32 [ 0, %entry ], [ %add, %for.body ] %v.04 = phi i32 [ 0, %entry ], [ %add, %for.body ]
%1 = load i32*, i32** @g1, align 4 %1 = load i32*, i32** @g1, align 4
%arrayidx = getelementptr inbounds i32, i32* %1, i32 %i.05 %arrayidx = getelementptr inbounds i32, i32* %1, i32 %i.05
%2 = load i32, i32* %arrayidx, align 4 %2 = load i32, i32* %arrayidx, align 4
%call = call i32 @foo2(i32 %2, i32* %arraydecay) %call = call i32 @foo2(i32 %2, i32* %arraydecay)
%add = add nsw i32 %call, %v.04 %add = add nsw i32 %call, %v.04
%inc = add nsw i32 %i.05, 1 %inc = add nsw i32 %i.05, 1
%exitcond = icmp eq i32 %inc, 10000 %exitcond = icmp eq i32 %inc, 10000
br i1 %exitcond, label %for.end, label %for.body br i1 %exitcond, label %for.end, label %for.body
for.end: ; preds = %for.body for.end: ; preds = %for.body
call void @llvm.lifetime.end(i64 64, i8* %0) call void @llvm.lifetime.end.p0i8(i64 64, i8* %0)
ret i32 %add ret i32 %add
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare i32 @foo2(i32, i32*) declare i32 @foo2(i32, i32*)
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)

test/CodeGen/Mips/stchar.ll

Show All 28 Lines
; 16_b-LABEL: test: ; 16_b-LABEL: test:
; 16_h-LABEL: test: ; 16_h-LABEL: test:
; 16_b: sb ${{[0-9]+}}, [[offset1:[0-9]+]](${{[0-9]+}}) ; 16_b: sb ${{[0-9]+}}, [[offset1:[0-9]+]](${{[0-9]+}})
; 16_b: lb ${{[0-9]+}}, [[offset1]](${{[0-9]+}}) ; 16_b: lb ${{[0-9]+}}, [[offset1]](${{[0-9]+}})
; 16_h: sh ${{[0-9]+}}, [[offset2:[0-9]+]](${{[0-9]+}}) ; 16_h: sh ${{[0-9]+}}, [[offset2:[0-9]+]](${{[0-9]+}})
; 16_h: lh ${{[0-9]+}}, [[offset2]](${{[0-9]+}}) ; 16_h: lh ${{[0-9]+}}, [[offset2]](${{[0-9]+}})
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) nounwind declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) nounwind declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) nounwind

test/CodeGen/NVPTX/bug22322.ll

Show All 11 Lines_ZL11compute_vecRK6float3jb.exit:
%ret_vec.sroa.8.i = alloca float, align 4 %ret_vec.sroa.8.i = alloca float, align 4
%0 = tail call i32 @llvm.nvvm.read.ptx.sreg.ctaid.x() %0 = tail call i32 @llvm.nvvm.read.ptx.sreg.ctaid.x()
%1 = tail call i32 @llvm.nvvm.read.ptx.sreg.ntid.x() %1 = tail call i32 @llvm.nvvm.read.ptx.sreg.ntid.x()
%2 = mul nsw i32 %1, %0 %2 = mul nsw i32 %1, %0
%3 = tail call i32 @llvm.nvvm.read.ptx.sreg.tid.x() %3 = tail call i32 @llvm.nvvm.read.ptx.sreg.tid.x()
%4 = add nsw i32 %2, %3 %4 = add nsw i32 %2, %3
%5 = zext i32 %4 to i64 %5 = zext i32 %4 to i64
%6 = bitcast float* %ret_vec.sroa.8.i to i8* %6 = bitcast float* %ret_vec.sroa.8.i to i8*
call void @llvm.lifetime.start(i64 4, i8* %6) call void @llvm.lifetime.start.p0i8(i64 4, i8* %6)
%7 = and i32 %4, 15 %7 = and i32 %4, 15
%8 = icmp eq i32 %7, 0 %8 = icmp eq i32 %7, 0
%9 = select i1 %8, float 0.000000e+00, float -1.000000e+00 %9 = select i1 %8, float 0.000000e+00, float -1.000000e+00
store float %9, float* %ret_vec.sroa.8.i, align 4 store float %9, float* %ret_vec.sroa.8.i, align 4
; CHECK: max.f32 %f{{[0-9]+}}, %f{{[0-9]+}}, 0f00000000 ; CHECK: max.f32 %f{{[0-9]+}}, %f{{[0-9]+}}, 0f00000000
%10 = fcmp olt float %9, 0.000000e+00 %10 = fcmp olt float %9, 0.000000e+00
%ret_vec.sroa.8.i.val = load float, float* %ret_vec.sroa.8.i, align 4 %ret_vec.sroa.8.i.val = load float, float* %ret_vec.sroa.8.i, align 4
%11 = select i1 %10, float 0.000000e+00, float %ret_vec.sroa.8.i.val %11 = select i1 %10, float 0.000000e+00, float %ret_vec.sroa.8.i.val
call void @llvm.lifetime.end(i64 4, i8* %6) call void @llvm.lifetime.end.p0i8(i64 4, i8* %6)
%12 = getelementptr inbounds %class.float3, %class.float3* %dst, i64 %5, i32 0 %12 = getelementptr inbounds %class.float3, %class.float3* %dst, i64 %5, i32 0
store float 0.000000e+00, float* %12, align 4 store float 0.000000e+00, float* %12, align 4
%13 = getelementptr inbounds %class.float3, %class.float3* %dst, i64 %5, i32 1 %13 = getelementptr inbounds %class.float3, %class.float3* %dst, i64 %5, i32 1
store float %11, float* %13, align 4 store float %11, float* %13, align 4
%14 = getelementptr inbounds %class.float3, %class.float3* %dst, i64 %5, i32 2 %14 = getelementptr inbounds %class.float3, %class.float3* %dst, i64 %5, i32 2
store float 0.000000e+00, float* %14, align 4 store float 0.000000e+00, float* %14, align 4
ret void ret void
} }
; Function Attrs: nounwind readnone ; Function Attrs: nounwind readnone
declare i32 @llvm.nvvm.read.ptx.sreg.ctaid.x() #1 declare i32 @llvm.nvvm.read.ptx.sreg.ctaid.x() #1
; Function Attrs: nounwind readnone ; Function Attrs: nounwind readnone
declare i32 @llvm.nvvm.read.ptx.sreg.ntid.x() #1 declare i32 @llvm.nvvm.read.ptx.sreg.ntid.x() #1
; Function Attrs: nounwind readnone ; Function Attrs: nounwind readnone
declare i32 @llvm.nvvm.read.ptx.sreg.tid.x() #1 declare i32 @llvm.nvvm.read.ptx.sreg.tid.x() #1
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) #2 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #2
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) #2 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #2
attributes #0 = { nounwind "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="true" "no-nans-fp-math"="true" "stack-protector-buffer-size"="8" "unsafe-fp-math"="true" "use-soft-float"="false" } attributes #0 = { nounwind "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="true" "no-nans-fp-math"="true" "stack-protector-buffer-size"="8" "unsafe-fp-math"="true" "use-soft-float"="false" }
attributes #1 = { nounwind readnone } attributes #1 = { nounwind readnone }
attributes #2 = { nounwind } attributes #2 = { nounwind }
!nvvm.annotations = !{!0} !nvvm.annotations = !{!0}
!llvm.ident = !{!1} !llvm.ident = !{!1}
!0 = !{void (%class.float3*)* @some_kernel, !"kernel", i32 1} !0 = !{void (%class.float3*)* @some_kernel, !"kernel", i32 1}
!1 = !{!"clang version 3.5.1 (tags/RELEASE_351/final)"} !1 = !{!"clang version 3.5.1 (tags/RELEASE_351/final)"}

test/CodeGen/PowerPC/BreakableToken-reduced.ll

Show First 20 Lines • Show All 259 Lines • ▼ Show 20 Lines_ZNK4llvm9StringRef10startswithES0_.exit: ; preds = %entry._ZNK4llvm9StringRef10startswithES0_.exit_crit_edge, %if.end.i.i
%.fca.1.insert12 = insertvalue [2 x i64] %.fca.0.insert11, i64 %agg.tmp6.sroa.2.0.copyload, 1 %.fca.1.insert12 = insertvalue [2 x i64] %.fca.0.insert11, i64 %agg.tmp6.sroa.2.0.copyload, 1
%.fca.0.insert = insertvalue [2 x i64] undef, i64 %agg.tmp7.sroa.0.0.copyload, 0 %.fca.0.insert = insertvalue [2 x i64] undef, i64 %agg.tmp7.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue [2 x i64] %.fca.0.insert, i64 %1, 1 %.fca.1.insert = insertvalue [2 x i64] %.fca.0.insert, i64 %1, 1
tail call void @_ZN5clang6format17WhitespaceManager24replaceWhitespaceInTokenERKNS0_11FormatTokenEjjN4llvm9StringRefES6_bjji(%"class.clang::format::WhitespaceManager"* nonnull %Whitespaces, %"struct.clang::format::FormatToken"* dereferenceable(272) %ref, i32 zeroext %conv5, i32 zeroext %Split.sroa.2.8.extract.trunc, [2 x i64] %.fca.1.insert12, [2 x i64] %.fca.1.insert, i1 zeroext %tobool, i32 zeroext 1, i32 zeroext %6, i32 signext %dec.) #9 tail call void @_ZN5clang6format17WhitespaceManager24replaceWhitespaceInTokenERKNS0_11FormatTokenEjjN4llvm9StringRefES6_bjji(%"class.clang::format::WhitespaceManager"* nonnull %Whitespaces, %"struct.clang::format::FormatToken"* dereferenceable(272) %ref, i32 zeroext %conv5, i32 zeroext %Split.sroa.2.8.extract.trunc, [2 x i64] %.fca.1.insert12, [2 x i64] %.fca.1.insert, i1 zeroext %tobool, i32 zeroext 1, i32 zeroext %6, i32 signext %dec.) #9
ret void ret void
} }
; Function Attrs: nounwind argmemonly ; Function Attrs: nounwind argmemonly
declare void @llvm.lifetime.start(i64, i8* nocapture) #2 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #2
declare void @_ZN5clang6format17WhitespaceManager24replaceWhitespaceInTokenERKNS0_11FormatTokenEjjN4llvm9StringRefES6_bjji(%"class.clang::format::WhitespaceManager"*, %"struct.clang::format::FormatToken"* dereferenceable(272), i32 zeroext, i32 zeroext, [2 x i64], [2 x i64], i1 zeroext, i32 zeroext, i32 zeroext, i32 signext) #3 declare void @_ZN5clang6format17WhitespaceManager24replaceWhitespaceInTokenERKNS0_11FormatTokenEjjN4llvm9StringRefES6_bjji(%"class.clang::format::WhitespaceManager"*, %"struct.clang::format::FormatToken"* dereferenceable(272), i32 zeroext, i32 zeroext, [2 x i64], [2 x i64], i1 zeroext, i32 zeroext, i32 zeroext, i32 signext) #3
; Function Attrs: nounwind argmemonly ; Function Attrs: nounwind argmemonly
declare void @llvm.lifetime.end(i64, i8* nocapture) #2 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #2
attributes #9 = { nounwind } attributes #9 = { nounwind }
!llvm.module.flags = !{!0} !llvm.module.flags = !{!0}
!llvm.ident = !{!1} !llvm.ident = !{!1}
!0 = !{i32 1, !"PIC Level", i32 2} !0 = !{i32 1, !"PIC Level", i32 2}
!1 = !{!"clang version 3.8.0 (trunk 248714) (llvm/trunk 248719)"} !1 = !{!"clang version 3.8.0 (trunk 248714) (llvm/trunk 248719)"}
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

test/CodeGen/PowerPC/addi-licm.ll

; RUN: llc -verify-machineinstrs -mcpu=pwr7 -disable-ppc-preinc-prep < %s | FileCheck %s ; RUN: llc -verify-machineinstrs -mcpu=pwr7 -disable-ppc-preinc-prep < %s | FileCheck %s
; RUN: llc -verify-machineinstrs -mcpu=pwr7 < %s | FileCheck %s -check-prefix=PIP ; RUN: llc -verify-machineinstrs -mcpu=pwr7 < %s | FileCheck %s -check-prefix=PIP
target datalayout = "E-m:e-i64:64-n32:64" target datalayout = "E-m:e-i64:64-n32:64"
target triple = "powerpc64-unknown-linux-gnu" target triple = "powerpc64-unknown-linux-gnu"
; Function Attrs: nounwind ; Function Attrs: nounwind
define double @foo() #1 { define double @foo() #1 {
entry: entry:
%x = alloca [2048 x float], align 4 %x = alloca [2048 x float], align 4
%y = alloca [2048 x float], align 4 %y = alloca [2048 x float], align 4
%0 = bitcast [2048 x float]* %x to i8* %0 = bitcast [2048 x float]* %x to i8*
call void @llvm.lifetime.start(i64 8192, i8* %0) #2 call void @llvm.lifetime.start.p0i8(i64 8192, i8* %0) #2
%1 = bitcast [2048 x float]* %y to i8* %1 = bitcast [2048 x float]* %y to i8*
call void @llvm.lifetime.start(i64 8192, i8* %1) #2 call void @llvm.lifetime.start.p0i8(i64 8192, i8* %1) #2
br label %for.body.i br label %for.body.i
; CHECK-LABEL: @foo ; CHECK-LABEL: @foo
; CHECK: addi [[REG1:[0-9]+]], 1, ; CHECK: addi [[REG1:[0-9]+]], 1,
; CHECK: addi [[REG2:[0-9]+]], 1, ; CHECK: addi [[REG2:[0-9]+]], 1,
; CHECK: %for.body.i ; CHECK: %for.body.i
; CHECK-DAG: lfsx {{[0-9]+}}, [[REG1]], ; CHECK-DAG: lfsx {{[0-9]+}}, [[REG1]],
; CHECK-DAG: lfsx {{[0-9]+}}, [[REG2]], ; CHECK-DAG: lfsx {{[0-9]+}}, [[REG2]],
Show All 22 Linesfor.body.i: ; preds = %for.body.i.preheader, %for.body.i
%exitcond.i = icmp eq i64 %i.08.i, 2047 %exitcond.i = icmp eq i64 %i.08.i, 2047
br i1 %exitcond.i, label %loop.exit, label %for.body.i br i1 %exitcond.i, label %loop.exit, label %for.body.i
loop.exit: ; preds = %for.body.i loop.exit: ; preds = %for.body.i
ret double %accumulator.09.i ret double %accumulator.09.i
} }
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) #2 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #2
declare void @bar(float*, float*) declare void @bar(float*, float*)
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) #2 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #2
attributes #0 = { nounwind readonly } attributes #0 = { nounwind readonly }
attributes #1 = { nounwind } attributes #1 = { nounwind }
attributes #2 = { nounwind } attributes #2 = { nounwind }

test/CodeGen/PowerPC/ctrloop-intrin.ll

Show All 11 Lines
@.str.6.93 = external hidden unnamed_addr constant [10 x i8], align 1 @.str.6.93 = external hidden unnamed_addr constant [10 x i8], align 1
@.str.7.94 = external hidden unnamed_addr constant [9 x i8], align 1 @.str.7.94 = external hidden unnamed_addr constant [9 x i8], align 1
@.str.8.95 = external hidden unnamed_addr constant [2 x i8], align 1 @.str.8.95 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.9.96 = external hidden unnamed_addr constant [2 x i8], align 1 @.str.9.96 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.10.97 = external hidden unnamed_addr constant [3 x i8], align 1 @.str.10.97 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.11.98 = external hidden unnamed_addr constant [3 x i8], align 1 @.str.11.98 = external hidden unnamed_addr constant [3 x i8], align 1
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) #0 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #0
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) #0 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #0
; Function Attrs: nounwind ; Function Attrs: nounwind
declare i8* @halide_string_to_string(i8*, i8*, i8*) #1 declare i8* @halide_string_to_string(i8*, i8*, i8*) #1
; Function Attrs: nounwind ; Function Attrs: nounwind
declare i8* @halide_int64_to_string(i8*, i8*, i64, i32) #1 declare i8* @halide_int64_to_string(i8*, i8*, i64, i32) #1
; Function Attrs: nounwind ; Function Attrs: nounwind
define weak i8* @halide_double_to_string(i8* %dst, i8* %end, double %arg, i32 %scientific) #1 { define weak i8* @halide_double_to_string(i8* %dst, i8* %end, double %arg, i32 %scientific) #1 {
entry: entry:
%arg.addr = alloca double, align 8 %arg.addr = alloca double, align 8
%bits = alloca i64, align 8 %bits = alloca i64, align 8
%buf = alloca [512 x i8], align 1 %buf = alloca [512 x i8], align 1
store double %arg, double* %arg.addr, align 8, !tbaa !4 store double %arg, double* %arg.addr, align 8, !tbaa !4
%0 = bitcast i64* %bits to i8* %0 = bitcast i64* %bits to i8*
call void @llvm.lifetime.start(i64 8, i8* %0) #0 call void @llvm.lifetime.start.p0i8(i64 8, i8* %0) #0
store i64 0, i64* %bits, align 8, !tbaa !8 store i64 0, i64* %bits, align 8, !tbaa !8
%1 = bitcast double* %arg.addr to i8* %1 = bitcast double* %arg.addr to i8*
%call = call i8* @memcpy(i8* %0, i8* %1, i64 8) #2 %call = call i8* @memcpy(i8* %0, i8* %1, i64 8) #2
%2 = load i64, i64* %bits, align 8, !tbaa !8 %2 = load i64, i64* %bits, align 8, !tbaa !8
%and = and i64 %2, 4503599627370495 %and = and i64 %2, 4503599627370495
%shr = lshr i64 %2, 52 %shr = lshr i64 %2, 52
%shr.tr = trunc i64 %shr to i32 %shr.tr = trunc i64 %shr to i32
%conv = and i32 %shr.tr, 2047 %conv = and i32 %shr.tr, 2047
▲ Show 20 Lines • Show All 192 Lines • ▼ Show 20 Linesif.end.84: ; preds = %if.else.76, %if.then.72
%.fractional_part.0 = select i1 %cmp101, i64 0, i64 %fractional_part.0 %.fractional_part.0 = select i1 %cmp101, i64 0, i64 %fractional_part.0
br label %if.end.105 br label %if.end.105
if.end.105: ; preds = %if.end.84, %if.end.66 if.end.105: ; preds = %if.end.84, %if.end.66
%integer_part.2 = phi i64 [ %inc103.integer_part.0, %if.end.84 ], [ %add68, %if.end.66 ] %integer_part.2 = phi i64 [ %inc103.integer_part.0, %if.end.84 ], [ %add68, %if.end.66 ]
%integer_exponent.0 = phi i32 [ 0, %if.end.84 ], [ %sub70, %if.end.66 ] %integer_exponent.0 = phi i32 [ 0, %if.end.84 ], [ %sub70, %if.end.66 ]
%fractional_part.2 = phi i64 [ %.fractional_part.0, %if.end.84 ], [ 0, %if.end.66 ] %fractional_part.2 = phi i64 [ %.fractional_part.0, %if.end.84 ], [ 0, %if.end.66 ]
%7 = bitcast [512 x i8]* %buf to i8* %7 = bitcast [512 x i8]* %buf to i8*
call void @llvm.lifetime.start(i64 512, i8* %7) #0 call void @llvm.lifetime.start.p0i8(i64 512, i8* %7) #0
%add.ptr = getelementptr inbounds [512 x i8], [512 x i8]* %buf, i64 0, i64 512 %add.ptr = getelementptr inbounds [512 x i8], [512 x i8]* %buf, i64 0, i64 512
%add.ptr106 = getelementptr inbounds [512 x i8], [512 x i8]* %buf, i64 0, i64 480 %add.ptr106 = getelementptr inbounds [512 x i8], [512 x i8]* %buf, i64 0, i64 480
%call109 = call i8* @halide_int64_to_string(i8* %add.ptr106, i8* %add.ptr, i64 %integer_part.2, i32 1) #3 %call109 = call i8* @halide_int64_to_string(i8* %add.ptr106, i8* %add.ptr, i64 %integer_part.2, i32 1) #3
%cmp110.252 = icmp sgt i32 %integer_exponent.0, 0 %cmp110.252 = icmp sgt i32 %integer_exponent.0, 0
br i1 %cmp110.252, label %for.cond.112.preheader, label %for.cond.cleanup br i1 %cmp110.252, label %for.cond.112.preheader, label %for.cond.cleanup
for.cond.112.preheader: ; preds = %if.end.138, %if.end.105 for.cond.112.preheader: ; preds = %if.end.138, %if.end.105
%i.0255 = phi i32 [ %inc140, %if.end.138 ], [ 0, %if.end.105 ] %i.0255 = phi i32 [ %inc140, %if.end.138 ], [ 0, %if.end.105 ]
Show All 10 Linesfor.body.116.preheader: ; preds = %for.cond.112.preheader
br label %for.body.116 br label %for.body.116
for.cond.cleanup: ; preds = %if.end.138, %if.end.105 for.cond.cleanup: ; preds = %if.end.138, %if.end.105
%int_part_ptr.0.lcssa = phi i8* [ %add.ptr106, %if.end.105 ], [ %int_part_ptr.1, %if.end.138 ] %int_part_ptr.0.lcssa = phi i8* [ %add.ptr106, %if.end.105 ], [ %int_part_ptr.1, %if.end.138 ]
%9 = bitcast [512 x i8]* %buf to i8* %9 = bitcast [512 x i8]* %buf to i8*
%call142 = call i8* @halide_string_to_string(i8* %dst.addr.0, i8* %end, i8* %int_part_ptr.0.lcssa) #3 %call142 = call i8* @halide_string_to_string(i8* %dst.addr.0, i8* %end, i8* %int_part_ptr.0.lcssa) #3
%call143 = call i8* @halide_string_to_string(i8* %call142, i8* %end, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9.96, i64 0, i64 0)) #3 %call143 = call i8* @halide_string_to_string(i8* %call142, i8* %end, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9.96, i64 0, i64 0)) #3
%call144 = call i8* @halide_int64_to_string(i8* %call143, i8* %end, i64 %fractional_part.2, i32 6) #3 %call144 = call i8* @halide_int64_to_string(i8* %call143, i8* %end, i64 %fractional_part.2, i32 6) #3
call void @llvm.lifetime.end(i64 512, i8* %9) #0 call void @llvm.lifetime.end.p0i8(i64 512, i8* %9) #0
br label %cleanup.148 br label %cleanup.148
for.cond.cleanup.115: ; preds = %for.body.116 for.cond.cleanup.115: ; preds = %for.body.116
br i1 %cmp125, label %if.then.136, label %if.end.138 br i1 %cmp125, label %if.then.136, label %if.end.138
for.body.116: ; preds = %for.body.116, %for.body.116.preheader for.body.116: ; preds = %for.body.116, %for.body.116.preheader
%call109.pn = phi i8* [ %p.0251, %for.body.116 ], [ %call109, %for.body.116.preheader ] %call109.pn = phi i8* [ %p.0251, %for.body.116 ], [ %call109, %for.body.116.preheader ]
%carry.0250 = phi i32 [ %carry.1, %for.body.116 ], [ 0, %for.body.116.preheader ] %carry.0250 = phi i32 [ %carry.1, %for.body.116 ], [ 0, %for.body.116.preheader ]
Show All 26 Linesif.end.138: ; preds = %if.then.136, %for.cond.cleanup.115, %for.cond.112.preheader
%int_part_ptr.1 = phi i8* [ %incdec.ptr137, %if.then.136 ], [ %call109, %for.cond.112.preheader ], [ %int_part_ptr.0253, %for.cond.cleanup.115 ] %int_part_ptr.1 = phi i8* [ %incdec.ptr137, %if.then.136 ], [ %call109, %for.cond.112.preheader ], [ %int_part_ptr.0253, %for.cond.cleanup.115 ]
%inc140 = add nuw nsw i32 %i.0255, 1 %inc140 = add nuw nsw i32 %i.0255, 1
%exitcond = icmp eq i32 %inc140, %integer_exponent.0 %exitcond = icmp eq i32 %inc140, %integer_exponent.0
br i1 %exitcond, label %for.cond.cleanup, label %for.cond.112.preheader br i1 %exitcond, label %for.cond.cleanup, label %for.cond.112.preheader
cleanup.148: ; preds = %for.cond.cleanup, %if.then.64, %if.end.59, %if.else.30, %if.then.28, %if.else.24, %if.then.22, %if.else.13, %if.then.11, %if.else, %if.then.6 cleanup.148: ; preds = %for.cond.cleanup, %if.then.64, %if.end.59, %if.else.30, %if.then.28, %if.else.24, %if.then.22, %if.else.13, %if.then.11, %if.else, %if.then.6
%retval.1 = phi i8* [ %call7, %if.then.6 ], [ %call8, %if.else ], [ %call12, %if.then.11 ], [ %call14, %if.else.13 ], [ %call23, %if.then.22 ], [ %call25, %if.else.24 ], [ %call29, %if.then.28 ], [ %call31, %if.else.30 ], [ %call65, %if.then.64 ], [ %call61, %if.end.59 ], [ %call144, %for.cond.cleanup ] %retval.1 = phi i8* [ %call7, %if.then.6 ], [ %call8, %if.else ], [ %call12, %if.then.11 ], [ %call14, %if.else.13 ], [ %call23, %if.then.22 ], [ %call25, %if.else.24 ], [ %call29, %if.then.28 ], [ %call31, %if.else.30 ], [ %call65, %if.then.64 ], [ %call61, %if.end.59 ], [ %call144, %for.cond.cleanup ]
%13 = bitcast i64* %bits to i8* %13 = bitcast i64* %bits to i8*
call void @llvm.lifetime.end(i64 8, i8* %13) #0 call void @llvm.lifetime.end.p0i8(i64 8, i8* %13) #0
ret i8* %retval.1 ret i8* %retval.1
} }
; Function Attrs: nounwind ; Function Attrs: nounwind
declare i8* @memcpy(i8*, i8* nocapture readonly, i64) #1 declare i8* @memcpy(i8*, i8* nocapture readonly, i64) #1
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.ppc.mtctr.i64(i64) #0 declare void @llvm.ppc.mtctr.i64(i64) #0
Show All 23 Lines

test/CodeGen/PowerPC/lsa.ll

; RUN: llc -verify-machineinstrs < %s -mtriple=powerpc64-unknown-linux-gnu -mcpu=ppc64 | FileCheck %s ; RUN: llc -verify-machineinstrs < %s -mtriple=powerpc64-unknown-linux-gnu -mcpu=ppc64 | 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-f128:128:128-v128:128:128-n32:64" 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-f128:128:128-v128:128:128-n32:64"
target triple = "powerpc64-unknown-linux-gnu" target triple = "powerpc64-unknown-linux-gnu"
define signext i32 @foo() #0 { define signext i32 @foo() #0 {
entry: entry:
%v = alloca [8200 x i32], align 4 %v = alloca [8200 x i32], align 4
%w = alloca [8200 x i32], align 4 %w = alloca [8200 x i32], align 4
%q = alloca [8200 x i32], align 4 %q = alloca [8200 x i32], align 4
%0 = bitcast [8200 x i32]* %v to i8* %0 = bitcast [8200 x i32]* %v to i8*
call void @llvm.lifetime.start(i64 32800, i8* %0) #0 call void @llvm.lifetime.start.p0i8(i64 32800, i8* %0) #0
%1 = bitcast [8200 x i32]* %w to i8* %1 = bitcast [8200 x i32]* %w to i8*
call void @llvm.lifetime.start(i64 32800, i8* %1) #0 call void @llvm.lifetime.start.p0i8(i64 32800, i8* %1) #0
%2 = bitcast [8200 x i32]* %q to i8* %2 = bitcast [8200 x i32]* %q to i8*
call void @llvm.lifetime.start(i64 32800, i8* %2) #0 call void @llvm.lifetime.start.p0i8(i64 32800, i8* %2) #0
%arraydecay = getelementptr inbounds [8200 x i32], [8200 x i32]* %q, i64 0, i64 0 %arraydecay = getelementptr inbounds [8200 x i32], [8200 x i32]* %q, i64 0, i64 0
%arraydecay1 = getelementptr inbounds [8200 x i32], [8200 x i32]* %v, i64 0, i64 0 %arraydecay1 = getelementptr inbounds [8200 x i32], [8200 x i32]* %v, i64 0, i64 0
%arraydecay2 = getelementptr inbounds [8200 x i32], [8200 x i32]* %w, i64 0, i64 0 %arraydecay2 = getelementptr inbounds [8200 x i32], [8200 x i32]* %w, i64 0, i64 0
call void @bar(i32* %arraydecay, i32* %arraydecay1, i32* %arraydecay2) #0 call void @bar(i32* %arraydecay, i32* %arraydecay1, i32* %arraydecay2) #0
%3 = load i32, i32* %arraydecay2, align 4 %3 = load i32, i32* %arraydecay2, align 4
%arrayidx3 = getelementptr inbounds [8200 x i32], [8200 x i32]* %w, i64 0, i64 1 %arrayidx3 = getelementptr inbounds [8200 x i32], [8200 x i32]* %w, i64 0, i64 1
%4 = load i32, i32* %arrayidx3, align 4 %4 = load i32, i32* %arrayidx3, align 4
; CHECK: @foo ; CHECK: @foo
; CHECK-NOT: lwzx ; CHECK-NOT: lwzx
; CHECK: lwz {{[0-9]+}}, 4([[REG:[0-9]+]]) ; CHECK: lwz {{[0-9]+}}, 4([[REG:[0-9]+]])
; CHECK: lwz {{[0-9]+}}, 0([[REG]]) ; CHECK: lwz {{[0-9]+}}, 0([[REG]])
; CHECK: blr ; CHECK: blr
%add = add nsw i32 %4, %3 %add = add nsw i32 %4, %3
call void @llvm.lifetime.end(i64 32800, i8* %2) #0 call void @llvm.lifetime.end.p0i8(i64 32800, i8* %2) #0
call void @llvm.lifetime.end(i64 32800, i8* %1) #0 call void @llvm.lifetime.end.p0i8(i64 32800, i8* %1) #0
call void @llvm.lifetime.end(i64 32800, i8* %0) #0 call void @llvm.lifetime.end.p0i8(i64 32800, i8* %0) #0
ret i32 %add ret i32 %add
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) #0 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #0
declare void @bar(i32*, i32*, i32*) declare void @bar(i32*, i32*, i32*)
declare void @llvm.lifetime.end(i64, i8* nocapture) #0 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #0
attributes #0 = { nounwind } attributes #0 = { nounwind }

test/CodeGen/PowerPC/pr30451.ll

; RUN: llc < %s -mcpu=pwr8 -mtriple=powerpc64le-unknown-unknown | FileCheck %s ; RUN: llc < %s -mcpu=pwr8 -mtriple=powerpc64le-unknown-unknown | FileCheck %s
define i8 @atomic_min_i8() { define i8 @atomic_min_i8() {
top: top:
%0 = alloca i8, align 2 %0 = alloca i8, align 2
%1 = bitcast i8* %0 to i8* %1 = bitcast i8* %0 to i8*
call void @llvm.lifetime.start(i64 2, i8* %1) call void @llvm.lifetime.start.p0i8(i64 2, i8* %1)
store i8 -1, i8* %0, align 2 store i8 -1, i8* %0, align 2
%2 = atomicrmw min i8* %0, i8 0 acq_rel %2 = atomicrmw min i8* %0, i8 0 acq_rel
%3 = load atomic i8, i8* %0 acquire, align 8 %3 = load atomic i8, i8* %0 acquire, align 8
call void @llvm.lifetime.end(i64 2, i8* %1) call void @llvm.lifetime.end.p0i8(i64 2, i8* %1)
ret i8 %3 ret i8 %3
; CHECK-LABEL: atomic_min_i8 ; CHECK-LABEL: atomic_min_i8
; CHECK: lbarx [[DST:[0-9]+]], ; CHECK: lbarx [[DST:[0-9]+]],
; CHECK-NEXT: extsb [[EXT:[0-9]+]], [[DST]] ; CHECK-NEXT: extsb [[EXT:[0-9]+]], [[DST]]
; CHECK-NEXT: cmpw {{[0-9]+}}, [[EXT]] ; CHECK-NEXT: cmpw {{[0-9]+}}, [[EXT]]
; CHECK-NEXT: bge 0 ; CHECK-NEXT: bge 0
} }
define i16 @atomic_min_i16() { define i16 @atomic_min_i16() {
top: top:
%0 = alloca i16, align 2 %0 = alloca i16, align 2
%1 = bitcast i16* %0 to i8* %1 = bitcast i16* %0 to i8*
call void @llvm.lifetime.start(i64 2, i8* %1) call void @llvm.lifetime.start.p0i8(i64 2, i8* %1)
store i16 -1, i16* %0, align 2 store i16 -1, i16* %0, align 2
%2 = atomicrmw min i16* %0, i16 0 acq_rel %2 = atomicrmw min i16* %0, i16 0 acq_rel
%3 = load atomic i16, i16* %0 acquire, align 8 %3 = load atomic i16, i16* %0 acquire, align 8
call void @llvm.lifetime.end(i64 2, i8* %1) call void @llvm.lifetime.end.p0i8(i64 2, i8* %1)
ret i16 %3 ret i16 %3
; CHECK-LABEL: atomic_min_i16 ; CHECK-LABEL: atomic_min_i16
; CHECK: lharx [[DST:[0-9]+]], ; CHECK: lharx [[DST:[0-9]+]],
; CHECK-NEXT: extsh [[EXT:[0-9]+]], [[DST]] ; CHECK-NEXT: extsh [[EXT:[0-9]+]], [[DST]]
; CHECK-NEXT: cmpw {{[0-9]+}}, [[EXT]] ; CHECK-NEXT: cmpw {{[0-9]+}}, [[EXT]]
; CHECK-NEXT: bge 0 ; CHECK-NEXT: bge 0
} }
define i8 @atomic_max_i8() { define i8 @atomic_max_i8() {
top: top:
%0 = alloca i8, align 2 %0 = alloca i8, align 2
%1 = bitcast i8* %0 to i8* %1 = bitcast i8* %0 to i8*
call void @llvm.lifetime.start(i64 2, i8* %1) call void @llvm.lifetime.start.p0i8(i64 2, i8* %1)
store i8 -1, i8* %0, align 2 store i8 -1, i8* %0, align 2
%2 = atomicrmw max i8* %0, i8 0 acq_rel %2 = atomicrmw max i8* %0, i8 0 acq_rel
%3 = load atomic i8, i8* %0 acquire, align 8 %3 = load atomic i8, i8* %0 acquire, align 8
call void @llvm.lifetime.end(i64 2, i8* %1) call void @llvm.lifetime.end.p0i8(i64 2, i8* %1)
ret i8 %3 ret i8 %3
; CHECK-LABEL: atomic_max_i8 ; CHECK-LABEL: atomic_max_i8
; CHECK: lbarx [[DST:[0-9]+]], ; CHECK: lbarx [[DST:[0-9]+]],
; CHECK-NEXT: extsb [[EXT:[0-9]+]], [[DST]] ; CHECK-NEXT: extsb [[EXT:[0-9]+]], [[DST]]
; CHECK-NEXT: cmpw {{[0-9]+}}, [[EXT]] ; CHECK-NEXT: cmpw {{[0-9]+}}, [[EXT]]
; CHECK-NEXT: ble 0 ; CHECK-NEXT: ble 0
} }
define i16 @atomic_max_i16() { define i16 @atomic_max_i16() {
top: top:
%0 = alloca i16, align 2 %0 = alloca i16, align 2
%1 = bitcast i16* %0 to i8* %1 = bitcast i16* %0 to i8*
call void @llvm.lifetime.start(i64 2, i8* %1) call void @llvm.lifetime.start.p0i8(i64 2, i8* %1)
store i16 -1, i16* %0, align 2 store i16 -1, i16* %0, align 2
%2 = atomicrmw max i16* %0, i16 0 acq_rel %2 = atomicrmw max i16* %0, i16 0 acq_rel
%3 = load atomic i16, i16* %0 acquire, align 8 %3 = load atomic i16, i16* %0 acquire, align 8
call void @llvm.lifetime.end(i64 2, i8* %1) call void @llvm.lifetime.end.p0i8(i64 2, i8* %1)
ret i16 %3 ret i16 %3
; CHECK-LABEL: atomic_max_i16 ; CHECK-LABEL: atomic_max_i16
; CHECK: lharx [[DST:[0-9]+]], ; CHECK: lharx [[DST:[0-9]+]],
; CHECK-NEXT: extsh [[EXT:[0-9]+]], [[DST]] ; CHECK-NEXT: extsh [[EXT:[0-9]+]], [[DST]]
; CHECK-NEXT: cmpw {{[0-9]+}}, [[EXT]] ; CHECK-NEXT: cmpw {{[0-9]+}}, [[EXT]]
; CHECK-NEXT: ble 0 ; CHECK-NEXT: ble 0
} }
declare void @llvm.lifetime.start(i64, i8*) declare void @llvm.lifetime.start.p0i8(i64, i8*)
declare void @llvm.lifetime.end(i64, i8*) declare void @llvm.lifetime.end.p0i8(i64, i8*)

test/CodeGen/PowerPC/swaps-le-4.ll

; RUN: llc -verify-machineinstrs -mcpu=pwr8 -mtriple=powerpc64le-unknown-linux-gnu -O3 < %s | FileCheck %s ; RUN: llc -verify-machineinstrs -mcpu=pwr8 -mtriple=powerpc64le-unknown-linux-gnu -O3 < %s | FileCheck %s
; This test verifies that VSX swap optimization works when an implicit ; This test verifies that VSX swap optimization works when an implicit
; subregister is present (in this case, in the XXPERMDI associated with ; subregister is present (in this case, in the XXPERMDI associated with
; the store). ; the store).
define void @bar() { define void @bar() {
entry: entry:
%x = alloca <2 x i64>, align 16 %x = alloca <2 x i64>, align 16
%0 = bitcast <2 x i64>* %x to i8* %0 = bitcast <2 x i64>* %x to i8*
call void @llvm.lifetime.start(i64 16, i8* %0) call void @llvm.lifetime.start.p0i8(i64 16, i8* %0)
%arrayidx = getelementptr inbounds <2 x i64>, <2 x i64>* %x, i64 0, i64 0 %arrayidx = getelementptr inbounds <2 x i64>, <2 x i64>* %x, i64 0, i64 0
store <2 x i64> <i64 0, i64 1>, <2 x i64>* %x, align 16 store <2 x i64> <i64 0, i64 1>, <2 x i64>* %x, align 16
call void @foo(i64* %arrayidx) call void @foo(i64* %arrayidx)
call void @llvm.lifetime.end(i64 16, i8* %0) call void @llvm.lifetime.end.p0i8(i64 16, i8* %0)
ret void ret void
} }
; CHECK-LABEL: @bar ; CHECK-LABEL: @bar
; CHECK: lxvd2x ; CHECK: lxvd2x
; CHECK: stxvd2x ; CHECK: stxvd2x
; CHECK-NOT: xxswapd ; CHECK-NOT: xxswapd
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @foo(i64*) declare void @foo(i64*)
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)

test/CodeGen/PowerPC/tail-dup-branch-to-fallthrough.ll

; RUN: llc -O2 %s -o - | FileCheck %s ; RUN: llc -O2 %s -o - | FileCheck %s
target datalayout = "E-m:e-i64:64-n32:64" target datalayout = "E-m:e-i64:64-n32:64"
target triple = "powerpc64-unknown-linux-gnu" target triple = "powerpc64-unknown-linux-gnu"
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) #0 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #0
declare void @f1() declare void @f1()
declare void @f2() declare void @f2()
declare void @f3() declare void @f3()
declare void @f4() declare void @f4()
; Function Attrs: nounwind ; Function Attrs: nounwind
; CHECK-LABEL: tail_dup_fallthrough_with_branch ; CHECK-LABEL: tail_dup_fallthrough_with_branch
Show All 34 Linesif.then: ; preds = %sw.default
call void @f3() #0 call void @f3() #0
br label %dup2 br label %dup2
if.else: ; preds = %sw.default if.else: ; preds = %sw.default
call void @f4() #0 call void @f4() #0
br label %dup2 br label %dup2
dup1: ; preds = %sw.0, %sw.1 dup1: ; preds = %sw.0, %sw.1
call void @llvm.lifetime.end(i64 8, i8* nonnull undef) #0 call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull undef) #0
unreachable unreachable
dup2: ; preds = %if.then, %if.else dup2: ; preds = %if.then, %if.else
call void @llvm.lifetime.end(i64 8, i8* nonnull undef) #0 call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull undef) #0
unreachable unreachable
} }
attributes #0 = { nounwind } attributes #0 = { nounwind }

test/CodeGen/PowerPC/toc-load-sched-bug.ll

Show First 20 Lines • Show All 217 Lines • ▼ Show 20 Linesif.then: ; preds = %_ZNK4llvm7ErrorOrISt10unique_ptrINS_12MemoryBufferESt14default_deleteIS2_EEE8getErrorEv.exit
store i8* bitcast (i64* getelementptr inbounds ([0 x i64], [0 x i64]* @_ZNSs4_Rep20_S_empty_rep_storageE, i64 0, i64 3) to i8*), i8** %_M_p2.i.i.i.i, align 8, !tbaa !1 store i8* bitcast (i64* getelementptr inbounds ([0 x i64], [0 x i64]* @_ZNSs4_Rep20_S_empty_rep_storageE, i64 0, i64 3) to i8*), i8** %_M_p2.i.i.i.i, align 8, !tbaa !1
%arrayidx.i.i.i36 = getelementptr inbounds i8, i8* %8, i64 -24 %arrayidx.i.i.i36 = getelementptr inbounds i8, i8* %8, i64 -24
%_M_length.i.i37 = bitcast i8* %arrayidx.i.i.i36 to i64* %_M_length.i.i37 = bitcast i8* %arrayidx.i.i.i36 to i64*
%9 = load i64, i64* %_M_length.i.i37, align 8, !tbaa !7 %9 = load i64, i64* %_M_length.i.i37, align 8, !tbaa !7
%Filename.i = getelementptr inbounds %"class.llvm::SMDiagnostic", %"class.llvm::SMDiagnostic"* %ref.tmp, i64 0, i32 2 %Filename.i = getelementptr inbounds %"class.llvm::SMDiagnostic", %"class.llvm::SMDiagnostic"* %ref.tmp, i64 0, i32 2
%10 = getelementptr inbounds %"class.std::allocator", %"class.std::allocator"* %ref.tmp.i.i2.i, i64 0, i32 0 %10 = getelementptr inbounds %"class.std::allocator", %"class.std::allocator"* %ref.tmp.i.i2.i, i64 0, i32 0
%11 = bitcast %"class.llvm::SMDiagnostic"* %ref.tmp to i8* %11 = bitcast %"class.llvm::SMDiagnostic"* %ref.tmp to i8*
call void @llvm.memset.p0i8.i64(i8* %11, i8 0, i64 16, i32 8, i1 false) #3 call void @llvm.memset.p0i8.i64(i8* %11, i8 0, i64 16, i32 8, i1 false) #3
call void @llvm.lifetime.start(i64 1, i8* %10) #3 call void @llvm.lifetime.start.p0i8(i64 1, i8* %10) #3
%tobool.i.i4.i = icmp eq i8* %4, null %tobool.i.i4.i = icmp eq i8* %4, null
br i1 %tobool.i.i4.i, label %if.then.i.i6.i, label %if.end.i.i8.i br i1 %tobool.i.i4.i, label %if.then.i.i6.i, label %if.end.i.i8.i
if.then.i.i6.i: ; preds = %if.then if.then.i.i6.i: ; preds = %if.then
%_M_p.i.i.i.i.i.i5.i = getelementptr inbounds %"class.std::basic_string", %"class.std::basic_string"* %Filename.i, i64 0, i32 0, i32 0 %_M_p.i.i.i.i.i.i5.i = getelementptr inbounds %"class.std::basic_string", %"class.std::basic_string"* %Filename.i, i64 0, i32 0, i32 0
store i8* bitcast (i64* getelementptr inbounds ([0 x i64], [0 x i64]* @_ZNSs4_Rep20_S_empty_rep_storageE, i64 0, i64 3) to i8*), i8** %_M_p.i.i.i.i.i.i5.i, align 8, !tbaa !13 store i8* bitcast (i64* getelementptr inbounds ([0 x i64], [0 x i64]* @_ZNSs4_Rep20_S_empty_rep_storageE, i64 0, i64 3) to i8*), i8** %_M_p.i.i.i.i.i.i5.i, align 8, !tbaa !13
br label %_ZNK4llvm9StringRefcvSsEv.exit9.i br label %_ZNK4llvm9StringRefcvSsEv.exit9.i
if.end.i.i8.i: ; preds = %if.then if.end.i.i8.i: ; preds = %if.then
call void @_ZNSsC1EPKcmRKSaIcE(%"class.std::basic_string"* %Filename.i, i8* %4, i64 %5, %"class.std::allocator"* dereferenceable(1) %ref.tmp.i.i2.i) #3 call void @_ZNSsC1EPKcmRKSaIcE(%"class.std::basic_string"* %Filename.i, i8* %4, i64 %5, %"class.std::allocator"* dereferenceable(1) %ref.tmp.i.i2.i) #3
br label %_ZNK4llvm9StringRefcvSsEv.exit9.i br label %_ZNK4llvm9StringRefcvSsEv.exit9.i
_ZNK4llvm9StringRefcvSsEv.exit9.i: ; preds = %if.end.i.i8.i, %if.then.i.i6.i _ZNK4llvm9StringRefcvSsEv.exit9.i: ; preds = %if.end.i.i8.i, %if.then.i.i6.i
call void @llvm.lifetime.end(i64 1, i8* %10) #3 call void @llvm.lifetime.end.p0i8(i64 1, i8* %10) #3
%LineNo.i = getelementptr inbounds %"class.llvm::SMDiagnostic", %"class.llvm::SMDiagnostic"* %ref.tmp, i64 0, i32 3 %LineNo.i = getelementptr inbounds %"class.llvm::SMDiagnostic", %"class.llvm::SMDiagnostic"* %ref.tmp, i64 0, i32 3
store i32 -1, i32* %LineNo.i, align 8, !tbaa !14 store i32 -1, i32* %LineNo.i, align 8, !tbaa !14
%ColumnNo.i = getelementptr inbounds %"class.llvm::SMDiagnostic", %"class.llvm::SMDiagnostic"* %ref.tmp, i64 0, i32 4 %ColumnNo.i = getelementptr inbounds %"class.llvm::SMDiagnostic", %"class.llvm::SMDiagnostic"* %ref.tmp, i64 0, i32 4
store i32 -1, i32* %ColumnNo.i, align 4, !tbaa !21 store i32 -1, i32* %ColumnNo.i, align 4, !tbaa !21
%Kind.i = getelementptr inbounds %"class.llvm::SMDiagnostic", %"class.llvm::SMDiagnostic"* %ref.tmp, i64 0, i32 5 %Kind.i = getelementptr inbounds %"class.llvm::SMDiagnostic", %"class.llvm::SMDiagnostic"* %ref.tmp, i64 0, i32 5
store i32 0, i32* %Kind.i, align 8, !tbaa !22 store i32 0, i32* %Kind.i, align 8, !tbaa !22
%Message.i = getelementptr inbounds %"class.llvm::SMDiagnostic", %"class.llvm::SMDiagnostic"* %ref.tmp, i64 0, i32 6 %Message.i = getelementptr inbounds %"class.llvm::SMDiagnostic", %"class.llvm::SMDiagnostic"* %ref.tmp, i64 0, i32 6
%12 = getelementptr inbounds %"class.std::allocator", %"class.std::allocator"* %ref.tmp.i.i.i, i64 0, i32 0 %12 = getelementptr inbounds %"class.std::allocator", %"class.std::allocator"* %ref.tmp.i.i.i, i64 0, i32 0
call void @llvm.lifetime.start(i64 1, i8* %12) #3 call void @llvm.lifetime.start.p0i8(i64 1, i8* %12) #3
%tobool.i.i.i = icmp eq i8* %8, null %tobool.i.i.i = icmp eq i8* %8, null
br i1 %tobool.i.i.i, label %if.then.i.i.i, label %if.end.i.i.i br i1 %tobool.i.i.i, label %if.then.i.i.i, label %if.end.i.i.i
if.then.i.i.i: ; preds = %_ZNK4llvm9StringRefcvSsEv.exit9.i if.then.i.i.i: ; preds = %_ZNK4llvm9StringRefcvSsEv.exit9.i
%_M_p.i.i.i.i.i.i.i = getelementptr inbounds %"class.std::basic_string", %"class.std::basic_string"* %Message.i, i64 0, i32 0, i32 0 %_M_p.i.i.i.i.i.i.i = getelementptr inbounds %"class.std::basic_string", %"class.std::basic_string"* %Message.i, i64 0, i32 0, i32 0
store i8* bitcast (i64* getelementptr inbounds ([0 x i64], [0 x i64]* @_ZNSs4_Rep20_S_empty_rep_storageE, i64 0, i64 3) to i8*), i8** %_M_p.i.i.i.i.i.i.i, align 8, !tbaa !13 store i8* bitcast (i64* getelementptr inbounds ([0 x i64], [0 x i64]* @_ZNSs4_Rep20_S_empty_rep_storageE, i64 0, i64 3) to i8*), i8** %_M_p.i.i.i.i.i.i.i, align 8, !tbaa !13
br label %_ZN4llvm12SMDiagnosticC2ENS_9StringRefENS_9SourceMgr8DiagKindES1_.exit br label %_ZN4llvm12SMDiagnosticC2ENS_9StringRefENS_9SourceMgr8DiagKindES1_.exit
if.end.i.i.i: ; preds = %_ZNK4llvm9StringRefcvSsEv.exit9.i if.end.i.i.i: ; preds = %_ZNK4llvm9StringRefcvSsEv.exit9.i
call void @_ZNSsC1EPKcmRKSaIcE(%"class.std::basic_string"* %Message.i, i8* %8, i64 %9, %"class.std::allocator"* dereferenceable(1) %ref.tmp.i.i.i) #3 call void @_ZNSsC1EPKcmRKSaIcE(%"class.std::basic_string"* %Message.i, i8* %8, i64 %9, %"class.std::allocator"* dereferenceable(1) %ref.tmp.i.i.i) #3
br label %_ZN4llvm12SMDiagnosticC2ENS_9StringRefENS_9SourceMgr8DiagKindES1_.exit br label %_ZN4llvm12SMDiagnosticC2ENS_9StringRefENS_9SourceMgr8DiagKindES1_.exit
_ZN4llvm12SMDiagnosticC2ENS_9StringRefENS_9SourceMgr8DiagKindES1_.exit: ; preds = %if.then.i.i.i, %if.end.i.i.i _ZN4llvm12SMDiagnosticC2ENS_9StringRefENS_9SourceMgr8DiagKindES1_.exit: ; preds = %if.then.i.i.i, %if.end.i.i.i
call void @llvm.lifetime.end(i64 1, i8* %12) #3 call void @llvm.lifetime.end.p0i8(i64 1, i8* %12) #3
%_M_p.i.i.i.i.i = getelementptr inbounds %"class.llvm::SMDiagnostic", %"class.llvm::SMDiagnostic"* %ref.tmp, i64 0, i32 7, i32 0, i32 0 %_M_p.i.i.i.i.i = getelementptr inbounds %"class.llvm::SMDiagnostic", %"class.llvm::SMDiagnostic"* %ref.tmp, i64 0, i32 7, i32 0, i32 0
store i8* bitcast (i64* getelementptr inbounds ([0 x i64], [0 x i64]* @_ZNSs4_Rep20_S_empty_rep_storageE, i64 0, i64 3) to i8*), i8** %_M_p.i.i.i.i.i, align 8, !tbaa !13 store i8* bitcast (i64* getelementptr inbounds ([0 x i64], [0 x i64]* @_ZNSs4_Rep20_S_empty_rep_storageE, i64 0, i64 3) to i8*), i8** %_M_p.i.i.i.i.i, align 8, !tbaa !13
%Ranges.i = getelementptr inbounds %"class.llvm::SMDiagnostic", %"class.llvm::SMDiagnostic"* %ref.tmp, i64 0, i32 8 %Ranges.i = getelementptr inbounds %"class.llvm::SMDiagnostic", %"class.llvm::SMDiagnostic"* %ref.tmp, i64 0, i32 8
%13 = bitcast %"class.std::vector.79"* %Ranges.i to i8* %13 = bitcast %"class.std::vector.79"* %Ranges.i to i8*
call void @llvm.memset.p0i8.i64(i8* %13, i8 0, i64 24, i32 8, i1 false) #3 call void @llvm.memset.p0i8.i64(i8* %13, i8 0, i64 24, i32 8, i1 false) #3
%14 = getelementptr inbounds %"class.llvm::SMDiagnostic", %"class.llvm::SMDiagnostic"* %ref.tmp, i64 0, i32 9, i32 0, i32 0, i32 0, i32 1, i32 0, i32 0, i64 0 %14 = getelementptr inbounds %"class.llvm::SMDiagnostic", %"class.llvm::SMDiagnostic"* %ref.tmp, i64 0, i32 9, i32 0, i32 0, i32 0, i32 1, i32 0, i32 0, i64 0
%BeginX.i.i.i.i.i.i = getelementptr inbounds %"class.llvm::SMDiagnostic", %"class.llvm::SMDiagnostic"* %ref.tmp, i64 0, i32 9, i32 0, i32 0, i32 0, i32 0, i32 0 %BeginX.i.i.i.i.i.i = getelementptr inbounds %"class.llvm::SMDiagnostic", %"class.llvm::SMDiagnostic"* %ref.tmp, i64 0, i32 9, i32 0, i32 0, i32 0, i32 0, i32 0
store i8* %14, i8** %BeginX.i.i.i.i.i.i, align 8, !tbaa !23 store i8* %14, i8** %BeginX.i.i.i.i.i.i, align 8, !tbaa !23
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Linesif.then.i.i.i.i.i.i: ; preds = %_ZN4llvm12SMDiagnosticC2ENS_9StringRefENS_9SourceMgr8DiagKindES1_.exit
br label %_ZN4llvm12SMDiagnosticaSEOS0_.exit br label %_ZN4llvm12SMDiagnosticaSEOS0_.exit
_ZN4llvm12SMDiagnosticaSEOS0_.exit: ; preds = %_ZN4llvm12SMDiagnosticC2ENS_9StringRefENS_9SourceMgr8DiagKindES1_.exit, %if.then.i.i.i.i.i.i _ZN4llvm12SMDiagnosticaSEOS0_.exit: ; preds = %_ZN4llvm12SMDiagnosticC2ENS_9StringRefENS_9SourceMgr8DiagKindES1_.exit, %if.then.i.i.i.i.i.i
%24 = getelementptr inbounds %"class.llvm::SMDiagnostic", %"class.llvm::SMDiagnostic"* %Err, i64 0, i32 9, i32 0 %24 = getelementptr inbounds %"class.llvm::SMDiagnostic", %"class.llvm::SMDiagnostic"* %Err, i64 0, i32 9, i32 0
%25 = getelementptr inbounds %"class.llvm::SMDiagnostic", %"class.llvm::SMDiagnostic"* %ref.tmp, i64 0, i32 9, i32 0 %25 = getelementptr inbounds %"class.llvm::SMDiagnostic", %"class.llvm::SMDiagnostic"* %ref.tmp, i64 0, i32 9, i32 0
%call2.i.i42 = call dereferenceable(48) %"class.llvm::SmallVectorImpl.85"* @_ZN4llvm15SmallVectorImplINS_7SMFixItEEaSEOS2_(%"class.llvm::SmallVectorImpl.85"* %24, %"class.llvm::SmallVectorImpl.85"* dereferenceable(48) %25) #3 %call2.i.i42 = call dereferenceable(48) %"class.llvm::SmallVectorImpl.85"* @_ZN4llvm15SmallVectorImplINS_7SMFixItEEaSEOS2_(%"class.llvm::SmallVectorImpl.85"* %24, %"class.llvm::SmallVectorImpl.85"* dereferenceable(48) %25) #3
call void @_ZN4llvm12SMDiagnosticD2Ev(%"class.llvm::SMDiagnostic"* %ref.tmp) #3 call void @_ZN4llvm12SMDiagnosticD2Ev(%"class.llvm::SMDiagnostic"* %ref.tmp) #3
%26 = getelementptr inbounds %"class.std::allocator", %"class.std::allocator"* %ref.tmp.i.i, i64 0, i32 0 %26 = getelementptr inbounds %"class.std::allocator", %"class.std::allocator"* %ref.tmp.i.i, i64 0, i32 0
call void @llvm.lifetime.start(i64 1, i8* %26) #3 call void @llvm.lifetime.start.p0i8(i64 1, i8* %26) #3
%27 = bitcast i8* %arrayidx.i.i.i36 to %"struct.std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep"* %27 = bitcast i8* %arrayidx.i.i.i36 to %"struct.std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep"*
%cmp.i.i.i = icmp eq i8* %arrayidx.i.i.i36, bitcast ([0 x i64]* @_ZNSs4_Rep20_S_empty_rep_storageE to i8*) %cmp.i.i.i = icmp eq i8* %arrayidx.i.i.i36, bitcast ([0 x i64]* @_ZNSs4_Rep20_S_empty_rep_storageE to i8*)
br i1 %cmp.i.i.i, label %_ZNSsD1Ev.exit, label %if.then.i.i.i45, !prof !28 br i1 %cmp.i.i.i, label %_ZNSsD1Ev.exit, label %if.then.i.i.i45, !prof !28
if.then.i.i.i45: ; preds = %_ZN4llvm12SMDiagnosticaSEOS0_.exit if.then.i.i.i45: ; preds = %_ZN4llvm12SMDiagnosticaSEOS0_.exit
%_M_refcount.i.i.i = getelementptr inbounds i8, i8* %8, i64 -8 %_M_refcount.i.i.i = getelementptr inbounds i8, i8* %8, i64 -8
%28 = bitcast i8* %_M_refcount.i.i.i to i32* %28 = bitcast i8* %_M_refcount.i.i.i to i32*
br i1 icmp ne (i8* bitcast (i32 (i32*, void (i8*)*)* @__pthread_key_create to i8*), i8* null), label %if.then.i.i.i.i, label %if.else.i.i.i.i br i1 icmp ne (i8* bitcast (i32 (i32*, void (i8*)*)* @__pthread_key_create to i8*), i8* null), label %if.then.i.i.i.i, label %if.else.i.i.i.i
if.then.i.i.i.i: ; preds = %if.then.i.i.i45 if.then.i.i.i.i: ; preds = %if.then.i.i.i45
%.atomicdst.i.i.i.i.i.0..atomicdst.i.i.i.i.0..atomicdst.i.i.i.0..atomicdst.i.i.0..atomicdst.i.0..sroa_cast = bitcast i32* %.atomicdst.i.i.i.i.i to i8* %.atomicdst.i.i.i.i.i.0..atomicdst.i.i.i.i.0..atomicdst.i.i.i.0..atomicdst.i.i.0..atomicdst.i.0..sroa_cast = bitcast i32* %.atomicdst.i.i.i.i.i to i8*
call void @llvm.lifetime.start(i64 4, i8* %.atomicdst.i.i.i.i.i.0..atomicdst.i.i.i.i.0..atomicdst.i.i.i.0..atomicdst.i.i.0..atomicdst.i.0..sroa_cast) call void @llvm.lifetime.start.p0i8(i64 4, i8* %.atomicdst.i.i.i.i.i.0..atomicdst.i.i.i.i.0..atomicdst.i.i.i.0..atomicdst.i.i.0..atomicdst.i.0..sroa_cast)
%29 = atomicrmw volatile add i32* %28, i32 -1 acq_rel %29 = atomicrmw volatile add i32* %28, i32 -1 acq_rel
store i32 %29, i32* %.atomicdst.i.i.i.i.i, align 4 store i32 %29, i32* %.atomicdst.i.i.i.i.i, align 4
%.atomicdst.i.i.i.i.i.0..atomicdst.i.i.i.i.0..atomicdst.i.i.i.0..atomicdst.i.i.0..atomicdst.i.0..atomicdst.0..atomicdst.0..i.i.i.i.i = load volatile i32, i32* %.atomicdst.i.i.i.i.i, align 4 %.atomicdst.i.i.i.i.i.0..atomicdst.i.i.i.i.0..atomicdst.i.i.i.0..atomicdst.i.i.0..atomicdst.i.0..atomicdst.0..atomicdst.0..i.i.i.i.i = load volatile i32, i32* %.atomicdst.i.i.i.i.i, align 4
call void @llvm.lifetime.end(i64 4, i8* %.atomicdst.i.i.i.i.i.0..atomicdst.i.i.i.i.0..atomicdst.i.i.i.0..atomicdst.i.i.0..atomicdst.i.0..sroa_cast) call void @llvm.lifetime.end.p0i8(i64 4, i8* %.atomicdst.i.i.i.i.i.0..atomicdst.i.i.i.i.0..atomicdst.i.i.i.0..atomicdst.i.i.0..atomicdst.i.0..sroa_cast)
br label %_ZN9__gnu_cxxL27__exchange_and_add_dispatchEPii.exit.i.i.i br label %_ZN9__gnu_cxxL27__exchange_and_add_dispatchEPii.exit.i.i.i
if.else.i.i.i.i: ; preds = %if.then.i.i.i45 if.else.i.i.i.i: ; preds = %if.then.i.i.i45
%30 = load i32, i32* %28, align 4, !tbaa !29 %30 = load i32, i32* %28, align 4, !tbaa !29
%add.i.i.i.i.i = add nsw i32 %30, -1 %add.i.i.i.i.i = add nsw i32 %30, -1
store i32 %add.i.i.i.i.i, i32* %28, align 4, !tbaa !29 store i32 %add.i.i.i.i.i, i32* %28, align 4, !tbaa !29
br label %_ZN9__gnu_cxxL27__exchange_and_add_dispatchEPii.exit.i.i.i br label %_ZN9__gnu_cxxL27__exchange_and_add_dispatchEPii.exit.i.i.i
_ZN9__gnu_cxxL27__exchange_and_add_dispatchEPii.exit.i.i.i: ; preds = %if.else.i.i.i.i, %if.then.i.i.i.i _ZN9__gnu_cxxL27__exchange_and_add_dispatchEPii.exit.i.i.i: ; preds = %if.else.i.i.i.i, %if.then.i.i.i.i
%retval.0.i.i.i.i = phi i32 [ %.atomicdst.i.i.i.i.i.0..atomicdst.i.i.i.i.0..atomicdst.i.i.i.0..atomicdst.i.i.0..atomicdst.i.0..atomicdst.0..atomicdst.0..i.i.i.i.i, %if.then.i.i.i.i ], [ %30, %if.else.i.i.i.i ] %retval.0.i.i.i.i = phi i32 [ %.atomicdst.i.i.i.i.i.0..atomicdst.i.i.i.i.0..atomicdst.i.i.i.0..atomicdst.i.i.0..atomicdst.i.0..atomicdst.0..atomicdst.0..i.i.i.i.i, %if.then.i.i.i.i ], [ %30, %if.else.i.i.i.i ]
%cmp3.i.i.i = icmp slt i32 %retval.0.i.i.i.i, 1 %cmp3.i.i.i = icmp slt i32 %retval.0.i.i.i.i, 1
br i1 %cmp3.i.i.i, label %if.then4.i.i.i, label %_ZNSsD1Ev.exit br i1 %cmp3.i.i.i, label %if.then4.i.i.i, label %_ZNSsD1Ev.exit
if.then4.i.i.i: ; preds = %_ZN9__gnu_cxxL27__exchange_and_add_dispatchEPii.exit.i.i.i if.then4.i.i.i: ; preds = %_ZN9__gnu_cxxL27__exchange_and_add_dispatchEPii.exit.i.i.i
call void @_ZNSs4_Rep10_M_destroyERKSaIcE(%"struct.std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep"* %27, %"class.std::allocator"* dereferenceable(1) %ref.tmp.i.i) #3 call void @_ZNSs4_Rep10_M_destroyERKSaIcE(%"struct.std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep"* %27, %"class.std::allocator"* dereferenceable(1) %ref.tmp.i.i) #3
br label %_ZNSsD1Ev.exit br label %_ZNSsD1Ev.exit
_ZNSsD1Ev.exit: ; preds = %_ZN4llvm12SMDiagnosticaSEOS0_.exit, %_ZN9__gnu_cxxL27__exchange_and_add_dispatchEPii.exit.i.i.i, %if.then4.i.i.i _ZNSsD1Ev.exit: ; preds = %_ZN4llvm12SMDiagnosticaSEOS0_.exit, %_ZN9__gnu_cxxL27__exchange_and_add_dispatchEPii.exit.i.i.i, %if.then4.i.i.i
call void @llvm.lifetime.end(i64 1, i8* %26) #3 call void @llvm.lifetime.end.p0i8(i64 1, i8* %26) #3
%31 = getelementptr inbounds %"class.std::allocator", %"class.std::allocator"* %ref.tmp.i.i47, i64 0, i32 0 %31 = getelementptr inbounds %"class.std::allocator", %"class.std::allocator"* %ref.tmp.i.i47, i64 0, i32 0
call void @llvm.lifetime.start(i64 1, i8* %31) #3 call void @llvm.lifetime.start.p0i8(i64 1, i8* %31) #3
%_M_p.i.i.i.i48 = getelementptr inbounds %"class.std::basic_string", %"class.std::basic_string"* %ref.tmp5, i64 0, i32 0, i32 0 %_M_p.i.i.i.i48 = getelementptr inbounds %"class.std::basic_string", %"class.std::basic_string"* %ref.tmp5, i64 0, i32 0, i32 0
%32 = load i8*, i8** %_M_p.i.i.i.i48, align 8, !tbaa !1 %32 = load i8*, i8** %_M_p.i.i.i.i48, align 8, !tbaa !1
%arrayidx.i.i.i49 = getelementptr inbounds i8, i8* %32, i64 -24 %arrayidx.i.i.i49 = getelementptr inbounds i8, i8* %32, i64 -24
%33 = bitcast i8* %arrayidx.i.i.i49 to %"struct.std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep"* %33 = bitcast i8* %arrayidx.i.i.i49 to %"struct.std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep"*
%cmp.i.i.i50 = icmp eq i8* %arrayidx.i.i.i49, bitcast ([0 x i64]* @_ZNSs4_Rep20_S_empty_rep_storageE to i8*) %cmp.i.i.i50 = icmp eq i8* %arrayidx.i.i.i49, bitcast ([0 x i64]* @_ZNSs4_Rep20_S_empty_rep_storageE to i8*)
br i1 %cmp.i.i.i50, label %_ZNSsD1Ev.exit62, label %if.then.i.i.i52, !prof !28 br i1 %cmp.i.i.i50, label %_ZNSsD1Ev.exit62, label %if.then.i.i.i52, !prof !28
if.then.i.i.i52: ; preds = %_ZNSsD1Ev.exit if.then.i.i.i52: ; preds = %_ZNSsD1Ev.exit
%_M_refcount.i.i.i51 = getelementptr inbounds i8, i8* %32, i64 -8 %_M_refcount.i.i.i51 = getelementptr inbounds i8, i8* %32, i64 -8
%34 = bitcast i8* %_M_refcount.i.i.i51 to i32* %34 = bitcast i8* %_M_refcount.i.i.i51 to i32*
br i1 icmp ne (i8* bitcast (i32 (i32*, void (i8*)*)* @__pthread_key_create to i8*), i8* null), label %if.then.i.i.i.i55, label %if.else.i.i.i.i57 br i1 icmp ne (i8* bitcast (i32 (i32*, void (i8*)*)* @__pthread_key_create to i8*), i8* null), label %if.then.i.i.i.i55, label %if.else.i.i.i.i57
if.then.i.i.i.i55: ; preds = %if.then.i.i.i52 if.then.i.i.i.i55: ; preds = %if.then.i.i.i52
%.atomicdst.i.i.i.i.i46.0..atomicdst.i.i.i.i.0..atomicdst.i.i.i.0..atomicdst.i.i.0..atomicdst.i.0..sroa_cast = bitcast i32* %.atomicdst.i.i.i.i.i46 to i8* %.atomicdst.i.i.i.i.i46.0..atomicdst.i.i.i.i.0..atomicdst.i.i.i.0..atomicdst.i.i.0..atomicdst.i.0..sroa_cast = bitcast i32* %.atomicdst.i.i.i.i.i46 to i8*
call void @llvm.lifetime.start(i64 4, i8* %.atomicdst.i.i.i.i.i46.0..atomicdst.i.i.i.i.0..atomicdst.i.i.i.0..atomicdst.i.i.0..atomicdst.i.0..sroa_cast) call void @llvm.lifetime.start.p0i8(i64 4, i8* %.atomicdst.i.i.i.i.i46.0..atomicdst.i.i.i.i.0..atomicdst.i.i.i.0..atomicdst.i.i.0..atomicdst.i.0..sroa_cast)
%35 = atomicrmw volatile add i32* %34, i32 -1 acq_rel %35 = atomicrmw volatile add i32* %34, i32 -1 acq_rel
store i32 %35, i32* %.atomicdst.i.i.i.i.i46, align 4 store i32 %35, i32* %.atomicdst.i.i.i.i.i46, align 4
%.atomicdst.i.i.i.i.i46.0..atomicdst.i.i.i.i.0..atomicdst.i.i.i.0..atomicdst.i.i.0..atomicdst.i.0..atomicdst.0..atomicdst.0..i.i.i.i.i54 = load volatile i32, i32* %.atomicdst.i.i.i.i.i46, align 4 %.atomicdst.i.i.i.i.i46.0..atomicdst.i.i.i.i.0..atomicdst.i.i.i.0..atomicdst.i.i.0..atomicdst.i.0..atomicdst.0..atomicdst.0..i.i.i.i.i54 = load volatile i32, i32* %.atomicdst.i.i.i.i.i46, align 4
call void @llvm.lifetime.end(i64 4, i8* %.atomicdst.i.i.i.i.i46.0..atomicdst.i.i.i.i.0..atomicdst.i.i.i.0..atomicdst.i.i.0..atomicdst.i.0..sroa_cast) call void @llvm.lifetime.end.p0i8(i64 4, i8* %.atomicdst.i.i.i.i.i46.0..atomicdst.i.i.i.i.0..atomicdst.i.i.i.0..atomicdst.i.i.0..atomicdst.i.0..sroa_cast)
br label %_ZN9__gnu_cxxL27__exchange_and_add_dispatchEPii.exit.i.i.i60 br label %_ZN9__gnu_cxxL27__exchange_and_add_dispatchEPii.exit.i.i.i60
if.else.i.i.i.i57: ; preds = %if.then.i.i.i52 if.else.i.i.i.i57: ; preds = %if.then.i.i.i52
%36 = load i32, i32* %34, align 4, !tbaa !29 %36 = load i32, i32* %34, align 4, !tbaa !29
%add.i.i.i.i.i56 = add nsw i32 %36, -1 %add.i.i.i.i.i56 = add nsw i32 %36, -1
store i32 %add.i.i.i.i.i56, i32* %34, align 4, !tbaa !29 store i32 %add.i.i.i.i.i56, i32* %34, align 4, !tbaa !29
br label %_ZN9__gnu_cxxL27__exchange_and_add_dispatchEPii.exit.i.i.i60 br label %_ZN9__gnu_cxxL27__exchange_and_add_dispatchEPii.exit.i.i.i60
_ZN9__gnu_cxxL27__exchange_and_add_dispatchEPii.exit.i.i.i60: ; preds = %if.else.i.i.i.i57, %if.then.i.i.i.i55 _ZN9__gnu_cxxL27__exchange_and_add_dispatchEPii.exit.i.i.i60: ; preds = %if.else.i.i.i.i57, %if.then.i.i.i.i55
%retval.0.i.i.i.i58 = phi i32 [ %.atomicdst.i.i.i.i.i46.0..atomicdst.i.i.i.i.0..atomicdst.i.i.i.0..atomicdst.i.i.0..atomicdst.i.0..atomicdst.0..atomicdst.0..i.i.i.i.i54, %if.then.i.i.i.i55 ], [ %36, %if.else.i.i.i.i57 ] %retval.0.i.i.i.i58 = phi i32 [ %.atomicdst.i.i.i.i.i46.0..atomicdst.i.i.i.i.0..atomicdst.i.i.i.0..atomicdst.i.i.0..atomicdst.i.0..atomicdst.0..atomicdst.0..i.i.i.i.i54, %if.then.i.i.i.i55 ], [ %36, %if.else.i.i.i.i57 ]
%cmp3.i.i.i59 = icmp slt i32 %retval.0.i.i.i.i58, 1 %cmp3.i.i.i59 = icmp slt i32 %retval.0.i.i.i.i58, 1
br i1 %cmp3.i.i.i59, label %if.then4.i.i.i61, label %_ZNSsD1Ev.exit62 br i1 %cmp3.i.i.i59, label %if.then4.i.i.i61, label %_ZNSsD1Ev.exit62
if.then4.i.i.i61: ; preds = %_ZN9__gnu_cxxL27__exchange_and_add_dispatchEPii.exit.i.i.i60 if.then4.i.i.i61: ; preds = %_ZN9__gnu_cxxL27__exchange_and_add_dispatchEPii.exit.i.i.i60
call void @_ZNSs4_Rep10_M_destroyERKSaIcE(%"struct.std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep"* %33, %"class.std::allocator"* dereferenceable(1) %ref.tmp.i.i47) #3 call void @_ZNSs4_Rep10_M_destroyERKSaIcE(%"struct.std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep"* %33, %"class.std::allocator"* dereferenceable(1) %ref.tmp.i.i47) #3
br label %_ZNSsD1Ev.exit62 br label %_ZNSsD1Ev.exit62
_ZNSsD1Ev.exit62: ; preds = %_ZNSsD1Ev.exit, %_ZN9__gnu_cxxL27__exchange_and_add_dispatchEPii.exit.i.i.i60, %if.then4.i.i.i61 _ZNSsD1Ev.exit62: ; preds = %_ZNSsD1Ev.exit, %_ZN9__gnu_cxxL27__exchange_and_add_dispatchEPii.exit.i.i.i60, %if.then4.i.i.i61
call void @llvm.lifetime.end(i64 1, i8* %31) #3 call void @llvm.lifetime.end.p0i8(i64 1, i8* %31) #3
br label %cleanup br label %cleanup
cond.false.i.i: ; preds = %_ZNK4llvm7ErrorOrISt10unique_ptrINS_12MemoryBufferESt14default_deleteIS2_EEE8getErrorEv.exit cond.false.i.i: ; preds = %_ZNK4llvm7ErrorOrISt10unique_ptrINS_12MemoryBufferESt14default_deleteIS2_EEE8getErrorEv.exit
call void @__assert_fail(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str1, i64 0, i64 0), i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str2, i64 0, i64 0), i32 zeroext 242, i8* getelementptr inbounds ([206 x i8], [206 x i8]* @__PRETTY_FUNCTION__._ZN4llvm7ErrorOrISt10unique_ptrINS_12MemoryBufferESt14default_deleteIS2_EEE10getStorageEv, i64 0, i64 0)) #7 call void @__assert_fail(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str1, i64 0, i64 0), i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str2, i64 0, i64 0), i32 zeroext 242, i8* getelementptr inbounds ([206 x i8], [206 x i8]* @__PRETTY_FUNCTION__._ZN4llvm7ErrorOrISt10unique_ptrINS_12MemoryBufferESt14default_deleteIS2_EEE10getStorageEv, i64 0, i64 0)) #7
unreachable unreachable
_ZN4llvm7ErrorOrISt10unique_ptrINS_12MemoryBufferESt14default_deleteIS2_EEE3getEv.exit: ; preds = %entry _ZN4llvm7ErrorOrISt10unique_ptrINS_12MemoryBufferESt14default_deleteIS2_EEE3getEv.exit: ; preds = %entry
%_M_head_impl.i.i.i.i.i = bitcast %"class.llvm::ErrorOr"* %FileOrErr to %"class.llvm::MemoryBuffer"** %_M_head_impl.i.i.i.i.i = bitcast %"class.llvm::ErrorOr"* %FileOrErr to %"class.llvm::MemoryBuffer"**
Show All 26 Lines_ZNSt10unique_ptrIN4llvm12MemoryBufferESt14default_deleteIS1_EED2Ev.exit.i: ; preds = %_ZNKSt14default_deleteIN4llvm12MemoryBufferEEclEPS1_.exit.i.i, %_ZN4llvm7ErrorOrISt10unique_ptrINS_12MemoryBufferESt14default_deleteIS2_EEE10getStorageEv.exit.i
store %"class.llvm::MemoryBuffer"* null, %"class.llvm::MemoryBuffer"** %_M_head_impl.i.i.i.i.i.i, align 8, !tbaa !27 store %"class.llvm::MemoryBuffer"* null, %"class.llvm::MemoryBuffer"** %_M_head_impl.i.i.i.i.i.i, align 8, !tbaa !27
br label %_ZN4llvm7ErrorOrISt10unique_ptrINS_12MemoryBufferESt14default_deleteIS2_EEED2Ev.exit br label %_ZN4llvm7ErrorOrISt10unique_ptrINS_12MemoryBufferESt14default_deleteIS2_EEED2Ev.exit
_ZN4llvm7ErrorOrISt10unique_ptrINS_12MemoryBufferESt14default_deleteIS2_EEED2Ev.exit: ; preds = %cleanup, %_ZNSt10unique_ptrIN4llvm12MemoryBufferESt14default_deleteIS1_EED2Ev.exit.i _ZN4llvm7ErrorOrISt10unique_ptrINS_12MemoryBufferESt14default_deleteIS2_EEED2Ev.exit: ; preds = %cleanup, %_ZNSt10unique_ptrIN4llvm12MemoryBufferESt14default_deleteIS1_EED2Ev.exit.i
ret %"class.llvm::Module"* %retval.0 ret %"class.llvm::Module"* %retval.0
} }
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) #3 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #3
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) #3 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #3
; Function Attrs: noreturn nounwind ; Function Attrs: noreturn nounwind
declare void @__assert_fail(i8*, i8*, i32 zeroext, i8*) #4 declare void @__assert_fail(i8*, i8*, i32 zeroext, i8*) #4
declare dereferenceable(8) %"class.std::basic_string"* @_ZNSs6insertEmPKcm(%"class.std::basic_string"*, i64, i8*, i64) #1 declare dereferenceable(8) %"class.std::basic_string"* @_ZNSs6insertEmPKcm(%"class.std::basic_string"*, i64, i8*, i64) #1
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i32, i1) #3 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i32, i1) #3
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

test/CodeGen/SystemZ/stack-guard.ll

Show All 11 Lines
; CHECK: ear [[REG2]], %a1 ; CHECK: ear [[REG2]], %a1
; CHECK: lg [[REG2]], 40([[REG2]]) ; CHECK: lg [[REG2]], 40([[REG2]])
; CHECK: sg [[REG2]], {{[0-9]*}}(%r15) ; CHECK: sg [[REG2]], {{[0-9]*}}(%r15)
define i32 @test_stack_guard() #0 { define i32 @test_stack_guard() #0 {
entry: entry:
%a1 = alloca [256 x i32], align 4 %a1 = alloca [256 x i32], align 4
%0 = bitcast [256 x i32]* %a1 to i8* %0 = bitcast [256 x i32]* %a1 to i8*
call void @llvm.lifetime.start(i64 1024, i8* %0) call void @llvm.lifetime.start.p0i8(i64 1024, i8* %0)
%arraydecay = getelementptr inbounds [256 x i32], [256 x i32]* %a1, i64 0, i64 0 %arraydecay = getelementptr inbounds [256 x i32], [256 x i32]* %a1, i64 0, i64 0
call void @foo3(i32* %arraydecay) call void @foo3(i32* %arraydecay)
call void @llvm.lifetime.end(i64 1024, i8* %0) call void @llvm.lifetime.end.p0i8(i64 1024, i8* %0)
ret i32 0 ret i32 0
} }
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @foo3(i32*) declare void @foo3(i32*)
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
attributes #0 = { sspstrong } attributes #0 = { sspstrong }

test/CodeGen/Thumb/PR17309.ll

; RUN: llc -mtriple thumbv5-none-linux-gnueabi < %s | FileCheck %s ; RUN: llc -mtriple thumbv5-none-linux-gnueabi < %s | FileCheck %s
%struct.C = type { [1000 x i8] } %struct.C = type { [1000 x i8] }
%struct.S = type { [1000 x i16] } %struct.S = type { [1000 x i16] }
%struct.I = type { [1000 x i32] } %struct.I = type { [1000 x i32] }
;CHECK-LABEL: pass_C: ;CHECK-LABEL: pass_C:
;CHECK-NOT: ldrb r{{[0-9]+}}, [{{.*}}], #1 ;CHECK-NOT: ldrb r{{[0-9]+}}, [{{.*}}], #1
;CHECK-NOT: strb r{{[0-9]+}}, [{{.*}}], #1 ;CHECK-NOT: strb r{{[0-9]+}}, [{{.*}}], #1
define void @pass_C() #0 { define void @pass_C() #0 {
entry: entry:
%c = alloca %struct.C, align 1 %c = alloca %struct.C, align 1
%0 = getelementptr inbounds %struct.C, %struct.C* %c, i32 0, i32 0, i32 0 %0 = getelementptr inbounds %struct.C, %struct.C* %c, i32 0, i32 0, i32 0
call void @llvm.lifetime.start(i64 1000, i8* %0) #1 call void @llvm.lifetime.start.p0i8(i64 1000, i8* %0) #1
call void @use_C(%struct.C* byval %c) #3 call void @use_C(%struct.C* byval %c) #3
call void @llvm.lifetime.end(i64 1000, i8* %0) #1 call void @llvm.lifetime.end.p0i8(i64 1000, i8* %0) #1
ret void ret void
} }
;CHECK-LABEL: pass_S: ;CHECK-LABEL: pass_S:
;CHECK-NOT: ldrh r{{[0-9]+}}, [{{.*}}], #2 ;CHECK-NOT: ldrh r{{[0-9]+}}, [{{.*}}], #2
;CHECK-NOT: strh r{{[0-9]+}}, [{{.*}}], #2 ;CHECK-NOT: strh r{{[0-9]+}}, [{{.*}}], #2
define void @pass_S() #0 { define void @pass_S() #0 {
entry: entry:
%s = alloca %struct.S, align 2 %s = alloca %struct.S, align 2
%0 = bitcast %struct.S* %s to i8* %0 = bitcast %struct.S* %s to i8*
call void @llvm.lifetime.start(i64 2000, i8* %0) #1 call void @llvm.lifetime.start.p0i8(i64 2000, i8* %0) #1
call void @use_S(%struct.S* byval %s) #3 call void @use_S(%struct.S* byval %s) #3
call void @llvm.lifetime.end(i64 2000, i8* %0) #1 call void @llvm.lifetime.end.p0i8(i64 2000, i8* %0) #1
ret void ret void
} }
;CHECK-LABEL: pass_I: ;CHECK-LABEL: pass_I:
;CHECK-NOT: ldr r{{[0-9]+}}, [{{.*}}], #4 ;CHECK-NOT: ldr r{{[0-9]+}}, [{{.*}}], #4
;CHECK-NOT: str r{{[0-9]+}}, [{{.*}}], #4 ;CHECK-NOT: str r{{[0-9]+}}, [{{.*}}], #4
define void @pass_I() #0 { define void @pass_I() #0 {
entry: entry:
%i = alloca %struct.I, align 4 %i = alloca %struct.I, align 4
%0 = bitcast %struct.I* %i to i8* %0 = bitcast %struct.I* %i to i8*
call void @llvm.lifetime.start(i64 4000, i8* %0) #1 call void @llvm.lifetime.start.p0i8(i64 4000, i8* %0) #1
call void @use_I(%struct.I* byval %i) #3 call void @use_I(%struct.I* byval %i) #3
call void @llvm.lifetime.end(i64 4000, i8* %0) #1 call void @llvm.lifetime.end.p0i8(i64 4000, i8* %0) #1
ret void ret void
} }
declare void @use_C(%struct.C* byval) #2 declare void @use_C(%struct.C* byval) #2
declare void @use_S(%struct.S* byval) #2 declare void @use_S(%struct.S* byval) #2
declare void @use_I(%struct.I* byval) #2 declare void @use_I(%struct.I* byval) #2
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
attributes #0 = { nounwind optsize "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-frame-pointer-elim-non-leaf"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #0 = { nounwind optsize "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-frame-pointer-elim-non-leaf"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { nounwind } attributes #1 = { nounwind }
attributes #2 = { optsize "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-frame-pointer-elim-non-leaf"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #2 = { optsize "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-frame-pointer-elim-non-leaf"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #3 = { nounwind optsize } attributes #3 = { nounwind optsize }

test/CodeGen/Thumb/stack-coloring-without-frame-ptr.ll

; RUN: llc -mtriple=thumb-eabi -mcpu=arm1022e %s -o /dev/null ; RUN: llc -mtriple=thumb-eabi -mcpu=arm1022e %s -o /dev/null
%iterator = type { i8**, i8**, i8**, i8*** } %iterator = type { i8**, i8**, i8**, i8*** }
%insert_iterator = type { %deque*, %iterator } %insert_iterator = type { %deque*, %iterator }
%deque = type { %iterator, %iterator, i8***, i32 } %deque = type { %iterator, %iterator, i8***, i32 }
define i32 @test_thumbv5e_fp_elim() nounwind optsize { define i32 @test_thumbv5e_fp_elim() nounwind optsize {
entry: entry:
%var1 = alloca %iterator, align 4 %var1 = alloca %iterator, align 4
%var2 = alloca %insert_iterator, align 4 %var2 = alloca %insert_iterator, align 4
%var3 = alloca %deque, align 4 %var3 = alloca %deque, align 4
%0 = bitcast %deque* %var3 to i8* %0 = bitcast %deque* %var3 to i8*
%1 = bitcast %iterator* %var1 to i8* %1 = bitcast %iterator* %var1 to i8*
call void @llvm.lifetime.start(i64 16, i8* %1) nounwind call void @llvm.lifetime.start.p0i8(i64 16, i8* %1) nounwind
call void @llvm.memcpy.p0i8.p0i8.i32(i8* %1, i8* %0, i32 16, i32 4, i1 false) call void @llvm.memcpy.p0i8.p0i8.i32(i8* %1, i8* %0, i32 16, i32 4, i1 false)
call void @llvm.lifetime.end(i64 16, i8* %1) nounwind call void @llvm.lifetime.end.p0i8(i64 16, i8* %1) nounwind
%2 = bitcast %insert_iterator* %var2 to i8* %2 = bitcast %insert_iterator* %var2 to i8*
call void @llvm.lifetime.start(i64 20, i8* %2) nounwind call void @llvm.lifetime.start.p0i8(i64 20, i8* %2) nounwind
ret i32 0 ret i32 0
} }
declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32, i1) nounwind declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32, i1) nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) nounwind declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) nounwind declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) nounwind

test/CodeGen/Thumb/stack_guard_remat.ll

Show All 21 Lines
;DYNAMIC-NO-PIC: [[LABEL0]]: ;DYNAMIC-NO-PIC: [[LABEL0]]:
;DYNAMIC-NO-PIC-NEXT: .long L___stack_chk_guard$non_lazy_ptr ;DYNAMIC-NO-PIC-NEXT: .long L___stack_chk_guard$non_lazy_ptr
; Function Attrs: nounwind ssp ; Function Attrs: nounwind ssp
define i32 @test_stack_guard_remat() #0 { define i32 @test_stack_guard_remat() #0 {
%a1 = alloca [256 x i32], align 4 %a1 = alloca [256 x i32], align 4
%1 = bitcast [256 x i32]* %a1 to i8* %1 = bitcast [256 x i32]* %a1 to i8*
call void @llvm.lifetime.start(i64 1024, i8* %1) call void @llvm.lifetime.start.p0i8(i64 1024, i8* %1)
%2 = getelementptr inbounds [256 x i32], [256 x i32]* %a1, i32 0, i32 0 %2 = getelementptr inbounds [256 x i32], [256 x i32]* %a1, i32 0, i32 0
call void @foo3(i32* %2) #3 call void @foo3(i32* %2) #3
call void asm sideeffect "foo2", "~{r0},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{sp},~{lr}"() call void asm sideeffect "foo2", "~{r0},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{sp},~{lr}"()
call void @llvm.lifetime.end(i64 1024, i8* %1) call void @llvm.lifetime.end.p0i8(i64 1024, i8* %1)
ret i32 0 ret i32 0
} }
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @foo3(i32*) declare void @foo3(i32*)
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
attributes #0 = { nounwind ssp "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #0 = { nounwind ssp "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }

test/CodeGen/Thumb2/ifcvt-rescan-bug-2016-08-22.ll

; RUN: llc -O2 -o - %s | FileCheck %s ; RUN: llc -O2 -o - %s | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
target triple = "thumbv7-unknown-linux-gnueabihf" target triple = "thumbv7-unknown-linux-gnueabihf"
; Function Attrs: argmemonly nounwind ; Function Attrs: argmemonly nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) #0 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #0
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @_ZNSaIcEC2Ev() unnamed_addr #0 align 2 declare void @_ZNSaIcEC2Ev() unnamed_addr #0 align 2
declare void @_ZNSsC1EPKcRKSaIcE() unnamed_addr #0 declare void @_ZNSsC1EPKcRKSaIcE() unnamed_addr #0
; It isn't valid to If-Convert the following function, even though the calls ; It isn't valid to If-Convert the following function, even though the calls
; are in common. The calls clobber the predicate info. ; are in common. The calls clobber the predicate info.
; CHECK: cbnz r{{[0-9]+}}, .LBB0_2 ; CHECK: cbnz r{{[0-9]+}}, .LBB0_2
; CHECK: BB#1 ; CHECK: BB#1
; CHECK: .LBB0_2 ; CHECK: .LBB0_2
; Function Attrs: nounwind ; Function Attrs: nounwind
define hidden void @_ZN4llvm14DOTGraphTraitsIPNS_13ScheduleDAGMIEE17getEdgeAttributesEPKNS_5SUnitENS_13SUnitIteratorEPKNS_11ScheduleDAGE() #0 align 2 { define hidden void @_ZN4llvm14DOTGraphTraitsIPNS_13ScheduleDAGMIEE17getEdgeAttributesEPKNS_5SUnitENS_13SUnitIteratorEPKNS_11ScheduleDAGE() #0 align 2 {
br i1 undef, label %1, label %2 br i1 undef, label %1, label %2
; <label>:1: ; preds = %0 ; <label>:1: ; preds = %0
call void @_ZNSaIcEC2Ev() #0 call void @_ZNSaIcEC2Ev() #0
call void @_ZNSsC1EPKcRKSaIcE() call void @_ZNSsC1EPKcRKSaIcE()
br label %3 br label %3
; <label>:2: ; preds = %0 ; <label>:2: ; preds = %0
call void @llvm.lifetime.start(i64 1, i8* undef) #0 call void @llvm.lifetime.start.p0i8(i64 1, i8* undef) #0
call void @_ZNSaIcEC2Ev() #0 call void @_ZNSaIcEC2Ev() #0
br label %3 br label %3
; <label>:3: ; preds = %2, %1 ; <label>:3: ; preds = %2, %1
ret void ret void
} }
attributes #0 = { nounwind } attributes #0 = { nounwind }

test/CodeGen/Thumb2/stack_guard_remat.ll

Show All 18 Lines
;DYNAMIC-NO-PIC: movw [[R0:r[0-9]+]], :lower16:L___stack_chk_guard$non_lazy_ptr ;DYNAMIC-NO-PIC: movw [[R0:r[0-9]+]], :lower16:L___stack_chk_guard$non_lazy_ptr
;DYNAMIC-NO-PIC: movt [[R0]], :upper16:L___stack_chk_guard$non_lazy_ptr ;DYNAMIC-NO-PIC: movt [[R0]], :upper16:L___stack_chk_guard$non_lazy_ptr
;DYNAMIC-NO-PIC: ldr {{r[0-9]+}}, {{\[}}[[R0]]{{\]}} ;DYNAMIC-NO-PIC: ldr {{r[0-9]+}}, {{\[}}[[R0]]{{\]}}
; Function Attrs: nounwind ssp ; Function Attrs: nounwind ssp
define i32 @test_stack_guard_remat() #0 { define i32 @test_stack_guard_remat() #0 {
%a1 = alloca [256 x i32], align 4 %a1 = alloca [256 x i32], align 4
%1 = bitcast [256 x i32]* %a1 to i8* %1 = bitcast [256 x i32]* %a1 to i8*
call void @llvm.lifetime.start(i64 1024, i8* %1) call void @llvm.lifetime.start.p0i8(i64 1024, i8* %1)
%2 = getelementptr inbounds [256 x i32], [256 x i32]* %a1, i32 0, i32 0 %2 = getelementptr inbounds [256 x i32], [256 x i32]* %a1, i32 0, i32 0
call void @foo3(i32* %2) #3 call void @foo3(i32* %2) #3
call void asm sideeffect "foo2", "~{r0},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{sp},~{lr}"() call void asm sideeffect "foo2", "~{r0},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{sp},~{lr}"()
call void @llvm.lifetime.end(i64 1024, i8* %1) call void @llvm.lifetime.end.p0i8(i64 1024, i8* %1)
ret i32 0 ret i32 0
} }
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @foo3(i32*) declare void @foo3(i32*)
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
attributes #0 = { nounwind ssp "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #0 = { nounwind ssp "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }

test/CodeGen/X86/StackColoring-dbg.ll

Show All 9 Lines
define void @foo() nounwind uwtable ssp { define void @foo() nounwind uwtable ssp {
entry: entry:
%x.i = alloca i8, align 1 %x.i = alloca i8, align 1
%y.i = alloca [256 x i8], align 16 %y.i = alloca [256 x i8], align 16
%0 = getelementptr inbounds [256 x i8], [256 x i8]* %y.i, i64 0, i64 0 %0 = getelementptr inbounds [256 x i8], [256 x i8]* %y.i, i64 0, i64 0
br label %for.body br label %for.body
for.body: for.body:
call void @llvm.lifetime.end(i64 -1, i8* %0) nounwind call void @llvm.lifetime.end.p0i8(i64 -1, i8* %0) nounwind
call void @llvm.lifetime.start(i64 -1, i8* %x.i) nounwind call void @llvm.lifetime.start.p0i8(i64 -1, i8* %x.i) nounwind
call void @llvm.dbg.declare(metadata i8* %x.i, metadata !22, metadata !DIExpression()) nounwind, !dbg !DILocation(scope: !2) call void @llvm.dbg.declare(metadata i8* %x.i, metadata !22, metadata !DIExpression()) nounwind, !dbg !DILocation(scope: !2)
br label %for.body br label %for.body
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) nounwind declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) nounwind declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) nounwind
!llvm.dbg.cu = !{!0} !llvm.dbg.cu = !{!0}
!llvm.module.flags = !{!23} !llvm.module.flags = !{!23}
!0 = distinct !DICompileUnit(language: DW_LANG_C89, producer: "clang", isOptimized: true, emissionKind: FullDebug, file: !1, enums: !{}, retainedTypes: !{}) !0 = distinct !DICompileUnit(language: DW_LANG_C89, producer: "clang", isOptimized: true, emissionKind: FullDebug, file: !1, enums: !{}, retainedTypes: !{})
!1 = !DIFile(filename: "t.c", directory: "") !1 = !DIFile(filename: "t.c", directory: "")
!16 = !DIBasicType(tag: DW_TAG_base_type, name: "char", size: 8, align: 8, encoding: DW_ATE_signed_char) !16 = !DIBasicType(tag: DW_TAG_base_type, name: "char", size: 8, align: 8, encoding: DW_ATE_signed_char)
!2 = distinct !DISubprogram(unit: !0) !2 = distinct !DISubprogram(unit: !0)
!22 = !DILocalVariable(name: "x", line: 16, scope: !2, file: !1, type: !16) !22 = !DILocalVariable(name: "x", line: 16, scope: !2, file: !1, type: !16)
!23 = !{i32 1, !"Debug Info Version", i32 3} !23 = !{i32 1, !"Debug Info Version", i32 3}

test/CodeGen/X86/StackColoring.ll

Show All 9 Lines
;NOCOLOR: subq $272, %rsp ;NOCOLOR: subq $272, %rsp
define i32 @myCall_w2(i32 %in) { define i32 @myCall_w2(i32 %in) {
entry: entry:
%a = alloca [17 x i8*], align 8 %a = alloca [17 x i8*], align 8
%a2 = alloca [16 x i8*], align 8 %a2 = alloca [16 x i8*], align 8
%b = bitcast [17 x i8*]* %a to i8* %b = bitcast [17 x i8*]* %a to i8*
%b2 = bitcast [16 x i8*]* %a2 to i8* %b2 = bitcast [16 x i8*]* %a2 to i8*
call void @llvm.lifetime.start(i64 -1, i8* %b) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %b)
%t1 = call i32 @foo(i32 %in, i8* %b) %t1 = call i32 @foo(i32 %in, i8* %b)
%t2 = call i32 @foo(i32 %in, i8* %b) %t2 = call i32 @foo(i32 %in, i8* %b)
call void @llvm.lifetime.end(i64 -1, i8* %b) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %b)
call void @llvm.lifetime.start(i64 -1, i8* %b2) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %b2)
%t3 = call i32 @foo(i32 %in, i8* %b2) %t3 = call i32 @foo(i32 %in, i8* %b2)
%t4 = call i32 @foo(i32 %in, i8* %b2) %t4 = call i32 @foo(i32 %in, i8* %b2)
call void @llvm.lifetime.end(i64 -1, i8* %b2) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %b2)
%t5 = add i32 %t1, %t2 %t5 = add i32 %t1, %t2
%t6 = add i32 %t3, %t4 %t6 = add i32 %t3, %t4
%t7 = add i32 %t5, %t6 %t7 = add i32 %t5, %t6
ret i32 %t7 ret i32 %t7
} }
;CHECK-LABEL: myCall2_no_merge ;CHECK-LABEL: myCall2_no_merge
;YESCOLOR: subq $272, %rsp ;YESCOLOR: subq $272, %rsp
;NOCOLOR: subq $272, %rsp ;NOCOLOR: subq $272, %rsp
define i32 @myCall2_no_merge(i32 %in, i1 %d) { define i32 @myCall2_no_merge(i32 %in, i1 %d) {
entry: entry:
%a = alloca [17 x i8*], align 8 %a = alloca [17 x i8*], align 8
%a2 = alloca [16 x i8*], align 8 %a2 = alloca [16 x i8*], align 8
%b = bitcast [17 x i8*]* %a to i8* %b = bitcast [17 x i8*]* %a to i8*
%b2 = bitcast [16 x i8*]* %a2 to i8* %b2 = bitcast [16 x i8*]* %a2 to i8*
call void @llvm.lifetime.start(i64 -1, i8* %b) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %b)
%t1 = call i32 @foo(i32 %in, i8* %b) %t1 = call i32 @foo(i32 %in, i8* %b)
%t2 = call i32 @foo(i32 %in, i8* %b) %t2 = call i32 @foo(i32 %in, i8* %b)
br i1 %d, label %bb2, label %bb3 br i1 %d, label %bb2, label %bb3
bb2: bb2:
call void @llvm.lifetime.start(i64 -1, i8* %b2) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %b2)
%t3 = call i32 @foo(i32 %in, i8* %b2) %t3 = call i32 @foo(i32 %in, i8* %b2)
%t4 = call i32 @foo(i32 %in, i8* %b2) %t4 = call i32 @foo(i32 %in, i8* %b2)
call void @llvm.lifetime.end(i64 -1, i8* %b2) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %b2)
%t5 = add i32 %t1, %t2 %t5 = add i32 %t1, %t2
%t6 = add i32 %t3, %t4 %t6 = add i32 %t3, %t4
%t7 = add i32 %t5, %t6 %t7 = add i32 %t5, %t6
call void @llvm.lifetime.end(i64 -1, i8* %b) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %b)
ret i32 %t7 ret i32 %t7
bb3: bb3:
call void @llvm.lifetime.end(i64 -1, i8* %b) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %b)
ret i32 0 ret i32 0
} }
;CHECK-LABEL: myCall2_w2 ;CHECK-LABEL: myCall2_w2
;YESCOLOR: subq $144, %rsp ;YESCOLOR: subq $144, %rsp
;NOCOLOR: subq $272, %rsp ;NOCOLOR: subq $272, %rsp
define i32 @myCall2_w2(i32 %in, i1 %d) { define i32 @myCall2_w2(i32 %in, i1 %d) {
entry: entry:
%a = alloca [17 x i8*], align 8 %a = alloca [17 x i8*], align 8
%a2 = alloca [16 x i8*], align 8 %a2 = alloca [16 x i8*], align 8
%b = bitcast [17 x i8*]* %a to i8* %b = bitcast [17 x i8*]* %a to i8*
%b2 = bitcast [16 x i8*]* %a2 to i8* %b2 = bitcast [16 x i8*]* %a2 to i8*
call void @llvm.lifetime.start(i64 -1, i8* %b) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %b)
%t1 = call i32 @foo(i32 %in, i8* %b) %t1 = call i32 @foo(i32 %in, i8* %b)
%t2 = call i32 @foo(i32 %in, i8* %b) %t2 = call i32 @foo(i32 %in, i8* %b)
call void @llvm.lifetime.end(i64 -1, i8* %b) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %b)
br i1 %d, label %bb2, label %bb3 br i1 %d, label %bb2, label %bb3
bb2: bb2:
call void @llvm.lifetime.start(i64 -1, i8* %b2) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %b2)
%t3 = call i32 @foo(i32 %in, i8* %b2) %t3 = call i32 @foo(i32 %in, i8* %b2)
%t4 = call i32 @foo(i32 %in, i8* %b2) %t4 = call i32 @foo(i32 %in, i8* %b2)
call void @llvm.lifetime.end(i64 -1, i8* %b2) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %b2)
%t5 = add i32 %t1, %t2 %t5 = add i32 %t1, %t2
%t6 = add i32 %t3, %t4 %t6 = add i32 %t3, %t4
%t7 = add i32 %t5, %t6 %t7 = add i32 %t5, %t6
ret i32 %t7 ret i32 %t7
bb3: bb3:
ret i32 0 ret i32 0
} }
;CHECK-LABEL: myCall_w4: ;CHECK-LABEL: myCall_w4:
;YESCOLOR: subq $120, %rsp ;YESCOLOR: subq $120, %rsp
;NOFIRSTUSE: subq $200, %rsp ;NOFIRSTUSE: subq $200, %rsp
;NOCOLOR: subq $408, %rsp ;NOCOLOR: subq $408, %rsp
define i32 @myCall_w4(i32 %in) { define i32 @myCall_w4(i32 %in) {
entry: entry:
%a1 = alloca [14 x i8*], align 8 %a1 = alloca [14 x i8*], align 8
%a2 = alloca [13 x i8*], align 8 %a2 = alloca [13 x i8*], align 8
%a3 = alloca [12 x i8*], align 8 %a3 = alloca [12 x i8*], align 8
%a4 = alloca [11 x i8*], align 8 %a4 = alloca [11 x i8*], align 8
%b1 = bitcast [14 x i8*]* %a1 to i8* %b1 = bitcast [14 x i8*]* %a1 to i8*
%b2 = bitcast [13 x i8*]* %a2 to i8* %b2 = bitcast [13 x i8*]* %a2 to i8*
%b3 = bitcast [12 x i8*]* %a3 to i8* %b3 = bitcast [12 x i8*]* %a3 to i8*
%b4 = bitcast [11 x i8*]* %a4 to i8* %b4 = bitcast [11 x i8*]* %a4 to i8*
call void @llvm.lifetime.start(i64 -1, i8* %b4) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %b4)
call void @llvm.lifetime.start(i64 -1, i8* %b1) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %b1)
%t1 = call i32 @foo(i32 %in, i8* %b1) %t1 = call i32 @foo(i32 %in, i8* %b1)
%t2 = call i32 @foo(i32 %in, i8* %b1) %t2 = call i32 @foo(i32 %in, i8* %b1)
call void @llvm.lifetime.end(i64 -1, i8* %b1) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %b1)
call void @llvm.lifetime.start(i64 -1, i8* %b2) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %b2)
%t9 = call i32 @foo(i32 %in, i8* %b2) %t9 = call i32 @foo(i32 %in, i8* %b2)
%t8 = call i32 @foo(i32 %in, i8* %b2) %t8 = call i32 @foo(i32 %in, i8* %b2)
call void @llvm.lifetime.end(i64 -1, i8* %b2) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %b2)
call void @llvm.lifetime.start(i64 -1, i8* %b3) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %b3)
%t3 = call i32 @foo(i32 %in, i8* %b3) %t3 = call i32 @foo(i32 %in, i8* %b3)
%t4 = call i32 @foo(i32 %in, i8* %b3) %t4 = call i32 @foo(i32 %in, i8* %b3)
call void @llvm.lifetime.end(i64 -1, i8* %b3) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %b3)
%t11 = call i32 @foo(i32 %in, i8* %b4) %t11 = call i32 @foo(i32 %in, i8* %b4)
call void @llvm.lifetime.end(i64 -1, i8* %b4) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %b4)
%t5 = add i32 %t1, %t2 %t5 = add i32 %t1, %t2
%t6 = add i32 %t3, %t4 %t6 = add i32 %t3, %t4
%t7 = add i32 %t5, %t6 %t7 = add i32 %t5, %t6
ret i32 %t7 ret i32 %t7
} }
;CHECK-LABEL: myCall2_w4: ;CHECK-LABEL: myCall2_w4:
;YESCOLOR: subq $112, %rsp ;YESCOLOR: subq $112, %rsp
;NOCOLOR: subq $400, %rsp ;NOCOLOR: subq $400, %rsp
define i32 @myCall2_w4(i32 %in) { define i32 @myCall2_w4(i32 %in) {
entry: entry:
%a1 = alloca [14 x i8*], align 8 %a1 = alloca [14 x i8*], align 8
%a2 = alloca [13 x i8*], align 8 %a2 = alloca [13 x i8*], align 8
%a3 = alloca [12 x i8*], align 8 %a3 = alloca [12 x i8*], align 8
%a4 = alloca [11 x i8*], align 8 %a4 = alloca [11 x i8*], align 8
%b1 = bitcast [14 x i8*]* %a1 to i8* %b1 = bitcast [14 x i8*]* %a1 to i8*
%b2 = bitcast [13 x i8*]* %a2 to i8* %b2 = bitcast [13 x i8*]* %a2 to i8*
%b3 = bitcast [12 x i8*]* %a3 to i8* %b3 = bitcast [12 x i8*]* %a3 to i8*
%b4 = bitcast [11 x i8*]* %a4 to i8* %b4 = bitcast [11 x i8*]* %a4 to i8*
call void @llvm.lifetime.start(i64 -1, i8* %b1) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %b1)
%t1 = call i32 @foo(i32 %in, i8* %b1) %t1 = call i32 @foo(i32 %in, i8* %b1)
%t2 = call i32 @foo(i32 %in, i8* %b1) %t2 = call i32 @foo(i32 %in, i8* %b1)
call void @llvm.lifetime.end(i64 -1, i8* %b1) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %b1)
call void @llvm.lifetime.start(i64 -1, i8* %b2) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %b2)
%t9 = call i32 @foo(i32 %in, i8* %b2) %t9 = call i32 @foo(i32 %in, i8* %b2)
%t8 = call i32 @foo(i32 %in, i8* %b2) %t8 = call i32 @foo(i32 %in, i8* %b2)
call void @llvm.lifetime.end(i64 -1, i8* %b2) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %b2)
call void @llvm.lifetime.start(i64 -1, i8* %b3) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %b3)
%t3 = call i32 @foo(i32 %in, i8* %b3) %t3 = call i32 @foo(i32 %in, i8* %b3)
%t4 = call i32 @foo(i32 %in, i8* %b3) %t4 = call i32 @foo(i32 %in, i8* %b3)
call void @llvm.lifetime.end(i64 -1, i8* %b3) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %b3)
br i1 undef, label %bb2, label %bb3 br i1 undef, label %bb2, label %bb3
bb2: bb2:
call void @llvm.lifetime.start(i64 -1, i8* %b4) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %b4)
%t11 = call i32 @foo(i32 %in, i8* %b4) %t11 = call i32 @foo(i32 %in, i8* %b4)
call void @llvm.lifetime.end(i64 -1, i8* %b4) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %b4)
%t5 = add i32 %t1, %t2 %t5 = add i32 %t1, %t2
%t6 = add i32 %t3, %t4 %t6 = add i32 %t3, %t4
%t7 = add i32 %t5, %t6 %t7 = add i32 %t5, %t6
ret i32 %t7 ret i32 %t7
bb3: bb3:
ret i32 0 ret i32 0
} }
;CHECK-LABEL: myCall2_noend: ;CHECK-LABEL: myCall2_noend:
;YESCOLOR: subq $144, %rsp ;YESCOLOR: subq $144, %rsp
;NOCOLOR: subq $272, %rsp ;NOCOLOR: subq $272, %rsp
define i32 @myCall2_noend(i32 %in, i1 %d) { define i32 @myCall2_noend(i32 %in, i1 %d) {
entry: entry:
%a = alloca [17 x i8*], align 8 %a = alloca [17 x i8*], align 8
%a2 = alloca [16 x i8*], align 8 %a2 = alloca [16 x i8*], align 8
%b = bitcast [17 x i8*]* %a to i8* %b = bitcast [17 x i8*]* %a to i8*
%b2 = bitcast [16 x i8*]* %a2 to i8* %b2 = bitcast [16 x i8*]* %a2 to i8*
call void @llvm.lifetime.start(i64 -1, i8* %b) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %b)
%t1 = call i32 @foo(i32 %in, i8* %b) %t1 = call i32 @foo(i32 %in, i8* %b)
%t2 = call i32 @foo(i32 %in, i8* %b) %t2 = call i32 @foo(i32 %in, i8* %b)
call void @llvm.lifetime.end(i64 -1, i8* %b) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %b)
br i1 %d, label %bb2, label %bb3 br i1 %d, label %bb2, label %bb3
bb2: bb2:
call void @llvm.lifetime.start(i64 -1, i8* %b2) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %b2)
%t3 = call i32 @foo(i32 %in, i8* %b2) %t3 = call i32 @foo(i32 %in, i8* %b2)
%t4 = call i32 @foo(i32 %in, i8* %b2) %t4 = call i32 @foo(i32 %in, i8* %b2)
%t5 = add i32 %t1, %t2 %t5 = add i32 %t1, %t2
%t6 = add i32 %t3, %t4 %t6 = add i32 %t3, %t4
%t7 = add i32 %t5, %t6 %t7 = add i32 %t5, %t6
ret i32 %t7 ret i32 %t7
bb3: bb3:
ret i32 0 ret i32 0
} }
;CHECK-LABEL: myCall2_noend2: ;CHECK-LABEL: myCall2_noend2:
;YESCOLOR: subq $144, %rsp ;YESCOLOR: subq $144, %rsp
;NOCOLOR: subq $272, %rsp ;NOCOLOR: subq $272, %rsp
define i32 @myCall2_noend2(i32 %in, i1 %d) { define i32 @myCall2_noend2(i32 %in, i1 %d) {
entry: entry:
%a = alloca [17 x i8*], align 8 %a = alloca [17 x i8*], align 8
%a2 = alloca [16 x i8*], align 8 %a2 = alloca [16 x i8*], align 8
%b = bitcast [17 x i8*]* %a to i8* %b = bitcast [17 x i8*]* %a to i8*
%b2 = bitcast [16 x i8*]* %a2 to i8* %b2 = bitcast [16 x i8*]* %a2 to i8*
call void @llvm.lifetime.start(i64 -1, i8* %b) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %b)
%t1 = call i32 @foo(i32 %in, i8* %b) %t1 = call i32 @foo(i32 %in, i8* %b)
%t2 = call i32 @foo(i32 %in, i8* %b) %t2 = call i32 @foo(i32 %in, i8* %b)
br i1 %d, label %bb2, label %bb3 br i1 %d, label %bb2, label %bb3
bb2: bb2:
call void @llvm.lifetime.end(i64 -1, i8* %b) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %b)
call void @llvm.lifetime.start(i64 -1, i8* %b2) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %b2)
%t3 = call i32 @foo(i32 %in, i8* %b2) %t3 = call i32 @foo(i32 %in, i8* %b2)
%t4 = call i32 @foo(i32 %in, i8* %b2) %t4 = call i32 @foo(i32 %in, i8* %b2)
%t5 = add i32 %t1, %t2 %t5 = add i32 %t1, %t2
%t6 = add i32 %t3, %t4 %t6 = add i32 %t3, %t4
%t7 = add i32 %t5, %t6 %t7 = add i32 %t5, %t6
ret i32 %t7 ret i32 %t7
bb3: bb3:
ret i32 0 ret i32 0
} }
;CHECK-LABEL: myCall2_nostart: ;CHECK-LABEL: myCall2_nostart:
;YESCOLOR: subq $272, %rsp ;YESCOLOR: subq $272, %rsp
;NOCOLOR: subq $272, %rsp ;NOCOLOR: subq $272, %rsp
define i32 @myCall2_nostart(i32 %in, i1 %d) { define i32 @myCall2_nostart(i32 %in, i1 %d) {
entry: entry:
%a = alloca [17 x i8*], align 8 %a = alloca [17 x i8*], align 8
%a2 = alloca [16 x i8*], align 8 %a2 = alloca [16 x i8*], align 8
%b = bitcast [17 x i8*]* %a to i8* %b = bitcast [17 x i8*]* %a to i8*
%b2 = bitcast [16 x i8*]* %a2 to i8* %b2 = bitcast [16 x i8*]* %a2 to i8*
%t1 = call i32 @foo(i32 %in, i8* %b) %t1 = call i32 @foo(i32 %in, i8* %b)
%t2 = call i32 @foo(i32 %in, i8* %b) %t2 = call i32 @foo(i32 %in, i8* %b)
call void @llvm.lifetime.end(i64 -1, i8* %b) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %b)
br i1 %d, label %bb2, label %bb3 br i1 %d, label %bb2, label %bb3
bb2: bb2:
call void @llvm.lifetime.start(i64 -1, i8* %b2) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %b2)
%t3 = call i32 @foo(i32 %in, i8* %b2) %t3 = call i32 @foo(i32 %in, i8* %b2)
%t4 = call i32 @foo(i32 %in, i8* %b2) %t4 = call i32 @foo(i32 %in, i8* %b2)
%t5 = add i32 %t1, %t2 %t5 = add i32 %t1, %t2
%t6 = add i32 %t3, %t4 %t6 = add i32 %t3, %t4
%t7 = add i32 %t5, %t6 %t7 = add i32 %t5, %t6
ret i32 %t7 ret i32 %t7
bb3: bb3:
ret i32 0 ret i32 0
} }
; Adopt the test from Transforms/Inline/array_merge.ll' ; Adopt the test from Transforms/Inline/array_merge.ll'
;CHECK-LABEL: array_merge: ;CHECK-LABEL: array_merge:
;YESCOLOR: subq $808, %rsp ;YESCOLOR: subq $808, %rsp
;NOCOLOR: subq $1608, %rsp ;NOCOLOR: subq $1608, %rsp
define void @array_merge() nounwind ssp { define void @array_merge() nounwind ssp {
entry: entry:
%A.i1 = alloca [100 x i32], align 4 %A.i1 = alloca [100 x i32], align 4
%B.i2 = alloca [100 x i32], align 4 %B.i2 = alloca [100 x i32], align 4
%A.i = alloca [100 x i32], align 4 %A.i = alloca [100 x i32], align 4
%B.i = alloca [100 x i32], align 4 %B.i = alloca [100 x i32], align 4
%0 = bitcast [100 x i32]* %A.i to i8* %0 = bitcast [100 x i32]* %A.i to i8*
call void @llvm.lifetime.start(i64 -1, i8* %0) nounwind call void @llvm.lifetime.start.p0i8(i64 -1, i8* %0) nounwind
%1 = bitcast [100 x i32]* %B.i to i8* %1 = bitcast [100 x i32]* %B.i to i8*
call void @llvm.lifetime.start(i64 -1, i8* %1) nounwind call void @llvm.lifetime.start.p0i8(i64 -1, i8* %1) nounwind
call void @bar([100 x i32]* %A.i, [100 x i32]* %B.i) nounwind call void @bar([100 x i32]* %A.i, [100 x i32]* %B.i) nounwind
call void @llvm.lifetime.end(i64 -1, i8* %0) nounwind call void @llvm.lifetime.end.p0i8(i64 -1, i8* %0) nounwind
call void @llvm.lifetime.end(i64 -1, i8* %1) nounwind call void @llvm.lifetime.end.p0i8(i64 -1, i8* %1) nounwind
%2 = bitcast [100 x i32]* %A.i1 to i8* %2 = bitcast [100 x i32]* %A.i1 to i8*
call void @llvm.lifetime.start(i64 -1, i8* %2) nounwind call void @llvm.lifetime.start.p0i8(i64 -1, i8* %2) nounwind
%3 = bitcast [100 x i32]* %B.i2 to i8* %3 = bitcast [100 x i32]* %B.i2 to i8*
call void @llvm.lifetime.start(i64 -1, i8* %3) nounwind call void @llvm.lifetime.start.p0i8(i64 -1, i8* %3) nounwind
call void @bar([100 x i32]* %A.i1, [100 x i32]* %B.i2) nounwind call void @bar([100 x i32]* %A.i1, [100 x i32]* %B.i2) nounwind
call void @llvm.lifetime.end(i64 -1, i8* %2) nounwind call void @llvm.lifetime.end.p0i8(i64 -1, i8* %2) nounwind
call void @llvm.lifetime.end(i64 -1, i8* %3) nounwind call void @llvm.lifetime.end.p0i8(i64 -1, i8* %3) nounwind
ret void ret void
} }
;CHECK-LABEL: func_phi_lifetime: ;CHECK-LABEL: func_phi_lifetime:
;YESCOLOR: subq $272, %rsp ;YESCOLOR: subq $272, %rsp
;NOCOLOR: subq $272, %rsp ;NOCOLOR: subq $272, %rsp
define i32 @func_phi_lifetime(i32 %in, i1 %d) { define i32 @func_phi_lifetime(i32 %in, i1 %d) {
entry: entry:
%a = alloca [17 x i8*], align 8 %a = alloca [17 x i8*], align 8
%a2 = alloca [16 x i8*], align 8 %a2 = alloca [16 x i8*], align 8
%b = bitcast [17 x i8*]* %a to i8* %b = bitcast [17 x i8*]* %a to i8*
%b2 = bitcast [16 x i8*]* %a2 to i8* %b2 = bitcast [16 x i8*]* %a2 to i8*
%t1 = call i32 @foo(i32 %in, i8* %b) %t1 = call i32 @foo(i32 %in, i8* %b)
%t2 = call i32 @foo(i32 %in, i8* %b) %t2 = call i32 @foo(i32 %in, i8* %b)
call void @llvm.lifetime.end(i64 -1, i8* %b) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %b)
br i1 %d, label %bb0, label %bb1 br i1 %d, label %bb0, label %bb1
bb0: bb0:
%I1 = bitcast [17 x i8*]* %a to i8* %I1 = bitcast [17 x i8*]* %a to i8*
br label %bb2 br label %bb2
bb1: bb1:
%I2 = bitcast [16 x i8*]* %a2 to i8* %I2 = bitcast [16 x i8*]* %a2 to i8*
br label %bb2 br label %bb2
bb2: bb2:
%split = phi i8* [ %I1, %bb0 ], [ %I2, %bb1 ] %split = phi i8* [ %I1, %bb0 ], [ %I2, %bb1 ]
call void @llvm.lifetime.start(i64 -1, i8* %split) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %split)
%t3 = call i32 @foo(i32 %in, i8* %b2) %t3 = call i32 @foo(i32 %in, i8* %b2)
%t4 = call i32 @foo(i32 %in, i8* %b2) %t4 = call i32 @foo(i32 %in, i8* %b2)
%t5 = add i32 %t1, %t2 %t5 = add i32 %t1, %t2
%t6 = add i32 %t3, %t4 %t6 = add i32 %t3, %t4
%t7 = add i32 %t5, %t6 %t7 = add i32 %t5, %t6
call void @llvm.lifetime.end(i64 -1, i8* %split) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %split)
ret i32 %t7 ret i32 %t7
bb3: bb3:
ret i32 0 ret i32 0
} }
;CHECK-LABEL: multi_region_bb: ;CHECK-LABEL: multi_region_bb:
;YESCOLOR: subq $272, %rsp ;YESCOLOR: subq $272, %rsp
;NOCOLOR: subq $272, %rsp ;NOCOLOR: subq $272, %rsp
define void @multi_region_bb() nounwind ssp { define void @multi_region_bb() nounwind ssp {
entry: entry:
%A.i1 = alloca [100 x i32], align 4 %A.i1 = alloca [100 x i32], align 4
%B.i2 = alloca [100 x i32], align 4 %B.i2 = alloca [100 x i32], align 4
%A.i = alloca [100 x i32], align 4 %A.i = alloca [100 x i32], align 4
%B.i = alloca [100 x i32], align 4 %B.i = alloca [100 x i32], align 4
%0 = bitcast [100 x i32]* %A.i to i8* %0 = bitcast [100 x i32]* %A.i to i8*
call void @llvm.lifetime.start(i64 -1, i8* %0) nounwind ; <---- start #1 call void @llvm.lifetime.start.p0i8(i64 -1, i8* %0) nounwind ; <---- start #1
%1 = bitcast [100 x i32]* %B.i to i8* %1 = bitcast [100 x i32]* %B.i to i8*
call void @llvm.lifetime.start(i64 -1, i8* %1) nounwind call void @llvm.lifetime.start.p0i8(i64 -1, i8* %1) nounwind
call void @bar([100 x i32]* %A.i, [100 x i32]* %B.i) nounwind call void @bar([100 x i32]* %A.i, [100 x i32]* %B.i) nounwind
call void @llvm.lifetime.end(i64 -1, i8* %0) nounwind call void @llvm.lifetime.end.p0i8(i64 -1, i8* %0) nounwind
call void @llvm.lifetime.end(i64 -1, i8* %1) nounwind call void @llvm.lifetime.end.p0i8(i64 -1, i8* %1) nounwind
%2 = bitcast [100 x i32]* %A.i1 to i8* %2 = bitcast [100 x i32]* %A.i1 to i8*
call void @llvm.lifetime.start(i64 -1, i8* %2) nounwind call void @llvm.lifetime.start.p0i8(i64 -1, i8* %2) nounwind
%3 = bitcast [100 x i32]* %B.i2 to i8* %3 = bitcast [100 x i32]* %B.i2 to i8*
call void @llvm.lifetime.start(i64 -1, i8* %3) nounwind call void @llvm.lifetime.start.p0i8(i64 -1, i8* %3) nounwind
call void @llvm.lifetime.start(i64 -1, i8* %0) nounwind ; <---- start #2 call void @llvm.lifetime.start.p0i8(i64 -1, i8* %0) nounwind ; <---- start #2
call void @bar([100 x i32]* %A.i1, [100 x i32]* %B.i2) nounwind call void @bar([100 x i32]* %A.i1, [100 x i32]* %B.i2) nounwind
call void @llvm.lifetime.end(i64 -1, i8* %2) nounwind call void @llvm.lifetime.end.p0i8(i64 -1, i8* %2) nounwind
call void @llvm.lifetime.end(i64 -1, i8* %0) nounwind call void @llvm.lifetime.end.p0i8(i64 -1, i8* %0) nounwind
call void @llvm.lifetime.end(i64 -1, i8* %3) nounwind call void @llvm.lifetime.end.p0i8(i64 -1, i8* %3) nounwind
ret void ret void
} }
define i32 @myCall_end_before_begin(i32 %in, i1 %d) { define i32 @myCall_end_before_begin(i32 %in, i1 %d) {
entry: entry:
%a = alloca [17 x i8*], align 8 %a = alloca [17 x i8*], align 8
%a2 = alloca [16 x i8*], align 8 %a2 = alloca [16 x i8*], align 8
%b = bitcast [17 x i8*]* %a to i8* %b = bitcast [17 x i8*]* %a to i8*
%b2 = bitcast [16 x i8*]* %a2 to i8* %b2 = bitcast [16 x i8*]* %a2 to i8*
%t1 = call i32 @foo(i32 %in, i8* %b) %t1 = call i32 @foo(i32 %in, i8* %b)
%t2 = call i32 @foo(i32 %in, i8* %b) %t2 = call i32 @foo(i32 %in, i8* %b)
call void @llvm.lifetime.end(i64 -1, i8* %b) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %b)
call void @llvm.lifetime.start(i64 -1, i8* %b) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %b)
br i1 %d, label %bb2, label %bb3 br i1 %d, label %bb2, label %bb3
bb2: bb2:
call void @llvm.lifetime.start(i64 -1, i8* %b2) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %b2)
%t3 = call i32 @foo(i32 %in, i8* %b2) %t3 = call i32 @foo(i32 %in, i8* %b2)
%t4 = call i32 @foo(i32 %in, i8* %b2) %t4 = call i32 @foo(i32 %in, i8* %b2)
%t5 = add i32 %t1, %t2 %t5 = add i32 %t1, %t2
%t6 = add i32 %t3, %t4 %t6 = add i32 %t3, %t4
%t7 = add i32 %t5, %t6 %t7 = add i32 %t5, %t6
ret i32 %t7 ret i32 %t7
bb3: bb3:
ret i32 0 ret i32 0
} }
; Regression test for PR15707. %buf1 and %buf2 should not be merged ; Regression test for PR15707. %buf1 and %buf2 should not be merged
; in this test case. ; in this test case.
;CHECK-LABEL: myCall_pr15707: ;CHECK-LABEL: myCall_pr15707:
;NOFIRSTUSE: subq $200008, %rsp ;NOFIRSTUSE: subq $200008, %rsp
;NOCOLOR: subq $200008, %rsp ;NOCOLOR: subq $200008, %rsp
define void @myCall_pr15707() { define void @myCall_pr15707() {
%buf1 = alloca i8, i32 100000, align 16 %buf1 = alloca i8, i32 100000, align 16
%buf2 = alloca i8, i32 100000, align 16 %buf2 = alloca i8, i32 100000, align 16
call void @llvm.lifetime.start(i64 -1, i8* %buf1) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %buf1)
call void @llvm.lifetime.end(i64 -1, i8* %buf1) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %buf1)
call void @llvm.lifetime.start(i64 -1, i8* %buf1) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %buf1)
call void @llvm.lifetime.start(i64 -1, i8* %buf2) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %buf2)
%result1 = call i32 @foo(i32 0, i8* %buf1) %result1 = call i32 @foo(i32 0, i8* %buf1)
%result2 = call i32 @foo(i32 0, i8* %buf2) %result2 = call i32 @foo(i32 0, i8* %buf2)
ret void ret void
} }
; Check that we don't assert and crash even when there are allocas ; Check that we don't assert and crash even when there are allocas
; outside the declared lifetime regions. ; outside the declared lifetime regions.
;CHECK-LABEL: bad_range: ;CHECK-LABEL: bad_range:
define void @bad_range() nounwind ssp { define void @bad_range() nounwind ssp {
entry: entry:
%A.i1 = alloca [100 x i32], align 4 %A.i1 = alloca [100 x i32], align 4
%B.i2 = alloca [100 x i32], align 4 %B.i2 = alloca [100 x i32], align 4
%A.i = alloca [100 x i32], align 4 %A.i = alloca [100 x i32], align 4
%B.i = alloca [100 x i32], align 4 %B.i = alloca [100 x i32], align 4
%0 = bitcast [100 x i32]* %A.i to i8* %0 = bitcast [100 x i32]* %A.i to i8*
call void @llvm.lifetime.start(i64 -1, i8* %0) nounwind call void @llvm.lifetime.start.p0i8(i64 -1, i8* %0) nounwind
%1 = bitcast [100 x i32]* %B.i to i8* %1 = bitcast [100 x i32]* %B.i to i8*
call void @llvm.lifetime.start(i64 -1, i8* %1) nounwind call void @llvm.lifetime.start.p0i8(i64 -1, i8* %1) nounwind
call void @bar([100 x i32]* %A.i, [100 x i32]* %B.i) nounwind call void @bar([100 x i32]* %A.i, [100 x i32]* %B.i) nounwind
call void @llvm.lifetime.end(i64 -1, i8* %0) nounwind call void @llvm.lifetime.end.p0i8(i64 -1, i8* %0) nounwind
call void @llvm.lifetime.end(i64 -1, i8* %1) nounwind call void @llvm.lifetime.end.p0i8(i64 -1, i8* %1) nounwind
br label %block2 br label %block2
block2: block2:
; I am used outside the marked lifetime. ; I am used outside the marked lifetime.
call void @bar([100 x i32]* %A.i, [100 x i32]* %B.i) nounwind call void @bar([100 x i32]* %A.i, [100 x i32]* %B.i) nounwind
ret void ret void
} }
; Check that we don't assert and crash even when there are usages ; Check that we don't assert and crash even when there are usages
; of allocas which do not read or write outside the declared lifetime regions. ; of allocas which do not read or write outside the declared lifetime regions.
;CHECK-LABEL: shady_range: ;CHECK-LABEL: shady_range:
%struct.Klass = type { i32, i32 } %struct.Klass = type { i32, i32 }
define i32 @shady_range(i32 %argc, i8** nocapture %argv) uwtable { define i32 @shady_range(i32 %argc, i8** nocapture %argv) uwtable {
%a.i = alloca [4 x %struct.Klass], align 16 %a.i = alloca [4 x %struct.Klass], align 16
%b.i = alloca [4 x %struct.Klass], align 16 %b.i = alloca [4 x %struct.Klass], align 16
%a8 = bitcast [4 x %struct.Klass]* %a.i to i8* %a8 = bitcast [4 x %struct.Klass]* %a.i to i8*
%b8 = bitcast [4 x %struct.Klass]* %b.i to i8* %b8 = bitcast [4 x %struct.Klass]* %b.i to i8*
; I am used outside the lifetime zone below: ; I am used outside the lifetime zone below:
%z2 = getelementptr inbounds [4 x %struct.Klass], [4 x %struct.Klass]* %a.i, i64 0, i64 0, i32 0 %z2 = getelementptr inbounds [4 x %struct.Klass], [4 x %struct.Klass]* %a.i, i64 0, i64 0, i32 0
call void @llvm.lifetime.start(i64 -1, i8* %a8) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %a8)
call void @llvm.lifetime.start(i64 -1, i8* %b8) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %b8)
%z3 = load i32, i32* %z2, align 16 %z3 = load i32, i32* %z2, align 16
%r = call i32 @foo(i32 %z3, i8* %a8) %r = call i32 @foo(i32 %z3, i8* %a8)
%r2 = call i32 @foo(i32 %z3, i8* %b8) %r2 = call i32 @foo(i32 %z3, i8* %b8)
call void @llvm.lifetime.end(i64 -1, i8* %a8) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %a8)
call void @llvm.lifetime.end(i64 -1, i8* %b8) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %b8)
ret i32 9 ret i32 9
} }
; In this case 'itar1' and 'itar2' can't be overlapped if we treat ; In this case 'itar1' and 'itar2' can't be overlapped if we treat
; lifetime.start as the beginning of the lifetime, but we can ; lifetime.start as the beginning of the lifetime, but we can
; overlap if we consider first use of the slot as lifetime ; overlap if we consider first use of the slot as lifetime
; start. See llvm bug 25776. ; start. See llvm bug 25776.
;CHECK-LABEL: ifthen_twoslots: ;CHECK-LABEL: ifthen_twoslots:
;YESCOLOR: subq $1544, %rsp ;YESCOLOR: subq $1544, %rsp
;NOFIRSTUSE: subq $2056, %rsp ;NOFIRSTUSE: subq $2056, %rsp
;NOCOLOR: subq $2568, %rsp ;NOCOLOR: subq $2568, %rsp
define i32 @ifthen_twoslots(i32 %x) #0 { define i32 @ifthen_twoslots(i32 %x) #0 {
entry: entry:
%b1 = alloca [128 x i32], align 16 %b1 = alloca [128 x i32], align 16
%b2 = alloca [128 x i32], align 16 %b2 = alloca [128 x i32], align 16
%b3 = alloca [128 x i32], align 16 %b3 = alloca [128 x i32], align 16
%b4 = alloca [128 x i32], align 16 %b4 = alloca [128 x i32], align 16
%b5 = alloca [128 x i32], align 16 %b5 = alloca [128 x i32], align 16
%tmp = bitcast [128 x i32]* %b1 to i8* %tmp = bitcast [128 x i32]* %b1 to i8*
call void @llvm.lifetime.start(i64 512, i8* %tmp) call void @llvm.lifetime.start.p0i8(i64 512, i8* %tmp)
%tmp1 = bitcast [128 x i32]* %b2 to i8* %tmp1 = bitcast [128 x i32]* %b2 to i8*
call void @llvm.lifetime.start(i64 512, i8* %tmp1) call void @llvm.lifetime.start.p0i8(i64 512, i8* %tmp1)
%and = and i32 %x, 1 %and = and i32 %x, 1
%tobool = icmp eq i32 %and, 0 %tobool = icmp eq i32 %and, 0
br i1 %tobool, label %if.else, label %if.then br i1 %tobool, label %if.else, label %if.then
if.then: ; preds = %entry if.then: ; preds = %entry
%tmp2 = bitcast [128 x i32]* %b3 to i8* %tmp2 = bitcast [128 x i32]* %b3 to i8*
call void @llvm.lifetime.start(i64 512, i8* %tmp2) call void @llvm.lifetime.start.p0i8(i64 512, i8* %tmp2)
%a1 = getelementptr inbounds [128 x i32], [128 x i32]* %b1, i64 0, i64 0 %a1 = getelementptr inbounds [128 x i32], [128 x i32]* %b1, i64 0, i64 0
%a2 = getelementptr inbounds [128 x i32], [128 x i32]* %b3, i64 0, i64 0 %a2 = getelementptr inbounds [128 x i32], [128 x i32]* %b3, i64 0, i64 0
call void @initb(i32* %a1, i32* %a2, i32* null) call void @initb(i32* %a1, i32* %a2, i32* null)
call void @llvm.lifetime.end(i64 512, i8* %tmp2) call void @llvm.lifetime.end.p0i8(i64 512, i8* %tmp2)
br label %if.end br label %if.end
if.else: ; preds = %entry if.else: ; preds = %entry
%tmp3 = bitcast [128 x i32]* %b4 to i8* %tmp3 = bitcast [128 x i32]* %b4 to i8*
call void @llvm.lifetime.start(i64 512, i8* %tmp3) call void @llvm.lifetime.start.p0i8(i64 512, i8* %tmp3)
%tmp4 = bitcast [128 x i32]* %b5 to i8* %tmp4 = bitcast [128 x i32]* %b5 to i8*
call void @llvm.lifetime.start(i64 512, i8* %tmp4) call void @llvm.lifetime.start.p0i8(i64 512, i8* %tmp4)
%a3 = getelementptr inbounds [128 x i32], [128 x i32]* %b2, i64 0, i64 0 %a3 = getelementptr inbounds [128 x i32], [128 x i32]* %b2, i64 0, i64 0
%a4 = getelementptr inbounds [128 x i32], [128 x i32]* %b4, i64 0, i64 0 %a4 = getelementptr inbounds [128 x i32], [128 x i32]* %b4, i64 0, i64 0
%a5 = getelementptr inbounds [128 x i32], [128 x i32]* %b5, i64 0, i64 0 %a5 = getelementptr inbounds [128 x i32], [128 x i32]* %b5, i64 0, i64 0
call void @initb(i32* %a3, i32* %a4, i32* %a5) #3 call void @initb(i32* %a3, i32* %a4, i32* %a5) #3
call void @llvm.lifetime.end(i64 512, i8* %tmp4) call void @llvm.lifetime.end.p0i8(i64 512, i8* %tmp4)
call void @llvm.lifetime.end(i64 512, i8* %tmp3) call void @llvm.lifetime.end.p0i8(i64 512, i8* %tmp3)
br label %if.end br label %if.end
if.end: ; preds = %if.else, %if.then if.end: ; preds = %if.else, %if.then
call void @llvm.lifetime.end(i64 512, i8* %tmp1) call void @llvm.lifetime.end.p0i8(i64 512, i8* %tmp1)
call void @llvm.lifetime.end(i64 512, i8* %tmp) call void @llvm.lifetime.end.p0i8(i64 512, i8* %tmp)
ret i32 0 ret i32 0
} }
; This function is intended to test the case where you ; This function is intended to test the case where you
; have a reference to a stack slot that lies outside of ; have a reference to a stack slot that lies outside of
; the START/END lifetime markers-- the flow analysis ; the START/END lifetime markers-- the flow analysis
; should catch this and build the lifetime based on the ; should catch this and build the lifetime based on the
; markers only. ; markers only.
;CHECK-LABEL: while_loop: ;CHECK-LABEL: while_loop:
;YESCOLOR: subq $1032, %rsp ;YESCOLOR: subq $1032, %rsp
;NOFIRSTUSE: subq $1544, %rsp ;NOFIRSTUSE: subq $1544, %rsp
;NOCOLOR: subq $1544, %rsp ;NOCOLOR: subq $1544, %rsp
define i32 @while_loop(i32 %x) #0 { define i32 @while_loop(i32 %x) #0 {
entry: entry:
%b1 = alloca [128 x i32], align 16 %b1 = alloca [128 x i32], align 16
%b2 = alloca [128 x i32], align 16 %b2 = alloca [128 x i32], align 16
%b3 = alloca [128 x i32], align 16 %b3 = alloca [128 x i32], align 16
%tmp = bitcast [128 x i32]* %b1 to i8* %tmp = bitcast [128 x i32]* %b1 to i8*
call void @llvm.lifetime.start(i64 512, i8* %tmp) #3 call void @llvm.lifetime.start.p0i8(i64 512, i8* %tmp) #3
%tmp1 = bitcast [128 x i32]* %b2 to i8* %tmp1 = bitcast [128 x i32]* %b2 to i8*
call void @llvm.lifetime.start(i64 512, i8* %tmp1) #3 call void @llvm.lifetime.start.p0i8(i64 512, i8* %tmp1) #3
%and = and i32 %x, 1 %and = and i32 %x, 1
%tobool = icmp eq i32 %and, 0 %tobool = icmp eq i32 %and, 0
br i1 %tobool, label %if.else, label %if.then br i1 %tobool, label %if.else, label %if.then
if.then: ; preds = %entry if.then: ; preds = %entry
%arraydecay = getelementptr inbounds [128 x i32], [128 x i32]* %b2, i64 0, i64 0 %arraydecay = getelementptr inbounds [128 x i32], [128 x i32]* %b2, i64 0, i64 0
call void @inita(i32* %arraydecay) #3 call void @inita(i32* %arraydecay) #3
br label %if.end br label %if.end
if.else: ; preds = %entry if.else: ; preds = %entry
%arraydecay1 = getelementptr inbounds [128 x i32], [128 x i32]* %b1, i64 0, i64 0 %arraydecay1 = getelementptr inbounds [128 x i32], [128 x i32]* %b1, i64 0, i64 0
call void @inita(i32* %arraydecay1) #3 call void @inita(i32* %arraydecay1) #3
%arraydecay3 = getelementptr inbounds [128 x i32], [128 x i32]* %b3, i64 0, i64 0 %arraydecay3 = getelementptr inbounds [128 x i32], [128 x i32]* %b3, i64 0, i64 0
call void @inita(i32* %arraydecay3) #3 call void @inita(i32* %arraydecay3) #3
%tobool25 = icmp eq i32 %x, 0 %tobool25 = icmp eq i32 %x, 0
br i1 %tobool25, label %if.end, label %while.body.lr.ph br i1 %tobool25, label %if.end, label %while.body.lr.ph
while.body.lr.ph: ; preds = %if.else while.body.lr.ph: ; preds = %if.else
%tmp2 = bitcast [128 x i32]* %b3 to i8* %tmp2 = bitcast [128 x i32]* %b3 to i8*
br label %while.body br label %while.body
while.body: ; preds = %while.body.lr.ph, %while.body while.body: ; preds = %while.body.lr.ph, %while.body
%x.addr.06 = phi i32 [ %x, %while.body.lr.ph ], [ %dec, %while.body ] %x.addr.06 = phi i32 [ %x, %while.body.lr.ph ], [ %dec, %while.body ]
%dec = add nsw i32 %x.addr.06, -1 %dec = add nsw i32 %x.addr.06, -1
call void @llvm.lifetime.start(i64 512, i8* %tmp2) #3 call void @llvm.lifetime.start.p0i8(i64 512, i8* %tmp2) #3
call void @inita(i32* %arraydecay3) #3 call void @inita(i32* %arraydecay3) #3
call void @llvm.lifetime.end(i64 512, i8* %tmp2) #3 call void @llvm.lifetime.end.p0i8(i64 512, i8* %tmp2) #3
%tobool2 = icmp eq i32 %dec, 0 %tobool2 = icmp eq i32 %dec, 0
br i1 %tobool2, label %if.end.loopexit, label %while.body br i1 %tobool2, label %if.end.loopexit, label %while.body
if.end.loopexit: ; preds = %while.body if.end.loopexit: ; preds = %while.body
br label %if.end br label %if.end
if.end: ; preds = %if.end.loopexit, %if.else, %if.then if.end: ; preds = %if.end.loopexit, %if.else, %if.then
call void @llvm.lifetime.end(i64 512, i8* %tmp1) #3 call void @llvm.lifetime.end.p0i8(i64 512, i8* %tmp1) #3
call void @llvm.lifetime.end(i64 512, i8* %tmp) #3 call void @llvm.lifetime.end.p0i8(i64 512, i8* %tmp) #3
ret i32 0 ret i32 0
} }
; Test case motivated by PR27903. Same routine inlined multiple times ; Test case motivated by PR27903. Same routine inlined multiple times
; into a caller results in a multi-segment lifetime, but the second ; into a caller results in a multi-segment lifetime, but the second
; lifetime has no explicit references to the stack slot. Such slots ; lifetime has no explicit references to the stack slot. Such slots
; have to be treated conservatively. ; have to be treated conservatively.
;CHECK-LABEL: twobod_b27903: ;CHECK-LABEL: twobod_b27903:
;YESCOLOR: subq $96, %rsp ;YESCOLOR: subq $96, %rsp
;NOFIRSTUSE: subq $96, %rsp ;NOFIRSTUSE: subq $96, %rsp
;NOCOLOR: subq $96, %rsp ;NOCOLOR: subq $96, %rsp
define i32 @twobod_b27903(i32 %y, i32 %x) { define i32 @twobod_b27903(i32 %y, i32 %x) {
entry: entry:
%buffer.i = alloca [12 x i32], align 16 %buffer.i = alloca [12 x i32], align 16
%abc = alloca [12 x i32], align 16 %abc = alloca [12 x i32], align 16
%tmp = bitcast [12 x i32]* %buffer.i to i8* %tmp = bitcast [12 x i32]* %buffer.i to i8*
call void @llvm.lifetime.start(i64 48, i8* %tmp) call void @llvm.lifetime.start.p0i8(i64 48, i8* %tmp)
%idxprom.i = sext i32 %y to i64 %idxprom.i = sext i32 %y to i64
%arrayidx.i = getelementptr inbounds [12 x i32], [12 x i32]* %buffer.i, i64 0, i64 %idxprom.i %arrayidx.i = getelementptr inbounds [12 x i32], [12 x i32]* %buffer.i, i64 0, i64 %idxprom.i
call void @inita(i32* %arrayidx.i) call void @inita(i32* %arrayidx.i)
%add.i = add nsw i32 %x, %y %add.i = add nsw i32 %x, %y
call void @llvm.lifetime.end(i64 48, i8* %tmp) call void @llvm.lifetime.end.p0i8(i64 48, i8* %tmp)
%tobool = icmp eq i32 %y, 0 %tobool = icmp eq i32 %y, 0
br i1 %tobool, label %if.end, label %if.then br i1 %tobool, label %if.end, label %if.then
if.then: ; preds = %entry if.then: ; preds = %entry
%tmp1 = bitcast [12 x i32]* %abc to i8* %tmp1 = bitcast [12 x i32]* %abc to i8*
call void @llvm.lifetime.start(i64 48, i8* %tmp1) call void @llvm.lifetime.start.p0i8(i64 48, i8* %tmp1)
%arrayidx = getelementptr inbounds [12 x i32], [12 x i32]* %abc, i64 0, i64 %idxprom.i %arrayidx = getelementptr inbounds [12 x i32], [12 x i32]* %abc, i64 0, i64 %idxprom.i
call void @inita(i32* %arrayidx) call void @inita(i32* %arrayidx)
call void @llvm.lifetime.start(i64 48, i8* %tmp) call void @llvm.lifetime.start.p0i8(i64 48, i8* %tmp)
call void @inita(i32* %arrayidx.i) call void @inita(i32* %arrayidx.i)
%add.i9 = add nsw i32 %add.i, %y %add.i9 = add nsw i32 %add.i, %y
call void @llvm.lifetime.end(i64 48, i8* %tmp) call void @llvm.lifetime.end.p0i8(i64 48, i8* %tmp)
call void @llvm.lifetime.end(i64 48, i8* %tmp1) call void @llvm.lifetime.end.p0i8(i64 48, i8* %tmp1)
br label %if.end br label %if.end
if.end: ; preds = %if.then, %entry if.end: ; preds = %if.then, %entry
%x.addr.0 = phi i32 [ %add.i9, %if.then ], [ %add.i, %entry ] %x.addr.0 = phi i32 [ %add.i9, %if.then ], [ %add.i, %entry ]
ret i32 %x.addr.0 ret i32 %x.addr.0
} }
declare void @inita(i32*) declare void @inita(i32*)
declare void @initb(i32*,i32*,i32*) declare void @initb(i32*,i32*,i32*)
declare void @bar([100 x i32]* , [100 x i32]*) nounwind declare void @bar([100 x i32]* , [100 x i32]*) nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) nounwind declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) nounwind declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) nounwind
declare i32 @foo(i32, i8*) declare i32 @foo(i32, i8*)

test/CodeGen/X86/avx-vbroadcast.ll

Show First 20 Lines • Show All 872 Lines • ▼ Show 20 Lines
; X64-NEXT: vsubss %xmm1, %xmm0, %xmm0 ; X64-NEXT: vsubss %xmm1, %xmm0, %xmm0
; X64-NEXT: addq $40, %rsp ; X64-NEXT: addq $40, %rsp
; X64-NEXT: retq ; X64-NEXT: retq
%1 = alloca <4 x float>, align 16 %1 = alloca <4 x float>, align 16
%2 = alloca <4 x float>, align 16 %2 = alloca <4 x float>, align 16
%3 = bitcast <4 x float>* %1 to i8* %3 = bitcast <4 x float>* %1 to i8*
%4 = bitcast <4 x float>* %2 to i8* %4 = bitcast <4 x float>* %2 to i8*
call void @llvm.lifetime.start(i64 16, i8* %3) call void @llvm.lifetime.start.p0i8(i64 16, i8* %3)
call void @gfunc(<4 x float>* %1) call void @gfunc(<4 x float>* %1)
%5 = load <4 x float>, <4 x float>* %1, align 16 %5 = load <4 x float>, <4 x float>* %1, align 16
call void @llvm.lifetime.end(i64 16, i8* %3) call void @llvm.lifetime.end.p0i8(i64 16, i8* %3)
call void @llvm.lifetime.start(i64 16, i8* %4) call void @llvm.lifetime.start.p0i8(i64 16, i8* %4)
call void @gfunc(<4 x float>* %2) call void @gfunc(<4 x float>* %2)
%6 = load <4 x float>, <4 x float>* %2, align 16 %6 = load <4 x float>, <4 x float>* %2, align 16
call void @llvm.lifetime.end(i64 16, i8* %4) call void @llvm.lifetime.end.p0i8(i64 16, i8* %4)
%7 = extractelement <4 x float> %5, i32 1 %7 = extractelement <4 x float> %5, i32 1
%8 = extractelement <4 x float> %6, i32 1 %8 = extractelement <4 x float> %6, i32 1
%9 = fsub float %8, %7 %9 = fsub float %8, %7
ret float %9 ret float %9
} }
declare void @gfunc(<4 x float>*) declare void @gfunc(<4 x float>*)
declare void @llvm.lifetime.start(i64, i8*) declare void @llvm.lifetime.start.p0i8(i64, i8*)
declare void @llvm.lifetime.end(i64, i8*) declare void @llvm.lifetime.end.p0i8(i64, i8*)

test/CodeGen/X86/catchpad-lifetime.ll

Show All 20 Lines
catch.dispatch: ; preds = %entry catch.dispatch: ; preds = %entry
%cs = catchswitch within none [label %catch.pad] unwind to caller %cs = catchswitch within none [label %catch.pad] unwind to caller
catch.pad: ; preds = %catch.dispatch catch.pad: ; preds = %catch.dispatch
%cp = catchpad within %cs [i8* null, i32 0, i8** %alloca1] %cp = catchpad within %cs [i8* null, i32 0, i8** %alloca1]
store volatile i8* null, i8** %alloca1 store volatile i8* null, i8** %alloca1
%bc1 = bitcast i8** %alloca1 to i8* %bc1 = bitcast i8** %alloca1 to i8*
call void @llvm.lifetime.end(i64 4, i8* nonnull %bc1) call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %bc1)
%bc2 = bitcast i8** %alloca2 to i8* %bc2 = bitcast i8** %alloca2 to i8*
call void @llvm.lifetime.start(i64 4, i8* %bc2) call void @llvm.lifetime.start.p0i8(i64 4, i8* %bc2)
store volatile i8* null, i8** %alloca1 store volatile i8* null, i8** %alloca1
unreachable unreachable
; CHECK-LABEL: "?catch$2@?0?test1@4HA" ; CHECK-LABEL: "?catch$2@?0?test1@4HA"
; CHECK: movq $0, -8(%rbp) ; CHECK: movq $0, -8(%rbp)
; CHECK: movq $0, -8(%rbp) ; CHECK: movq $0, -8(%rbp)
; CHECK: ud2 ; CHECK: ud2
Show All 18 Lines
catch.dispatch: ; preds = %entry catch.dispatch: ; preds = %entry
%cs = catchswitch within none [label %catch.pad] unwind to caller %cs = catchswitch within none [label %catch.pad] unwind to caller
catch.pad: ; preds = %catch.dispatch catch.pad: ; preds = %catch.dispatch
%cp = catchpad within %cs [i8* null, i32 0, i8** null] %cp = catchpad within %cs [i8* null, i32 0, i8** null]
store volatile i8* null, i8** %alloca1 store volatile i8* null, i8** %alloca1
%bc1 = bitcast i8** %alloca1 to i8* %bc1 = bitcast i8** %alloca1 to i8*
call void @llvm.lifetime.end(i64 4, i8* nonnull %bc1) call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %bc1)
%bc2 = bitcast i8** %alloca2 to i8* %bc2 = bitcast i8** %alloca2 to i8*
call void @llvm.lifetime.start(i64 4, i8* %bc2) call void @llvm.lifetime.start.p0i8(i64 4, i8* %bc2)
store volatile i8* null, i8** %alloca1 store volatile i8* null, i8** %alloca1
unreachable unreachable
; CHECK-LABEL: "?catch$2@?0?test2@4HA" ; CHECK-LABEL: "?catch$2@?0?test2@4HA"
; CHECK: movq $0, -16(%rbp) ; CHECK: movq $0, -16(%rbp)
; CHECK: movq $0, -16(%rbp) ; CHECK: movq $0, -16(%rbp)
; CHECK: ud2 ; CHECK: ud2
unreachable: ; preds = %entry unreachable: ; preds = %entry
unreachable unreachable
} }
; CHECK-LABEL: $cppxdata$test2: ; CHECK-LABEL: $cppxdata$test2:
; CHECK: .long 0 # CatchObjOffset ; CHECK: .long 0 # CatchObjOffset
; Function Attrs: argmemonly nounwind ; Function Attrs: argmemonly nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) #0 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #0
; Function Attrs: argmemonly nounwind ; Function Attrs: argmemonly nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) #0 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #0
attributes #0 = { argmemonly nounwind } attributes #0 = { argmemonly nounwind }

test/CodeGen/X86/catchpad-weight.ll

Show All 20 Lines
@"\01??_R0?AUB@@@8" = linkonce_odr global %rtti.TypeDescriptor7 { i8** @"\01??_7type_info@@6B@", i8* null, [8 x i8] c".?AUB@@\00" }, comdat @"\01??_R0?AUB@@@8" = linkonce_odr global %rtti.TypeDescriptor7 { i8** @"\01??_7type_info@@6B@", i8* null, [8 x i8] c".?AUB@@\00" }, comdat
@"\01??_R0?AUC@@@8" = linkonce_odr global %rtti.TypeDescriptor7 { i8** @"\01??_7type_info@@6B@", i8* null, [8 x i8] c".?AUC@@\00" }, comdat @"\01??_R0?AUC@@@8" = linkonce_odr global %rtti.TypeDescriptor7 { i8** @"\01??_7type_info@@6B@", i8* null, [8 x i8] c".?AUC@@\00" }, comdat
; Function Attrs: uwtable ; Function Attrs: uwtable
define i32 @main() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) { define i32 @main() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
entry: entry:
%o = alloca %struct.HasDtor, align 1 %o = alloca %struct.HasDtor, align 1
%0 = getelementptr inbounds %struct.HasDtor, %struct.HasDtor* %o, i64 0, i32 0 %0 = getelementptr inbounds %struct.HasDtor, %struct.HasDtor* %o, i64 0, i32 0
call void @llvm.lifetime.start(i64 1, i8* %0) #4 call void @llvm.lifetime.start.p0i8(i64 1, i8* %0) #4
invoke void @"\01?may_throw@@YAXXZ"() invoke void @"\01?may_throw@@YAXXZ"()
to label %try.cont unwind label %catch.dispatch to label %try.cont unwind label %catch.dispatch
catch.dispatch: ; preds = %entry catch.dispatch: ; preds = %entry
%cs1 = catchswitch within none [label %catch.5] unwind label %catch.dispatch.1 %cs1 = catchswitch within none [label %catch.5] unwind label %catch.dispatch.1
catch.5: ; preds = %catch.dispatch catch.5: ; preds = %catch.dispatch
%1 = catchpad within %cs1 [%rtti.TypeDescriptor7* @"\01??_R0?AUA@@@8", i32 0, i8* null] %1 = catchpad within %cs1 [%rtti.TypeDescriptor7* @"\01??_R0?AUA@@@8", i32 0, i8* null]
catchret from %1 to label %try.cont catchret from %1 to label %try.cont
try.cont: ; preds = %entry, %catch, %catch.3, %catch.5 try.cont: ; preds = %entry, %catch, %catch.3, %catch.5
call void @"\01??1HasDtor@@QEAA@XZ"(%struct.HasDtor* nonnull %o) #4 call void @"\01??1HasDtor@@QEAA@XZ"(%struct.HasDtor* nonnull %o) #4
call void @llvm.lifetime.end(i64 1, i8* %0) #4 call void @llvm.lifetime.end.p0i8(i64 1, i8* %0) #4
ret i32 0 ret i32 0
catch.dispatch.1: ; preds = %catch.dispatch catch.dispatch.1: ; preds = %catch.dispatch
%cs2 = catchswitch within none [label %catch.3] unwind label %catch.dispatch.2 %cs2 = catchswitch within none [label %catch.3] unwind label %catch.dispatch.2
catch.3: ; preds = %catch.dispatch.1 catch.3: ; preds = %catch.dispatch.1
%2 = catchpad within %cs2 [%rtti.TypeDescriptor7* @"\01??_R0?AUB@@@8", i32 0, i8* null] %2 = catchpad within %cs2 [%rtti.TypeDescriptor7* @"\01??_R0?AUB@@@8", i32 0, i8* null]
catchret from %2 to label %try.cont catchret from %2 to label %try.cont
catch.dispatch.2: ; preds = %catch.dispatch.1 catch.dispatch.2: ; preds = %catch.dispatch.1
%cs3 = catchswitch within none [label %catch] unwind label %ehcleanup %cs3 = catchswitch within none [label %catch] unwind label %ehcleanup
catch: ; preds = %catch.dispatch.2 catch: ; preds = %catch.dispatch.2
%3 = catchpad within %cs3 [%rtti.TypeDescriptor7* @"\01??_R0?AUC@@@8", i32 0, i8* null] %3 = catchpad within %cs3 [%rtti.TypeDescriptor7* @"\01??_R0?AUC@@@8", i32 0, i8* null]
catchret from %3 to label %try.cont catchret from %3 to label %try.cont
ehcleanup: ; preds = %catchendblock ehcleanup: ; preds = %catchendblock
%4 = cleanuppad within none [] %4 = cleanuppad within none []
call void @"\01??1HasDtor@@QEAA@XZ"(%struct.HasDtor* nonnull %o) #4 [ "funclet"(token %4) ] call void @"\01??1HasDtor@@QEAA@XZ"(%struct.HasDtor* nonnull %o) #4 [ "funclet"(token %4) ]
cleanupret from %4 unwind to caller cleanupret from %4 unwind to caller
} }
; Function Attrs: nounwind argmemonly ; Function Attrs: nounwind argmemonly
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
declare void @"\01?may_throw@@YAXXZ"() #2 declare void @"\01?may_throw@@YAXXZ"() #2
declare i32 @__CxxFrameHandler3(...) declare i32 @__CxxFrameHandler3(...)
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @"\01??1HasDtor@@QEAA@XZ"(%struct.HasDtor*) #3 declare void @"\01??1HasDtor@@QEAA@XZ"(%struct.HasDtor*) #3
; Function Attrs: nounwind argmemonly ; Function Attrs: nounwind argmemonly
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
attributes #0 = { uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+mmx,+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #0 = { uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+mmx,+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { nounwind argmemonly } attributes #1 = { nounwind argmemonly }
attributes #2 = { "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+mmx,+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #2 = { "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+mmx,+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #3 = { nounwind "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+mmx,+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #3 = { nounwind "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+mmx,+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #4 = { nounwind } attributes #4 = { nounwind }

test/CodeGen/X86/crash.ll

Show First 20 Lines • Show All 308 Lines • ▼ Show 20 Linesbb37: ; preds = %bb36, %bb35, %bb31
%tmp40 = add i32 undef, 1 %tmp40 = add i32 undef, 1
br label %bb4 br label %bb4
} }
declare %t14* @_ZN4llvm9MCContext16CreateTempSymbolEv(%t2*) declare %t14* @_ZN4llvm9MCContext16CreateTempSymbolEv(%t2*)
declare void @_ZNSt6vectorIN4llvm11MachineMoveESaIS1_EE13_M_insert_auxEN9__gnu_cxx17__normal_iteratorIPS1_S3_EERKS1_(%t10*, %t21* byval align 4, %t13*) declare void @_ZNSt6vectorIN4llvm11MachineMoveESaIS1_EE13_M_insert_auxEN9__gnu_cxx17__normal_iteratorIPS1_S3_EERKS1_(%t10*, %t21* byval align 4, %t13*)
declare void @llvm.lifetime.start(i64, i8* nocapture) nounwind declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) nounwind declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) nounwind
; PR10463 ; PR10463
; Spilling a virtual register with <undef> uses. ; Spilling a virtual register with <undef> uses.
define void @autogen_239_1000() { define void @autogen_239_1000() {
BB: BB:
%Shuff = shufflevector <8 x double> undef, <8 x double> undef, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 undef, i32 undef> %Shuff = shufflevector <8 x double> undef, <8 x double> undef, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 undef, i32 undef>
br label %CF br label %CF
▲ Show 20 Lines • Show All 265 Lines • Show Last 20 Lines

test/CodeGen/X86/dbg-changes-codegen-branch-folding.ll

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 Lines
if.then: ; preds = %entry if.then: ; preds = %entry
%call = tail call i8* @_Z5i2stri(i32 %param2), !dbg !53 %call = tail call i8* @_Z5i2stri(i32 %param2), !dbg !53
tail call void @llvm.dbg.value(metadata i8* %call, i64 0, metadata !31, metadata !46), !dbg !49 tail call void @llvm.dbg.value(metadata i8* %call, i64 0, metadata !31, metadata !46), !dbg !49
br label %if.end, !dbg !55 br label %if.end, !dbg !55
if.end: ; preds = %entry, %if.then if.end: ; preds = %entry, %if.then
%0 = getelementptr inbounds %struct.AAA3, %struct.AAA3* %var1, i64 0, i32 0, i64 0, !dbg !56 %0 = getelementptr inbounds %struct.AAA3, %struct.AAA3* %var1, i64 0, i32 0, i64 0, !dbg !56
call void @llvm.lifetime.start(i64 4, i8* %0) #4, !dbg !56 call void @llvm.lifetime.start.p0i8(i64 4, i8* %0) #4, !dbg !56
tail call void @llvm.dbg.value(metadata %struct.AAA3* %var1, i64 0, metadata !32, metadata !57), !dbg !58 tail call void @llvm.dbg.value(metadata %struct.AAA3* %var1, i64 0, metadata !32, metadata !57), !dbg !58
tail call void @llvm.dbg.value(metadata %struct.AAA3* %var1, i64 0, metadata !36, metadata !46), !dbg !59 tail call void @llvm.dbg.value(metadata %struct.AAA3* %var1, i64 0, metadata !36, metadata !46), !dbg !59
tail call void @llvm.dbg.value(metadata i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0), i64 0, metadata !38, metadata !46), !dbg !62 tail call void @llvm.dbg.value(metadata i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0), i64 0, metadata !38, metadata !46), !dbg !62
call void @_Z3fooPcjPKc(i8* %0, i32 4, i8* nonnull getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0)), !dbg !63 call void @_Z3fooPcjPKc(i8* %0, i32 4, i8* nonnull getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0)), !dbg !63
%1 = getelementptr inbounds %struct.AAA3, %struct.AAA3* %var2, i64 0, i32 0, i64 0, !dbg !65 %1 = getelementptr inbounds %struct.AAA3, %struct.AAA3* %var2, i64 0, i32 0, i64 0, !dbg !65
call void @llvm.lifetime.start(i64 4, i8* %1) #4, !dbg !65 call void @llvm.lifetime.start.p0i8(i64 4, i8* %1) #4, !dbg !65
call void @llvm.dbg.value(metadata %struct.AAA3* %var2, i64 0, metadata !33, metadata !57), !dbg !66 call void @llvm.dbg.value(metadata %struct.AAA3* %var2, i64 0, metadata !33, metadata !57), !dbg !66
call void @llvm.dbg.value(metadata %struct.AAA3* %var2, i64 0, metadata !36, metadata !46), !dbg !67 call void @llvm.dbg.value(metadata %struct.AAA3* %var2, i64 0, metadata !36, metadata !46), !dbg !67
call void @llvm.dbg.value(metadata i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0), i64 0, metadata !38, metadata !46), !dbg !69 call void @llvm.dbg.value(metadata i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0), i64 0, metadata !38, metadata !46), !dbg !69
call void @_Z3fooPcjPKc(i8* %1, i32 4, i8* nonnull getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0)), !dbg !70 call void @_Z3fooPcjPKc(i8* %1, i32 4, i8* nonnull getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0)), !dbg !70
%tobool1 = icmp eq i32 %param1, 0, !dbg !71 %tobool1 = icmp eq i32 %param1, 0, !dbg !71
call void @llvm.dbg.value(metadata %struct.AAA3* %var2, i64 0, metadata !33, metadata !57), !dbg !66 call void @llvm.dbg.value(metadata %struct.AAA3* %var2, i64 0, metadata !33, metadata !57), !dbg !66
call void @llvm.dbg.value(metadata %struct.AAA3* %var2, i64 0, metadata !41, metadata !46), !dbg !73 call void @llvm.dbg.value(metadata %struct.AAA3* %var2, i64 0, metadata !41, metadata !46), !dbg !73
br i1 %tobool1, label %if.else, label %if.then2, !dbg !75 br i1 %tobool1, label %if.else, label %if.then2, !dbg !75
if.then2: ; preds = %if.end if.then2: ; preds = %if.end
call void @llvm.dbg.value(metadata i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0), i64 0, metadata !42, metadata !46), !dbg !76 call void @llvm.dbg.value(metadata i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0), i64 0, metadata !42, metadata !46), !dbg !76
call void @_Z3fooPcjPKc(i8* %1, i32 4, i8* nonnull getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0)), !dbg !78 call void @_Z3fooPcjPKc(i8* %1, i32 4, i8* nonnull getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0)), !dbg !78
br label %if.end3, !dbg !79 br label %if.end3, !dbg !79
if.else: ; preds = %if.end if.else: ; preds = %if.end
call void @llvm.dbg.value(metadata i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i64 0, metadata !42, metadata !46), !dbg !80 call void @llvm.dbg.value(metadata i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i64 0, metadata !42, metadata !46), !dbg !80
call void @_Z3fooPcjPKc(i8* %1, i32 4, i8* nonnull getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0)), !dbg !81 call void @_Z3fooPcjPKc(i8* %1, i32 4, i8* nonnull getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0)), !dbg !81
br label %if.end3 br label %if.end3
if.end3: ; preds = %if.else, %if.then2 if.end3: ; preds = %if.else, %if.then2
call void @llvm.dbg.value(metadata %struct.AAA3* %var1, i64 0, metadata !32, metadata !57), !dbg !58 call void @llvm.dbg.value(metadata %struct.AAA3* %var1, i64 0, metadata !32, metadata !57), !dbg !58
call void @llvm.dbg.value(metadata %struct.AAA3* %var1, i64 0, metadata !41, metadata !46), !dbg !82 call void @llvm.dbg.value(metadata %struct.AAA3* %var1, i64 0, metadata !41, metadata !46), !dbg !82
call void @llvm.dbg.value(metadata i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0), i64 0, metadata !42, metadata !46), !dbg !84 call void @llvm.dbg.value(metadata i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0), i64 0, metadata !42, metadata !46), !dbg !84
call void @_Z3fooPcjPKc(i8* %0, i32 4, i8* nonnull getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0)), !dbg !85 call void @_Z3fooPcjPKc(i8* %0, i32 4, i8* nonnull getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0)), !dbg !85
call void @llvm.lifetime.end(i64 4, i8* %1) #4, !dbg !86 call void @llvm.lifetime.end.p0i8(i64 4, i8* %1) #4, !dbg !86
call void @llvm.lifetime.end(i64 4, i8* %0) #4, !dbg !87 call void @llvm.lifetime.end.p0i8(i64 4, i8* %0) #4, !dbg !87
ret void, !dbg !86 ret void, !dbg !86
} }
; Function Attrs: argmemonly nounwind ; Function Attrs: argmemonly nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
declare i8* @_Z5i2stri(i32) #2 declare i8* @_Z5i2stri(i32) #2
; Function Attrs: argmemonly nounwind ; Function Attrs: argmemonly nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
declare void @_Z3fooPcjPKc(i8*, i32, i8*) #2 declare void @_Z3fooPcjPKc(i8*, i32, i8*) #2
; Function Attrs: nounwind readnone ; Function Attrs: nounwind readnone
declare void @llvm.dbg.value(metadata, i64, metadata, metadata) #3 declare void @llvm.dbg.value(metadata, i64, metadata, metadata) #3
attributes #0 = { uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #0 = { uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { argmemonly nounwind } attributes #1 = { argmemonly nounwind }
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

test/CodeGen/X86/dynamic-alloca-lifetime.ll

; RUN: llc -no-stack-coloring=false < %s | FileCheck %s ; RUN: llc -no-stack-coloring=false < %s | FileCheck %s
; This test crashed in PEI because the stack protector was dead. ; This test crashed in PEI because the stack protector was dead.
; This was due to it being colored, which was in turn due to incorrect ; This was due to it being colored, which was in turn due to incorrect
; lifetimes being applied to the stack protector frame index. ; lifetimes being applied to the stack protector frame index.
; CHECK: stack_chk_guard ; CHECK: stack_chk_guard
target datalayout = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128" target datalayout = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128"
target triple = "i386-apple-macosx10.10.0" target triple = "i386-apple-macosx10.10.0"
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) #0 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #0
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) #0 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #0
; Function Attrs: ssp ; Function Attrs: ssp
define void @foo(i1 %cond1, i1 %cond2) #1 { define void @foo(i1 %cond1, i1 %cond2) #1 {
entry: entry:
%bitmapBuffer = alloca [8192 x i8], align 1 %bitmapBuffer = alloca [8192 x i8], align 1
br i1 %cond1, label %end1, label %bb1 br i1 %cond1, label %end1, label %bb1
bb1: bb1:
%bitmapBuffer229 = alloca [8192 x i8], align 1 %bitmapBuffer229 = alloca [8192 x i8], align 1
br i1 %cond2, label %end1, label %if.else130 br i1 %cond2, label %end1, label %if.else130
end1: end1:
ret void ret void
if.else130: ; preds = %bb1 if.else130: ; preds = %bb1
%tmp = getelementptr inbounds [8192 x i8], [8192 x i8]* %bitmapBuffer, i32 0, i32 0 %tmp = getelementptr inbounds [8192 x i8], [8192 x i8]* %bitmapBuffer, i32 0, i32 0
call void @llvm.lifetime.start(i64 8192, i8* %tmp) #0 call void @llvm.lifetime.start.p0i8(i64 8192, i8* %tmp) #0
call void @llvm.lifetime.end(i64 8192, i8* %tmp) #0 call void @llvm.lifetime.end.p0i8(i64 8192, i8* %tmp) #0
%tmp25 = getelementptr inbounds [8192 x i8], [8192 x i8]* %bitmapBuffer229, i32 0, i32 0 %tmp25 = getelementptr inbounds [8192 x i8], [8192 x i8]* %bitmapBuffer229, i32 0, i32 0
call void @llvm.lifetime.start(i64 8192, i8* %tmp25) #0 call void @llvm.lifetime.start.p0i8(i64 8192, i8* %tmp25) #0
call void @llvm.lifetime.end(i64 8192, i8* %tmp25) #0 call void @llvm.lifetime.end.p0i8(i64 8192, i8* %tmp25) #0
br label %end1 br label %end1
} }
declare void @bar() declare void @bar()
attributes #0 = { nounwind } attributes #0 = { nounwind }
attributes #1 = { ssp } attributes #1 = { ssp }
No newline at end of file No newline at end of file

test/CodeGen/X86/fast-isel-deadcode.ll

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Lines
define i32 @main() noinline optnone { define i32 @main() noinline optnone {
entry: entry:
%retval = alloca i32, align 4 %retval = alloca i32, align 4
%v = alloca %struct.FVector, align 4 %v = alloca %struct.FVector, align 4
%ref.tmp = alloca %struct.FVector, align 4 %ref.tmp = alloca %struct.FVector, align 4
%tmp = alloca { <2 x float>, float }, align 8 %tmp = alloca { <2 x float>, float }, align 8
store i32 0, i32* %retval, align 4 store i32 0, i32* %retval, align 4
%0 = bitcast %struct.FVector* %v to i8* %0 = bitcast %struct.FVector* %v to i8*
call void @llvm.lifetime.start(i64 12, i8* %0) nounwind call void @llvm.lifetime.start.p0i8(i64 12, i8* %0) nounwind
%x.i = getelementptr inbounds %struct.FVector, %struct.FVector* %v, i64 0, i32 0 %x.i = getelementptr inbounds %struct.FVector, %struct.FVector* %v, i64 0, i32 0
store float 1.000000e+00, float* %x.i, align 4 store float 1.000000e+00, float* %x.i, align 4
%y.i = getelementptr inbounds %struct.FVector, %struct.FVector* %v, i64 0, i32 1 %y.i = getelementptr inbounds %struct.FVector, %struct.FVector* %v, i64 0, i32 1
store float 1.000000e+00, float* %y.i, align 4 store float 1.000000e+00, float* %y.i, align 4
%z.i = getelementptr inbounds %struct.FVector, %struct.FVector* %v, i64 0, i32 2 %z.i = getelementptr inbounds %struct.FVector, %struct.FVector* %v, i64 0, i32 2
store float 1.000000e+00, float* %z.i, align 4 store float 1.000000e+00, float* %z.i, align 4
%x.i.1 = getelementptr inbounds %struct.FVector, %struct.FVector* %v, i64 0, i32 0 %x.i.1 = getelementptr inbounds %struct.FVector, %struct.FVector* %v, i64 0, i32 0
%1 = load float, float* %x.i.1, align 4 %1 = load float, float* %x.i.1, align 4
Show All 36 Linesfunc.exit: ; preds = %if.then.i, %if.else.i, %if.end.5.i
store { <2 x float>, float } %.fca.1.insert.i, { <2 x float>, float }* %tmp, align 8 store { <2 x float>, float } %.fca.1.insert.i, { <2 x float>, float }* %tmp, align 8
%2 = bitcast { <2 x float>, float }* %tmp to i8* %2 = bitcast { <2 x float>, float }* %tmp to i8*
%3 = bitcast %struct.FVector* %ref.tmp to i8* %3 = bitcast %struct.FVector* %ref.tmp to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %3, i8* %2, i64 12, i32 4, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %3, i8* %2, i64 12, i32 4, i1 false)
%4 = bitcast %struct.FVector* %v to i8* %4 = bitcast %struct.FVector* %v to i8*
%5 = bitcast %struct.FVector* %ref.tmp to i8* %5 = bitcast %struct.FVector* %ref.tmp to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %4, i8* %5, i64 12, i32 4, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %4, i8* %5, i64 12, i32 4, i1 false)
%6 = bitcast %struct.FVector* %v to i8* %6 = bitcast %struct.FVector* %v to i8*
call void @llvm.lifetime.end(i64 12, i8* %6) nounwind call void @llvm.lifetime.end.p0i8(i64 12, i8* %6) nounwind
ret i32 0 ret i32 0
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) argmemonly nounwind declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) argmemonly nounwind
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i32, i1) argmemonly nounwind declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i32, i1) argmemonly nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) argmemonly nounwind declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) argmemonly nounwind

test/CodeGen/X86/fast-isel.ll

Show First 20 Lines • Show All 101 Lines • ▼ Show 20 Lines
@crash_test1x = external global <2 x i32>, align 8 @crash_test1x = external global <2 x i32>, align 8
define void @crash_test1() nounwind ssp { define void @crash_test1() nounwind ssp {
%tmp = load <2 x i32>, <2 x i32>* @crash_test1x, align 8 %tmp = load <2 x i32>, <2 x i32>* @crash_test1x, align 8
%neg = xor <2 x i32> %tmp, <i32 -1, i32 -1> %neg = xor <2 x i32> %tmp, <i32 -1, i32 -1>
ret void ret void
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) nounwind declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind
define i64* @life() nounwind { define i64* @life() nounwind {
%a1 = alloca i64*, align 8 %a1 = alloca i64*, align 8
%a2 = bitcast i64** %a1 to i8* %a2 = bitcast i64** %a1 to i8*
call void @llvm.lifetime.start(i64 -1, i8* %a2) nounwind call void @llvm.lifetime.start.p0i8(i64 -1, i8* %a2) nounwind
%a3 = load i64*, i64** %a1, align 8 %a3 = load i64*, i64** %a1, align 8
ret i64* %a3 ret i64* %a3
} }
declare void @llvm.donothing() readnone declare void @llvm.donothing() readnone
; CHECK: donada ; CHECK: donada
define void @donada() nounwind { define void @donada() nounwind {
entry: entry:
call void @llvm.donothing() call void @llvm.donothing()
ret void ret void
} }

test/CodeGen/X86/load-slice.ll

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Linesentry:
store <2 x float> %retval.sroa.0.4.vec.insert.i, <2 x float>* %ref.tmp.sroa.0.0.cast, align 4 store <2 x float> %retval.sroa.0.4.vec.insert.i, <2 x float>* %ref.tmp.sroa.0.0.cast, align 4
ret void ret void
} }
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i32, i1) #1 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i32, i1) #1
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
; Check that we do not read outside of the chunk of bits of the original loads. ; Check that we do not read outside of the chunk of bits of the original loads.
; ;
; The 64-bits should have been split in one 32-bits and one 16-bits slices. ; The 64-bits should have been split in one 32-bits and one 16-bits slices.
; The 16-bits should be zero extended to match the final type. ; The 16-bits should be zero extended to match the final type.
; ;
; The memory layout is: ; The memory layout is:
; LSB 0 1 2 3 | 4 5 | 6 7 MSB ; LSB 0 1 2 3 | 4 5 | 6 7 MSB
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

test/CodeGen/X86/local_stack_symbol_ordering.ll

Show First 20 Lines • Show All 109 Lines • ▼ Show 20 Linesentry:
%a = alloca [30 x i32], align 16 %a = alloca [30 x i32], align 16
%aa = alloca [1000 x i32], align 16 %aa = alloca [1000 x i32], align 16
%e = alloca i32, align 4 %e = alloca i32, align 4
%cc = alloca [1000 x i32], align 16 %cc = alloca [1000 x i32], align 16
%b = alloca i32, align 4 %b = alloca i32, align 4
%d = alloca i32, align 4 %d = alloca i32, align 4
%aaa = alloca [1000 x i32], align 16 %aaa = alloca [1000 x i32], align 16
%0 = bitcast i32* %f to i8* %0 = bitcast i32* %f to i8*
call void @llvm.lifetime.start(i64 4, i8* %0) #1 call void @llvm.lifetime.start.p0i8(i64 4, i8* %0) #1
%1 = bitcast [30 x i32]* %a to i8* %1 = bitcast [30 x i32]* %a to i8*
call void @llvm.lifetime.start(i64 120, i8* %1) #1 call void @llvm.lifetime.start.p0i8(i64 120, i8* %1) #1
%2 = bitcast [1000 x i32]* %aa to i8* %2 = bitcast [1000 x i32]* %aa to i8*
call void @llvm.lifetime.start(i64 4000, i8* %2) #1 call void @llvm.lifetime.start.p0i8(i64 4000, i8* %2) #1
%3 = bitcast i32* %e to i8* %3 = bitcast i32* %e to i8*
call void @llvm.lifetime.start(i64 4, i8* %3) #1 call void @llvm.lifetime.start.p0i8(i64 4, i8* %3) #1
%4 = bitcast [1000 x i32]* %cc to i8* %4 = bitcast [1000 x i32]* %cc to i8*
call void @llvm.lifetime.start(i64 4000, i8* %4) #1 call void @llvm.lifetime.start.p0i8(i64 4000, i8* %4) #1
%5 = bitcast i32* %b to i8* %5 = bitcast i32* %b to i8*
call void @llvm.lifetime.start(i64 4, i8* %5) #1 call void @llvm.lifetime.start.p0i8(i64 4, i8* %5) #1
%6 = bitcast i32* %d to i8* %6 = bitcast i32* %d to i8*
call void @llvm.lifetime.start(i64 4, i8* %6) #1 call void @llvm.lifetime.start.p0i8(i64 4, i8* %6) #1
%7 = bitcast [1000 x i32]* %aaa to i8* %7 = bitcast [1000 x i32]* %aaa to i8*
call void @llvm.lifetime.start(i64 4000, i8* %7) #1 call void @llvm.lifetime.start.p0i8(i64 4000, i8* %7) #1
%call = call i32 ([30 x i32]*, ...) bitcast (i32 (...)* @check_a to i32 ([30 x i32]*, ...)*)([30 x i32]* %a) %call = call i32 ([30 x i32]*, ...) bitcast (i32 (...)* @check_a to i32 ([30 x i32]*, ...)*)([30 x i32]* %a)
%call1 = call i32 ([1000 x i32]*, ...) bitcast (i32 (...)* @bar1 to i32 ([1000 x i32]*, ...)*)([1000 x i32]* %aaa) %call1 = call i32 ([1000 x i32]*, ...) bitcast (i32 (...)* @bar1 to i32 ([1000 x i32]*, ...)*)([1000 x i32]* %aaa)
call void asm sideeffect "", "~{esi},~{edi},~{ebp},~{ebx},~{rbx},~{r12},~{r13},~{r14},~{r15},~{rbp},~{dirflag},~{fpsr},~{flags}"() #1 call void asm sideeffect "", "~{esi},~{edi},~{ebp},~{ebx},~{rbx},~{r12},~{r13},~{r14},~{r15},~{rbp},~{dirflag},~{fpsr},~{flags}"() #1
%call2 = call i32 ([30 x i32]*, ...) bitcast (i32 (...)* @bar1 to i32 ([30 x i32]*, ...)*)([30 x i32]* %a) %call2 = call i32 ([30 x i32]*, ...) bitcast (i32 (...)* @bar1 to i32 ([30 x i32]*, ...)*)([30 x i32]* %a)
%call3 = call i32 (i32*, ...) bitcast (i32 (...)* @check_f to i32 (i32*, ...)*)(i32* %f) %call3 = call i32 (i32*, ...) bitcast (i32 (...)* @check_f to i32 (i32*, ...)*)(i32* %f)
call void asm sideeffect "", "~{esi},~{edi},~{ebp},~{ebx},~{rbx},~{r12},~{r13},~{r14},~{r15},~{rbp},~{dirflag},~{fpsr},~{flags}"() #1 call void asm sideeffect "", "~{esi},~{edi},~{ebp},~{ebx},~{rbx},~{r12},~{r13},~{r14},~{r15},~{rbp},~{dirflag},~{fpsr},~{flags}"() #1
%call4 = call i32 ([30 x i32]*, ...) bitcast (i32 (...)* @bar1 to i32 ([30 x i32]*, ...)*)([30 x i32]* %a) %call4 = call i32 ([30 x i32]*, ...) bitcast (i32 (...)* @bar1 to i32 ([30 x i32]*, ...)*)([30 x i32]* %a)
%call5 = call i32 ([1000 x i32]*, [1000 x i32]*, [1000 x i32]*, ...) bitcast (i32 (...)* @bar3 to i32 ([1000 x i32]*, [1000 x i32]*, [1000 x i32]*, ...)*)([1000 x i32]* %aa, [1000 x i32]* %aaa, [1000 x i32]* %cc) %call5 = call i32 ([1000 x i32]*, [1000 x i32]*, [1000 x i32]*, ...) bitcast (i32 (...)* @bar3 to i32 ([1000 x i32]*, [1000 x i32]*, [1000 x i32]*, ...)*)([1000 x i32]* %aa, [1000 x i32]* %aaa, [1000 x i32]* %cc)
Show All 10 Linesentry:
call void asm sideeffect "", "~{esi},~{edi},~{ebp},~{ebx},~{rbx},~{r12},~{r13},~{r14},~{r15},~{rbp},~{dirflag},~{fpsr},~{flags}"() #1 call void asm sideeffect "", "~{esi},~{edi},~{ebp},~{ebx},~{rbx},~{r12},~{r13},~{r14},~{r15},~{rbp},~{dirflag},~{fpsr},~{flags}"() #1
%call12 = call i32 (i32*, i32*, ...) bitcast (i32 (...)* @bar2 to i32 (i32*, i32*, ...)*)(i32* %e, i32* %f) %call12 = call i32 (i32*, i32*, ...) bitcast (i32 (...)* @bar2 to i32 (i32*, i32*, ...)*)(i32* %e, i32* %f)
%call13 = call i32 (i32*, ...) bitcast (i32 (...)* @check_d to i32 (i32*, ...)*)(i32* %d) %call13 = call i32 (i32*, ...) bitcast (i32 (...)* @check_d to i32 (i32*, ...)*)(i32* %d)
%call14 = call i32 ([30 x i32]*, ...) bitcast (i32 (...)* @bar1 to i32 ([30 x i32]*, ...)*)([30 x i32]* %a) %call14 = call i32 ([30 x i32]*, ...) bitcast (i32 (...)* @bar1 to i32 ([30 x i32]*, ...)*)([30 x i32]* %a)
call void asm sideeffect "", "~{esi},~{edi},~{ebp},~{ebx},~{rbx},~{r12},~{r13},~{r14},~{r15},~{rbp},~{dirflag},~{fpsr},~{flags}"() #1 call void asm sideeffect "", "~{esi},~{edi},~{ebp},~{ebx},~{rbx},~{r12},~{r13},~{r14},~{r15},~{rbp},~{dirflag},~{fpsr},~{flags}"() #1
%call15 = call i32 (i32*, i32*, i32*, ...) bitcast (i32 (...)* @bar3 to i32 (i32*, i32*, i32*, ...)*)(i32* %d, i32* %e, i32* %f) %call15 = call i32 (i32*, i32*, i32*, ...) bitcast (i32 (...)* @bar3 to i32 (i32*, i32*, i32*, ...)*)(i32* %d, i32* %e, i32* %f)
call void asm sideeffect "", "~{esi},~{edi},~{ebp},~{ebx},~{rbx},~{r12},~{r13},~{r14},~{r15},~{rbp},~{dirflag},~{fpsr},~{flags}"() #1 call void asm sideeffect "", "~{esi},~{edi},~{ebp},~{ebx},~{rbx},~{r12},~{r13},~{r14},~{r15},~{rbp},~{dirflag},~{fpsr},~{flags}"() #1
%call16 = call i32 ([30 x i32]*, ...) bitcast (i32 (...)* @bar1 to i32 ([30 x i32]*, ...)*)([30 x i32]* %a) %call16 = call i32 ([30 x i32]*, ...) bitcast (i32 (...)* @bar1 to i32 ([30 x i32]*, ...)*)([30 x i32]* %a)
call void @llvm.lifetime.end(i64 4000, i8* %7) #1 call void @llvm.lifetime.end.p0i8(i64 4000, i8* %7) #1
call void @llvm.lifetime.end(i64 4, i8* %6) #1 call void @llvm.lifetime.end.p0i8(i64 4, i8* %6) #1
call void @llvm.lifetime.end(i64 4, i8* %5) #1 call void @llvm.lifetime.end.p0i8(i64 4, i8* %5) #1
call void @llvm.lifetime.end(i64 4000, i8* %4) #1 call void @llvm.lifetime.end.p0i8(i64 4000, i8* %4) #1
call void @llvm.lifetime.end(i64 4, i8* %3) #1 call void @llvm.lifetime.end.p0i8(i64 4, i8* %3) #1
call void @llvm.lifetime.end(i64 4000, i8* %2) #1 call void @llvm.lifetime.end.p0i8(i64 4000, i8* %2) #1
call void @llvm.lifetime.end(i64 120, i8* %1) #1 call void @llvm.lifetime.end.p0i8(i64 120, i8* %1) #1
call void @llvm.lifetime.end(i64 4, i8* %0) #1 call void @llvm.lifetime.end.p0i8(i64 4, i8* %0) #1
ret void ret void
} }
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
declare i32 @check_a(...) #2 declare i32 @check_a(...) #2
declare i32 @bar1(...) #2 declare i32 @bar1(...) #2
declare i32 @check_f(...) #2 declare i32 @check_f(...) #2
declare i32 @bar3(...) #2 declare i32 @bar3(...) #2
declare i32 @bar2(...) #2 declare i32 @bar2(...) #2
declare i32 @check_b(...) #2 declare i32 @check_b(...) #2
declare i32 @check_e(...) #2 declare i32 @check_e(...) #2
declare i32 @check_d(...) #2 declare i32 @check_d(...) #2
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1

test/CodeGen/X86/machine-trace-metrics-crash.ll

Show All 25 Linesif.end:
%n0 = load float, float* undef, align 4 %n0 = load float, float* undef, align 4
%mul = fmul fast float %n0, %h %mul = fmul fast float %n0, %h
%add = fadd fast float %mul, 1.0 %add = fadd fast float %mul, 1.0
tail call void @llvm.dbg.value(metadata %struct.A* undef, i64 0, metadata !5, metadata !4), !dbg !6 tail call void @llvm.dbg.value(metadata %struct.A* undef, i64 0, metadata !5, metadata !4), !dbg !6
tail call void @llvm.dbg.value(metadata float %add, i64 0, metadata !5, metadata !4), !dbg !6 tail call void @llvm.dbg.value(metadata float %add, i64 0, metadata !5, metadata !4), !dbg !6
%add.i = fadd fast float %add, %n0 %add.i = fadd fast float %add, %n0
store float %add.i, float* undef, align 4 store float %add.i, float* undef, align 4
%n1 = bitcast %struct.A* %i to i8* %n1 = bitcast %struct.A* %i to i8*
call void @llvm.lifetime.start(i64 16, i8* %n1) call void @llvm.lifetime.start.p0i8(i64 16, i8* %n1)
%n2 = load <2 x float>, <2 x float>* undef, align 8 %n2 = load <2 x float>, <2 x float>* undef, align 8
%conv = uitofp i1 %tobool to float %conv = uitofp i1 %tobool to float
%bitcast = extractelement <2 x float> %n2, i32 0 %bitcast = extractelement <2 x float> %n2, i32 0
%factor = fmul fast float %bitcast, 2.0 %factor = fmul fast float %bitcast, 2.0
%add3 = fadd fast float %factor, %conv %add3 = fadd fast float %factor, %conv
call void @bar(float %add3) call void @bar(float %add3)
ret void ret void
} }
%struct.A = type { float, float } %struct.A = type { float, float }
declare void @bar(float) declare void @bar(float)
declare void @foo(%struct.A*) declare void @foo(%struct.A*)
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @llvm.dbg.value(metadata, i64, metadata, metadata) declare void @llvm.dbg.value(metadata, i64, metadata, metadata)
!llvm.dbg.cu = !{!0} !llvm.dbg.cu = !{!0}
!llvm.module.flags = !{!2} !llvm.module.flags = !{!2}
!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug) !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug)
!1 = !DIFile(filename: "24199.cpp", directory: "/bin") !1 = !DIFile(filename: "24199.cpp", directory: "/bin")
!2 = !{i32 2, !"Debug Info Version", i32 3} !2 = !{i32 2, !"Debug Info Version", i32 3}
!3 = distinct !DISubprogram(linkageName: "foo", file: !1, line: 18, isLocal: false, isDefinition: true, scopeLine: 18, unit: !0) !3 = distinct !DISubprogram(linkageName: "foo", file: !1, line: 18, isLocal: false, isDefinition: true, scopeLine: 18, unit: !0)
!4 = !DIExpression() !4 = !DIExpression()
!5 = !DILocalVariable(name: "this", arg: 1, scope: !3, flags: DIFlagArtificial | DIFlagObjectPointer) !5 = !DILocalVariable(name: "this", arg: 1, scope: !3, flags: DIFlagArtificial | DIFlagObjectPointer)
!6 = !DILocation(line: 0, scope: !3) !6 = !DILocation(line: 0, scope: !3)

test/CodeGen/X86/misched-aa-colored.ll

Show First 20 Lines • Show All 137 Lines • ▼ Show 20 Lines
@__PRETTY_FUNCTION__._ZNK4llvm6SDNode10getOperandEj = external hidden unnamed_addr constant [66 x i8], align 1 @__PRETTY_FUNCTION__._ZNK4llvm6SDNode10getOperandEj = external hidden unnamed_addr constant [66 x i8], align 1
declare { %"class.llvm::SDNode.10.610.970.1930.2050.2290.4090"*, i32 } @_ZN4llvm12SelectionDAG7getNodeEjNS_5SDLocENS_3EVTENS_7SDValueES3_(%"class.llvm::SelectionDAG.104.704.1064.2024.2144.2384.4184"*, i32, i8*, i32, i32, %"class.llvm::Type.7.607.967.1927.2047.2287.4087"*, %"class.llvm::SDValue.3.603.963.1923.2043.2283.4083"* byval align 8, %"class.llvm::SDValue.3.603.963.1923.2043.2283.4083"* byval align 8) declare { %"class.llvm::SDNode.10.610.970.1930.2050.2290.4090"*, i32 } @_ZN4llvm12SelectionDAG7getNodeEjNS_5SDLocENS_3EVTENS_7SDValueES3_(%"class.llvm::SelectionDAG.104.704.1064.2024.2144.2384.4184"*, i32, i8*, i32, i32, %"class.llvm::Type.7.607.967.1927.2047.2287.4087"*, %"class.llvm::SDValue.3.603.963.1923.2043.2283.4083"* byval align 8, %"class.llvm::SDValue.3.603.963.1923.2043.2283.4083"* byval align 8)
; Function Attrs: noreturn nounwind ; Function Attrs: noreturn nounwind
declare void @__assert_fail(i8*, i8*, i32, i8*) #0 declare void @__assert_fail(i8*, i8*, i32, i8*) #0
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define hidden { %"class.llvm::SDNode.10.610.970.1930.2050.2290.4090"*, i32 } @_ZN4llvm16DAGTypeLegalizer18WidenVecRes_BinaryEPNS_6SDNodeE(%"class.llvm::DAGTypeLegalizer.117.717.1077.2037.2157.2397.4197"* %this, %"class.llvm::SDNode.10.610.970.1930.2050.2290.4090"* %N) #2 align 2 { define hidden { %"class.llvm::SDNode.10.610.970.1930.2050.2290.4090"*, i32 } @_ZN4llvm16DAGTypeLegalizer18WidenVecRes_BinaryEPNS_6SDNodeE(%"class.llvm::DAGTypeLegalizer.117.717.1077.2037.2157.2397.4197"* %this, %"class.llvm::SDNode.10.610.970.1930.2050.2290.4090"* %N) #2 align 2 {
entry: entry:
%Op.i43 = alloca %"class.llvm::SDValue.3.603.963.1923.2043.2283.4083", align 8 %Op.i43 = alloca %"class.llvm::SDValue.3.603.963.1923.2043.2283.4083", align 8
%ref.tmp.i = alloca %"struct.std::pair.112.119.719.1079.2039.2159.2399.4199", align 8 %ref.tmp.i = alloca %"struct.std::pair.112.119.719.1079.2039.2159.2399.4199", align 8
%Op.i = alloca %"class.llvm::SDValue.3.603.963.1923.2043.2283.4083", align 8 %Op.i = alloca %"class.llvm::SDValue.3.603.963.1923.2043.2283.4083", align 8
%0 = bitcast %"struct.std::pair.112.119.719.1079.2039.2159.2399.4199"* %ref.tmp.i to i8* %0 = bitcast %"struct.std::pair.112.119.719.1079.2039.2159.2399.4199"* %ref.tmp.i to i8*
call void @llvm.lifetime.start(i64 24, i8* %0) #1 call void @llvm.lifetime.start.p0i8(i64 24, i8* %0) #1
%retval.sroa.0.0.idx.i36 = getelementptr inbounds %"struct.std::pair.112.119.719.1079.2039.2159.2399.4199", %"struct.std::pair.112.119.719.1079.2039.2159.2399.4199"* %ref.tmp.i, i64 0, i32 1, i32 0, i32 0 %retval.sroa.0.0.idx.i36 = getelementptr inbounds %"struct.std::pair.112.119.719.1079.2039.2159.2399.4199", %"struct.std::pair.112.119.719.1079.2039.2159.2399.4199"* %ref.tmp.i, i64 0, i32 1, i32 0, i32 0
%retval.sroa.0.0.copyload.i37 = load i32, i32* %retval.sroa.0.0.idx.i36, align 8 %retval.sroa.0.0.copyload.i37 = load i32, i32* %retval.sroa.0.0.idx.i36, align 8
call void @llvm.lifetime.end(i64 24, i8* %0) #1 call void @llvm.lifetime.end.p0i8(i64 24, i8* %0) #1
%agg.tmp8.sroa.2.0.copyload = load i32, i32* undef, align 8 %agg.tmp8.sroa.2.0.copyload = load i32, i32* undef, align 8
%1 = bitcast %"class.llvm::SDValue.3.603.963.1923.2043.2283.4083"* %Op.i to i8* %1 = bitcast %"class.llvm::SDValue.3.603.963.1923.2043.2283.4083"* %Op.i to i8*
call void @llvm.lifetime.start(i64 16, i8* %1) #1 call void @llvm.lifetime.start.p0i8(i64 16, i8* %1) #1
%2 = getelementptr %"class.llvm::SDValue.3.603.963.1923.2043.2283.4083", %"class.llvm::SDValue.3.603.963.1923.2043.2283.4083"* %Op.i, i64 0, i32 1 %2 = getelementptr %"class.llvm::SDValue.3.603.963.1923.2043.2283.4083", %"class.llvm::SDValue.3.603.963.1923.2043.2283.4083"* %Op.i, i64 0, i32 1
store i32 %agg.tmp8.sroa.2.0.copyload, i32* %2, align 8 store i32 %agg.tmp8.sroa.2.0.copyload, i32* %2, align 8
; CHECK: movl (%rax), %eax ; CHECK: movl (%rax), %eax
; CHECK-NOT: movl %eax, {{[0-9]+}}(%rsp) ; CHECK-NOT: movl %eax, {{[0-9]+}}(%rsp)
; CHECK: movl [[OFF:[0-9]+]](%rsp), %r8d ; CHECK: movl [[OFF:[0-9]+]](%rsp), %r8d
; CHECK: movl %eax, [[OFF]](%rsp) ; CHECK: movl %eax, [[OFF]](%rsp)
; CHECK: movl $-1, %ecx ; CHECK: movl $-1, %ecx
Show All 18 Lines

test/CodeGen/X86/stack-align.ll

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
%struct.sixteen = type { [16 x i8] } %struct.sixteen = type { [16 x i8] }
; Accessing stack parameters shouldn't assume stack alignment. Here we should ; Accessing stack parameters shouldn't assume stack alignment. Here we should
; emit two 8-byte loads, followed by two 8-byte stores. ; emit two 8-byte loads, followed by two 8-byte stores.
define x86_stdcallcc void @test5(%struct.sixteen* byval nocapture readonly align 4 %s) #0 { define x86_stdcallcc void @test5(%struct.sixteen* byval nocapture readonly align 4 %s) #0 {
%d.sroa.0 = alloca [16 x i8], align 1 %d.sroa.0 = alloca [16 x i8], align 1
%1 = getelementptr inbounds [16 x i8], [16 x i8]* %d.sroa.0, i32 0, i32 0 %1 = getelementptr inbounds [16 x i8], [16 x i8]* %d.sroa.0, i32 0, i32 0
call void @llvm.lifetime.start(i64 16, i8* %1) call void @llvm.lifetime.start.p0i8(i64 16, i8* %1)
%2 = getelementptr inbounds %struct.sixteen, %struct.sixteen* %s, i32 0, i32 0, i32 0 %2 = getelementptr inbounds %struct.sixteen, %struct.sixteen* %s, i32 0, i32 0, i32 0
call void @llvm.memcpy.p0i8.p0i8.i32(i8* %1, i8* %2, i32 16, i32 1, i1 true) call void @llvm.memcpy.p0i8.p0i8.i32(i8* %1, i8* %2, i32 16, i32 1, i1 true)
call void @llvm.lifetime.end(i64 16, i8* %1) call void @llvm.lifetime.end.p0i8(i64 16, i8* %1)
ret void ret void
; CHECK-LABEL: test5: ; CHECK-LABEL: test5:
; CHECK: and ; CHECK: and
; CHECK: movsd ; CHECK: movsd
; CHECK-NEXT: movsd ; CHECK-NEXT: movsd
; CHECK-NEXT: movsd ; CHECK-NEXT: movsd
; CHECK-NEXT: movsd ; CHECK-NEXT: movsd
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) argmemonly nounwind declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) argmemonly nounwind
declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture readonly, i32, i32, i1) argmemonly nounwind declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture readonly, i32, i32, i1) argmemonly nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) argmemonly nounwind declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) argmemonly nounwind
attributes #0 = { nounwind alignstack=16 "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" } attributes #0 = { nounwind alignstack=16 "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" }

test/CodeGen/X86/stack-protector-weight.ll

Show All 25 Lines
; MSVC-IR: ST4[FixedStack0] ; MSVC-IR: ST4[FixedStack0]
; MSVC-IR: LD4[%StackGuardSlot] ; MSVC-IR: LD4[%StackGuardSlot]
; MSVC-IR: CALLpcrel32 <ga:@__security_check_cookie> ; MSVC-IR: CALLpcrel32 <ga:@__security_check_cookie>
define i32 @test_branch_weights(i32 %n) #0 { define i32 @test_branch_weights(i32 %n) #0 {
entry: entry:
%a = alloca [128 x i32], align 16 %a = alloca [128 x i32], align 16
%0 = bitcast [128 x i32]* %a to i8* %0 = bitcast [128 x i32]* %a to i8*
call void @llvm.lifetime.start(i64 512, i8* %0) call void @llvm.lifetime.start.p0i8(i64 512, i8* %0)
%arraydecay = getelementptr inbounds [128 x i32], [128 x i32]* %a, i64 0, i64 0 %arraydecay = getelementptr inbounds [128 x i32], [128 x i32]* %a, i64 0, i64 0
call void @foo2(i32* %arraydecay) call void @foo2(i32* %arraydecay)
%idxprom = sext i32 %n to i64 %idxprom = sext i32 %n to i64
%arrayidx = getelementptr inbounds [128 x i32], [128 x i32]* %a, i64 0, i64 %idxprom %arrayidx = getelementptr inbounds [128 x i32], [128 x i32]* %a, i64 0, i64 %idxprom
%1 = load i32, i32* %arrayidx, align 4 %1 = load i32, i32* %arrayidx, align 4
call void @llvm.lifetime.end(i64 512, i8* %0) call void @llvm.lifetime.end.p0i8(i64 512, i8* %0)
ret i32 %1 ret i32 %1
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @foo2(i32*) declare void @foo2(i32*)
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
attributes #0 = { sspstrong "stack-protector-buffer-size"="8" } attributes #0 = { sspstrong "stack-protector-buffer-size"="8" }

test/CodeGen/X86/stack_guard_remat.ll

; RUN: llc < %s -mtriple=x86_64-apple-darwin -no-integrated-as | FileCheck %s ; RUN: llc < %s -mtriple=x86_64-apple-darwin -no-integrated-as | FileCheck %s
;CHECK: foo2 ;CHECK: foo2
;CHECK: movq ___stack_chk_guard@GOTPCREL(%rip), [[R0:%[a-z0-9]+]] ;CHECK: movq ___stack_chk_guard@GOTPCREL(%rip), [[R0:%[a-z0-9]+]]
;CHECK: movq ([[R0]]), {{%[a-z0-9]+}} ;CHECK: movq ([[R0]]), {{%[a-z0-9]+}}
; Function Attrs: nounwind ssp uwtable ; Function Attrs: nounwind ssp uwtable
define i32 @test_stack_guard_remat() #0 { define i32 @test_stack_guard_remat() #0 {
entry: entry:
%a1 = alloca [256 x i32], align 16 %a1 = alloca [256 x i32], align 16
%0 = bitcast [256 x i32]* %a1 to i8* %0 = bitcast [256 x i32]* %a1 to i8*
call void @llvm.lifetime.start(i64 1024, i8* %0) call void @llvm.lifetime.start.p0i8(i64 1024, i8* %0)
%arraydecay = getelementptr inbounds [256 x i32], [256 x i32]* %a1, i64 0, i64 0 %arraydecay = getelementptr inbounds [256 x i32], [256 x i32]* %a1, i64 0, i64 0
call void @foo3(i32* %arraydecay) call void @foo3(i32* %arraydecay)
call void asm sideeffect "foo2", "~{r12},~{r13},~{r14},~{r15},~{ebx},~{esi},~{edi},~{dirflag},~{fpsr},~{flags}"() call void asm sideeffect "foo2", "~{r12},~{r13},~{r14},~{r15},~{ebx},~{esi},~{edi},~{dirflag},~{fpsr},~{flags}"()
call void @llvm.lifetime.end(i64 1024, i8* %0) call void @llvm.lifetime.end.p0i8(i64 1024, i8* %0)
ret i32 0 ret i32 0
} }
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @foo3(i32*) declare void @foo3(i32*)
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
attributes #0 = { nounwind ssp uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #0 = { nounwind ssp uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }

test/CodeGen/X86/unused_stackslots.ll

Show All 18 Lines
; CHECK-LABEL: @fn ; CHECK-LABEL: @fn
; CHECK: subq {{\$3[0-4][0-9]}}, %rsp ; CHECK: subq {{\$3[0-4][0-9]}}, %rsp
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define i32 @fn() #0 { define i32 @fn() #0 {
entry: entry:
%n = alloca [8 x [8 x i32]], align 16 %n = alloca [8 x [8 x i32]], align 16
%tmp = bitcast [8 x [8 x i32]]* %n to i8* %tmp = bitcast [8 x [8 x i32]]* %n to i8*
call void @llvm.lifetime.start(i64 256, i8* %tmp) #3 call void @llvm.lifetime.start.p0i8(i64 256, i8* %tmp) #3
%tmp1 = bitcast [8 x [8 x i32]]* %n to i8* %tmp1 = bitcast [8 x [8 x i32]]* %n to i8*
%arraydecay.1 = getelementptr inbounds [8 x [8 x i32]], [8 x [8 x i32]]* %n, i64 0, i64 1, i64 0 %arraydecay.1 = getelementptr inbounds [8 x [8 x i32]], [8 x [8 x i32]]* %n, i64 0, i64 1, i64 0
%tmp2 = bitcast i32* %arraydecay.1 to i8* %tmp2 = bitcast i32* %arraydecay.1 to i8*
%arraydecay.2 = getelementptr inbounds [8 x [8 x i32]], [8 x [8 x i32]]* %n, i64 0, i64 2, i64 0 %arraydecay.2 = getelementptr inbounds [8 x [8 x i32]], [8 x [8 x i32]]* %n, i64 0, i64 2, i64 0
%tmp3 = bitcast i32* %arraydecay.2 to i8* %tmp3 = bitcast i32* %arraydecay.2 to i8*
%arraydecay.3 = getelementptr inbounds [8 x [8 x i32]], [8 x [8 x i32]]* %n, i64 0, i64 3, i64 0 %arraydecay.3 = getelementptr inbounds [8 x [8 x i32]], [8 x [8 x i32]]* %n, i64 0, i64 3, i64 0
%tmp4 = bitcast i32* %arraydecay.3 to i8* %tmp4 = bitcast i32* %arraydecay.3 to i8*
%arraydecay.4 = getelementptr inbounds [8 x [8 x i32]], [8 x [8 x i32]]* %n, i64 0, i64 4, i64 0 %arraydecay.4 = getelementptr inbounds [8 x [8 x i32]], [8 x [8 x i32]]* %n, i64 0, i64 4, i64 0
▲ Show 20 Lines • Show All 181 Lines • ▼ Show 20 Lines
for.inc73: ; preds = %for.body61.preheader, %land.lhs.true54, %for.end50 for.inc73: ; preds = %for.body61.preheader, %land.lhs.true54, %for.end50
%m.4 = phi i32 [ %add71, %for.body61.preheader ], [ %m.3.lcssa.lcssa, %land.lhs.true54 ], [ %m.3.lcssa.lcssa, %for.end50 ] %m.4 = phi i32 [ %add71, %for.body61.preheader ], [ %m.3.lcssa.lcssa, %land.lhs.true54 ], [ %m.3.lcssa.lcssa, %for.end50 ]
%inc74 = add nuw nsw i32 %q.0131, 1 %inc74 = add nuw nsw i32 %q.0131, 1
%exitcond156 = icmp eq i32 %inc74, 4 %exitcond156 = icmp eq i32 %inc74, 4
br i1 %exitcond156, label %for.end75, label %for.body br i1 %exitcond156, label %for.end75, label %for.body
for.end75: ; preds = %for.inc73 for.end75: ; preds = %for.inc73
%m.4.lcssa = phi i32 [ %m.4, %for.inc73 ] %m.4.lcssa = phi i32 [ %m.4, %for.inc73 ]
call void @llvm.lifetime.end(i64 256, i8* %tmp) #3 call void @llvm.lifetime.end.p0i8(i64 256, i8* %tmp) #3
ret i32 %m.4.lcssa ret i32 %m.4.lcssa
} }
; Function Attrs: argmemonly nounwind ; Function Attrs: argmemonly nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
declare void @LumaPrediction4x4(i32, i32, i32, i32, i32, i16 signext, i16 signext) #2 declare void @LumaPrediction4x4(i32, i32, i32, i32, i32, i16 signext, i16 signext) #2
declare i32 @distortion4x4(i32*) #2 declare i32 @distortion4x4(i32*) #2
; Function Attrs: argmemonly nounwind ; Function Attrs: argmemonly nounwind
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i32, i1) #1 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i32, i1) #1
; Function Attrs: argmemonly nounwind ; Function Attrs: argmemonly nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
attributes #0 = { nounwind uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #0 = { nounwind uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { argmemonly nounwind } attributes #1 = { argmemonly nounwind }
attributes #2 = { "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #2 = { "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #3 = { nounwind } attributes #3 = { nounwind }

test/CodeGen/X86/unwindraise.ll

Show First 20 Lines • Show All 117 Lines • ▼ Show 20 Lineswhile.end: ; preds = %if.then4
%private_1 = getelementptr inbounds %struct._Unwind_Exception, %struct._Unwind_Exception* %exc, i64 0, i32 2 %private_1 = getelementptr inbounds %struct._Unwind_Exception, %struct._Unwind_Exception* %exc, i64 0, i32 2
store i64 0, i64* %private_1, align 8 store i64 0, i64* %private_1, align 8
%15 = load i8*, i8** %ra.i, align 8 %15 = load i8*, i8** %ra.i, align 8
%16 = ptrtoint i8* %15 to i64 %16 = ptrtoint i8* %15 to i64
%private_2 = getelementptr inbounds %struct._Unwind_Exception, %struct._Unwind_Exception* %exc, i64 0, i32 3 %private_2 = getelementptr inbounds %struct._Unwind_Exception, %struct._Unwind_Exception* %exc, i64 0, i32 3
store i64 %16, i64* %private_2, align 8 store i64 %16, i64* %private_2, align 8
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %2, i8* %3, i64 240, i32 8, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %2, i8* %3, i64 240, i32 8, i1 false)
%17 = bitcast %struct._Unwind_FrameState* %fs.i to i8* %17 = bitcast %struct._Unwind_FrameState* %fs.i to i8*
call void @llvm.lifetime.start(i64 -1, i8* %17) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %17)
%personality.i = getelementptr inbounds %struct._Unwind_FrameState, %struct._Unwind_FrameState* %fs.i, i64 0, i32 6 %personality.i = getelementptr inbounds %struct._Unwind_FrameState, %struct._Unwind_FrameState* %fs.i, i64 0, i32 6
%retaddr_column.i22 = getelementptr inbounds %struct._Unwind_FrameState, %struct._Unwind_FrameState* %fs.i, i64 0, i32 9 %retaddr_column.i22 = getelementptr inbounds %struct._Unwind_FrameState, %struct._Unwind_FrameState* %fs.i, i64 0, i32 9
br label %while.body.i br label %while.body.i
while.body.i: ; preds = %uw_update_context.exit44, %while.end while.body.i: ; preds = %uw_update_context.exit44, %while.end
%call.i = call fastcc i32 @uw_frame_state_for(%struct._Unwind_Context* %cur_context, %struct._Unwind_FrameState* %fs.i) %call.i = call fastcc i32 @uw_frame_state_for(%struct._Unwind_Context* %cur_context, %struct._Unwind_FrameState* %fs.i)
%18 = load i8*, i8** %ra.i, align 8 %18 = load i8*, i8** %ra.i, align 8
%19 = ptrtoint i8* %18 to i64 %19 = ptrtoint i8* %18 to i64
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines
uw_update_context.exit44: ; preds = %if.then10.i.i.i40, %if.then.i.i.i37 uw_update_context.exit44: ; preds = %if.then10.i.i.i40, %if.then.i.i.i37
%retval.0.i.i.i42 = phi i64 [ %28, %if.then.i.i.i37 ], [ %30, %if.then10.i.i.i40 ] %retval.0.i.i.i42 = phi i64 [ %28, %if.then.i.i.i37 ], [ %30, %if.then10.i.i.i40 ]
%31 = inttoptr i64 %retval.0.i.i.i42 to i8* %31 = inttoptr i64 %retval.0.i.i.i42 to i8*
store i8* %31, i8** %ra.i, align 8 store i8* %31, i8** %ra.i, align 8
br label %while.body.i br label %while.body.i
do.body19: ; preds = %if.then3.i do.body19: ; preds = %if.then3.i
call void @llvm.lifetime.end(i64 -1, i8* %17) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %17)
%call20 = call fastcc i64 @uw_install_context_1(%struct._Unwind_Context* %this_context, %struct._Unwind_Context* %cur_context) %call20 = call fastcc i64 @uw_install_context_1(%struct._Unwind_Context* %this_context, %struct._Unwind_Context* %cur_context)
%32 = load i8*, i8** %ra.i, align 8 %32 = load i8*, i8** %ra.i, align 8
call void @llvm.eh.return.i64(i64 %call20, i8* %32) call void @llvm.eh.return.i64(i64 %call20, i8* %32)
unreachable unreachable
do.end21.loopexit46: ; preds = %if.then4, %while.body do.end21.loopexit46: ; preds = %if.then4, %while.body
%retval.0.ph = phi i32 [ 3, %if.then4 ], [ 5, %while.body ] %retval.0.ph = phi i32 [ 3, %if.then4 ], [ 5, %while.body ]
br label %do.end21 br label %do.end21
Show All 14 Lines
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i32, i1) nounwind declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i32, i1) nounwind
declare fastcc i64 @uw_install_context_1(%struct._Unwind_Context*, %struct._Unwind_Context*) uwtable declare fastcc i64 @uw_install_context_1(%struct._Unwind_Context*, %struct._Unwind_Context*) uwtable
declare void @llvm.eh.return.i64(i64, i8*) nounwind declare void @llvm.eh.return.i64(i64, i8*) nounwind
declare fastcc void @uw_update_context_1(%struct._Unwind_Context*, %struct._Unwind_FrameState* nocapture) uwtable declare fastcc void @uw_update_context_1(%struct._Unwind_Context*, %struct._Unwind_FrameState* nocapture) uwtable
declare void @llvm.lifetime.start(i64, i8* nocapture) nounwind declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) nounwind declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) nounwind

test/CodeGen/X86/x32-va_start.ll

Show All 18 Lines
target triple = "x86_64-unknown-linux-gnux32" target triple = "x86_64-unknown-linux-gnux32"
%struct.__va_list_tag = type { i32, i32, i8*, i8* } %struct.__va_list_tag = type { i32, i32, i8*, i8* }
define i32 @foo(float %a, i8* nocapture readnone %fmt, ...) nounwind { define i32 @foo(float %a, i8* nocapture readnone %fmt, ...) nounwind {
entry: entry:
%ap = alloca [1 x %struct.__va_list_tag], align 16 %ap = alloca [1 x %struct.__va_list_tag], align 16
%0 = bitcast [1 x %struct.__va_list_tag]* %ap to i8* %0 = bitcast [1 x %struct.__va_list_tag]* %ap to i8*
call void @llvm.lifetime.start(i64 16, i8* %0) #2 call void @llvm.lifetime.start.p0i8(i64 16, i8* %0) #2
call void @llvm.va_start(i8* %0) call void @llvm.va_start(i8* %0)
; SSE: subl $72, %esp ; SSE: subl $72, %esp
; SSE: testb %al, %al ; SSE: testb %al, %al
; SSE: je .[[NOFP:.*]] ; SSE: je .[[NOFP:.*]]
; SSE-DAG: movaps %xmm1 ; SSE-DAG: movaps %xmm1
; SSE-DAG: movaps %xmm2 ; SSE-DAG: movaps %xmm2
; SSE-DAG: movaps %xmm3 ; SSE-DAG: movaps %xmm3
; SSE-DAG: movaps %xmm4 ; SSE-DAG: movaps %xmm4
Show All 38 Lines
; NOSSE: retq ; NOSSE: retq
; SSE: .[[END]]: ; SSE: .[[END]]:
vaarg.end: ; preds = %vaarg.in_mem, %vaarg.in_reg vaarg.end: ; preds = %vaarg.in_mem, %vaarg.in_reg
%vaarg.addr.in = phi i8* [ %2, %vaarg.in_reg ], [ %overflow_arg_area, %vaarg.in_mem ] %vaarg.addr.in = phi i8* [ %2, %vaarg.in_reg ], [ %overflow_arg_area, %vaarg.in_mem ]
%vaarg.addr = bitcast i8* %vaarg.addr.in to i32* %vaarg.addr = bitcast i8* %vaarg.addr.in to i32*
%4 = load i32, i32* %vaarg.addr, align 4 %4 = load i32, i32* %vaarg.addr, align 4
call void @llvm.va_end(i8* %0) call void @llvm.va_end(i8* %0)
call void @llvm.lifetime.end(i64 16, i8* %0) #2 call void @llvm.lifetime.end.p0i8(i64 16, i8* %0) #2
ret i32 %4 ret i32 %4
; SSE: movl ([[ADDR]]), %eax ; SSE: movl ([[ADDR]]), %eax
; SSE: retq ; SSE: retq
} }
; Function Attrs: nounwind argmemonly ; Function Attrs: nounwind argmemonly
declare void @llvm.lifetime.start(i64, i8* nocapture) nounwind declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.va_start(i8*) nounwind declare void @llvm.va_start(i8*) nounwind
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.va_end(i8*) nounwind declare void @llvm.va_end(i8*) nounwind
; Function Attrs: nounwind argmemonly ; Function Attrs: nounwind argmemonly
declare void @llvm.lifetime.end(i64, i8* nocapture) nounwind declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) nounwind

test/Instrumentation/AddressSanitizer/lifetime-throw.ll

Show All 17 Lines
; CHECK-LABEL: define void @Throw() ; CHECK-LABEL: define void @Throw()
entry: entry:
%x = alloca %struct.ABC, align 4 %x = alloca %struct.ABC, align 4
%0 = bitcast %struct.ABC* %x to i8* %0 = bitcast %struct.ABC* %x to i8*
; Poison memory in prologue: F1F1F1F1F8F3F3F3 ; Poison memory in prologue: F1F1F1F1F8F3F3F3
; CHECK: store i64 -868082052615769615, i64* %{{[0-9]+}} ; CHECK: store i64 -868082052615769615, i64* %{{[0-9]+}}
call void @llvm.lifetime.start(i64 4, i8* %0) call void @llvm.lifetime.start.p0i8(i64 4, i8* %0)
; CHECK: store i8 4, i8* %{{[0-9]+}} ; CHECK: store i8 4, i8* %{{[0-9]+}}
; CHECK-NEXT: @llvm.lifetime.start ; CHECK-NEXT: @llvm.lifetime.start
%exception = call i8* @__cxa_allocate_exception(i64 4) %exception = call i8* @__cxa_allocate_exception(i64 4)
invoke void @__cxa_throw(i8* %exception, i8* bitcast ({ i8*, i8* }* @_ZTI3ABC to i8*), i8* bitcast (void (%struct.ABC*)* @_ZN3ABCD2Ev to i8*)) noreturn invoke void @__cxa_throw(i8* %exception, i8* bitcast ({ i8*, i8* }* @_ZTI3ABC to i8*), i8* bitcast (void (%struct.ABC*)* @_ZN3ABCD2Ev to i8*)) noreturn
to label %unreachable unwind label %lpad to label %unreachable unwind label %lpad
; CHECK: call void @__asan_handle_no_return ; CHECK: call void @__asan_handle_no_return
; CHECK-NEXT: @__cxa_throw ; CHECK-NEXT: @__cxa_throw
lpad: lpad:
%1 = landingpad { i8*, i32 } %1 = landingpad { i8*, i32 }
cleanup cleanup
call void @_ZN3ABCD2Ev(%struct.ABC* nonnull %x) call void @_ZN3ABCD2Ev(%struct.ABC* nonnull %x)
call void @llvm.lifetime.end(i64 4, i8* %0) call void @llvm.lifetime.end.p0i8(i64 4, i8* %0)
; CHECK: store i8 -8, i8* %{{[0-9]+}} ; CHECK: store i8 -8, i8* %{{[0-9]+}}
; CHECK-NEXT: @llvm.lifetime.end ; CHECK-NEXT: @llvm.lifetime.end
resume { i8*, i32 } %1 resume { i8*, i32 } %1
; CHECK: store i64 0, i64* %{{[0-9]+}} ; CHECK: store i64 0, i64* %{{[0-9]+}}
; CHECK-NEXT: resume ; CHECK-NEXT: resume
unreachable: unreachable:
Show All 23 Lines
entry: entry:
%x = alloca %struct.ABC, align 4 %x = alloca %struct.ABC, align 4
%tmp = alloca %struct.ABC, align 4 %tmp = alloca %struct.ABC, align 4
%0 = bitcast %struct.ABC* %x to i8* %0 = bitcast %struct.ABC* %x to i8*
; Poison memory in prologue: F1F1F1F1F8F304F2 ; Poison memory in prologue: F1F1F1F1F8F304F2
; CHECK: store i64 -935355671561244175, i64* %{{[0-9]+}} ; CHECK: store i64 -935355671561244175, i64* %{{[0-9]+}}
call void @llvm.lifetime.start(i64 4, i8* %0) call void @llvm.lifetime.start.p0i8(i64 4, i8* %0)
; CHECK: store i8 4, i8* %{{[0-9]+}} ; CHECK: store i8 4, i8* %{{[0-9]+}}
; CHECK-NEXT: @llvm.lifetime.start ; CHECK-NEXT: @llvm.lifetime.start
%1 = bitcast %struct.ABC* %tmp to i8* %1 = bitcast %struct.ABC* %tmp to i8*
invoke void @_CxxThrowException(i8* %1, %eh.ThrowInfo* nonnull @"_TI1?AUABC@@") noreturn invoke void @_CxxThrowException(i8* %1, %eh.ThrowInfo* nonnull @"_TI1?AUABC@@") noreturn
to label %unreachable unwind label %ehcleanup to label %unreachable unwind label %ehcleanup
; CHECK: call void @__asan_handle_no_return ; CHECK: call void @__asan_handle_no_return
; CHECK-NEXT: @_CxxThrowException ; CHECK-NEXT: @_CxxThrowException
ehcleanup: ehcleanup:
%2 = cleanuppad within none [] %2 = cleanuppad within none []
call void @"\01??1ABC@@QEAA@XZ"(%struct.ABC* nonnull %x) [ "funclet"(token %2) ] call void @"\01??1ABC@@QEAA@XZ"(%struct.ABC* nonnull %x) [ "funclet"(token %2) ]
call void @llvm.lifetime.end(i64 4, i8* %0) call void @llvm.lifetime.end.p0i8(i64 4, i8* %0)
; CHECK: store i8 -8, i8* %{{[0-9]+}} ; CHECK: store i8 -8, i8* %{{[0-9]+}}
; CHECK-NEXT: @llvm.lifetime.end ; CHECK-NEXT: @llvm.lifetime.end
cleanupret from %2 unwind to caller cleanupret from %2 unwind to caller
; CHECK: store i64 0, i64* %{{[0-9]+}} ; CHECK: store i64 0, i64* %{{[0-9]+}}
; CHECK-NEXT: cleanupret ; CHECK-NEXT: cleanupret
unreachable: unreachable:
unreachable unreachable
} }
declare i32 @__gxx_personality_v0(...) declare i32 @__gxx_personality_v0(...)
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
declare void @__cxa_throw(i8*, i8*, i8*) local_unnamed_addr declare void @__cxa_throw(i8*, i8*, i8*) local_unnamed_addr
declare i8* @__cxa_allocate_exception(i64) local_unnamed_addr declare i8* @__cxa_allocate_exception(i64) local_unnamed_addr
declare void @_ZN3ABCD2Ev(%struct.ABC* %this) unnamed_addr declare void @_ZN3ABCD2Ev(%struct.ABC* %this) unnamed_addr
declare void @"\01??1ABC@@QEAA@XZ"(%struct.ABC* %this) declare void @"\01??1ABC@@QEAA@XZ"(%struct.ABC* %this)
declare void @_CxxThrowException(i8*, %eh.ThrowInfo*) declare void @_CxxThrowException(i8*, %eh.ThrowInfo*)
declare i32 @__CxxFrameHandler3(...) declare i32 @__CxxFrameHandler3(...)

test/Instrumentation/AddressSanitizer/lifetime-uar-uas.ll

; Test handling of llvm.lifetime intrinsics in UAR/UAS modes. ; Test handling of llvm.lifetime intrinsics in UAR/UAS modes.
; RUN: opt < %s -asan -asan-module -asan-use-after-return=0 -asan-use-after-scope=0 -S | FileCheck %s ; RUN: opt < %s -asan -asan-module -asan-use-after-return=0 -asan-use-after-scope=0 -S | FileCheck %s
; RUN: opt < %s -asan -asan-module -asan-use-after-return=1 -asan-use-after-scope=0 -S | FileCheck %s ; RUN: opt < %s -asan -asan-module -asan-use-after-return=1 -asan-use-after-scope=0 -S | FileCheck %s
; RUN: opt < %s -asan -asan-module -asan-use-after-return=0 -asan-use-after-scope=1 -S | FileCheck %s --check-prefix=CHECK-UAS ; RUN: opt < %s -asan -asan-module -asan-use-after-return=0 -asan-use-after-scope=1 -S | FileCheck %s --check-prefix=CHECK-UAS
; RUN: opt < %s -asan -asan-module -asan-use-after-return=1 -asan-use-after-scope=1 -S | FileCheck %s --check-prefix=CHECK-UAS ; RUN: opt < %s -asan -asan-module -asan-use-after-return=1 -asan-use-after-scope=1 -S | FileCheck %s --check-prefix=CHECK-UAS
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.lifetime.start(i64, i8* nocapture) nounwind declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) nounwind declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) nounwind
define i32 @basic_test() sanitize_address { define i32 @basic_test() sanitize_address {
; CHECK-LABEL: define i32 @basic_test() ; CHECK-LABEL: define i32 @basic_test()
entry: entry:
%retval = alloca i32, align 4 %retval = alloca i32, align 4
%c = alloca i8, align 1 %c = alloca i8, align 1
; Memory is poisoned in prologue: F1F1F1F104F3F8F2 ; Memory is poisoned in prologue: F1F1F1F104F3F8F2
; CHECK-UAS: store i64 -866676825215864335, i64* %{{[0-9]+}} ; CHECK-UAS: store i64 -866676825215864335, i64* %{{[0-9]+}}
call void @llvm.lifetime.start(i64 1, i8* %c) call void @llvm.lifetime.start.p0i8(i64 1, i8* %c)
; Memory is unpoisoned at llvm.lifetime.start: 01 ; Memory is unpoisoned at llvm.lifetime.start: 01
; CHECK-UAS: store i8 1, i8* %{{[0-9]+}} ; CHECK-UAS: store i8 1, i8* %{{[0-9]+}}
store volatile i32 0, i32* %retval store volatile i32 0, i32* %retval
store volatile i8 0, i8* %c, align 1 store volatile i8 0, i8* %c, align 1
call void @llvm.lifetime.end(i64 1, i8* %c) call void @llvm.lifetime.end.p0i8(i64 1, i8* %c)
; Memory is poisoned at llvm.lifetime.end: F8 ; Memory is poisoned at llvm.lifetime.end: F8
; CHECK-UAS: store i8 -8, i8* %{{[0-9]+}} ; CHECK-UAS: store i8 -8, i8* %{{[0-9]+}}
; Unpoison memory at function exit in UAS mode. ; Unpoison memory at function exit in UAS mode.
; CHECK-UAS: store i64 0, i64* %{{[0-9]+}} ; CHECK-UAS: store i64 0, i64* %{{[0-9]+}}
; CHECK-UAS: ret i32 0 ; CHECK-UAS: ret i32 0
ret i32 0 ret i32 0
} }
; No poisoning/poisoning at all in plain mode. ; No poisoning/poisoning at all in plain mode.
; CHECK-NOT: __asan_poison_stack_memory ; CHECK-NOT: __asan_poison_stack_memory
; CHECK-NOT: __asan_unpoison_stack_memory ; CHECK-NOT: __asan_unpoison_stack_memory

test/Instrumentation/AddressSanitizer/lifetime.ll

; Test handling of llvm.lifetime intrinsics. ; Test handling of llvm.lifetime intrinsics.
; RUN: opt < %s -asan -asan-module -asan-use-after-scope -asan-use-after-return=0 -S | FileCheck %s --check-prefixes=CHECK,CHECK-DEFAULT ; RUN: opt < %s -asan -asan-module -asan-use-after-scope -asan-use-after-return=0 -S | FileCheck %s --check-prefixes=CHECK,CHECK-DEFAULT
; RUN: opt < %s -asan -asan-module -asan-use-after-scope -asan-use-after-return=0 -asan-instrument-dynamic-allocas=0 -S | FileCheck %s --check-prefixes=CHECK,CHECK-NO-DYNAMIC ; RUN: opt < %s -asan -asan-module -asan-use-after-scope -asan-use-after-return=0 -asan-instrument-dynamic-allocas=0 -S | FileCheck %s --check-prefixes=CHECK,CHECK-NO-DYNAMIC
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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
declare void @llvm.lifetime.start(i64, i8* nocapture) nounwind declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) nounwind declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) nounwind
define void @lifetime_no_size() sanitize_address { define void @lifetime_no_size() sanitize_address {
; CHECK-LABEL: define void @lifetime_no_size() ; CHECK-LABEL: define void @lifetime_no_size()
entry: entry:
%i = alloca i32, align 4 %i = alloca i32, align 4
%i.ptr = bitcast i32* %i to i8* %i.ptr = bitcast i32* %i to i8*
; Poison memory in prologue: F1F1F1F104F3F3F3 ; Poison memory in prologue: F1F1F1F104F3F3F3
; CHECK: store i64 -868083100587789839, i64* %{{[0-9]+}} ; CHECK: store i64 -868083100587789839, i64* %{{[0-9]+}}
call void @llvm.lifetime.start(i64 -1, i8* %i.ptr) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %i.ptr)
; Check that lifetime with no size are ignored. ; Check that lifetime with no size are ignored.
; CHECK-NOT: store ; CHECK-NOT: store
; CHECK: call void @llvm.lifetime.start ; CHECK: call void @llvm.lifetime.start
store volatile i8 0, i8* %i.ptr store volatile i8 0, i8* %i.ptr
; CHECK: store volatile ; CHECK: store volatile
call void @llvm.lifetime.end(i64 -1, i8* %i.ptr) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %i.ptr)
; Check that lifetime with no size are ignored. ; Check that lifetime with no size are ignored.
; CHECK-NOT: store ; CHECK-NOT: store
; CHECK: call void @llvm.lifetime.end ; CHECK: call void @llvm.lifetime.end
; Unpoison stack frame on exit. ; Unpoison stack frame on exit.
; CHECK: store i64 0, i64* %{{[0-9]+}} ; CHECK: store i64 0, i64* %{{[0-9]+}}
; CHECK: ret void ; CHECK: ret void
ret void ret void
} }
; Generic case of lifetime analysis. ; Generic case of lifetime analysis.
define void @lifetime() sanitize_address { define void @lifetime() sanitize_address {
; CHECK-LABEL: define void @lifetime() ; CHECK-LABEL: define void @lifetime()
; Regular variable lifetime intrinsics. ; Regular variable lifetime intrinsics.
%i = alloca i32, align 4 %i = alloca i32, align 4
%i.ptr = bitcast i32* %i to i8* %i.ptr = bitcast i32* %i to i8*
; Poison memory in prologue: F1F1F1F1F8F3F3F3 ; Poison memory in prologue: F1F1F1F1F8F3F3F3
; CHECK: store i64 -868082052615769615, i64* %{{[0-9]+}} ; CHECK: store i64 -868082052615769615, i64* %{{[0-9]+}}
; Memory is unpoisoned at llvm.lifetime.start ; Memory is unpoisoned at llvm.lifetime.start
call void @llvm.lifetime.start(i64 3, i8* %i.ptr) call void @llvm.lifetime.start.p0i8(i64 3, i8* %i.ptr)
; CHECK: store i8 4, i8* %{{[0-9]+}} ; CHECK: store i8 4, i8* %{{[0-9]+}}
; CHECK-NEXT: llvm.lifetime.start ; CHECK-NEXT: llvm.lifetime.start
store volatile i8 0, i8* %i.ptr store volatile i8 0, i8* %i.ptr
; CHECK: store volatile ; CHECK: store volatile
call void @llvm.lifetime.end(i64 4, i8* %i.ptr) call void @llvm.lifetime.end.p0i8(i64 4, i8* %i.ptr)
; CHECK: store i8 -8, i8* %{{[0-9]+}} ; CHECK: store i8 -8, i8* %{{[0-9]+}}
; CHECK-NEXT: call void @llvm.lifetime.end ; CHECK-NEXT: call void @llvm.lifetime.end
; Memory is poisoned at every call to llvm.lifetime.end ; Memory is poisoned at every call to llvm.lifetime.end
call void @llvm.lifetime.end(i64 2, i8* %i.ptr) call void @llvm.lifetime.end.p0i8(i64 2, i8* %i.ptr)
; CHECK: store i8 -8, i8* %{{[0-9]+}} ; CHECK: store i8 -8, i8* %{{[0-9]+}}
; CHECK-NEXT: call void @llvm.lifetime.end ; CHECK-NEXT: call void @llvm.lifetime.end
; Lifetime intrinsics for array. ; Lifetime intrinsics for array.
%arr = alloca [10 x i32], align 16 %arr = alloca [10 x i32], align 16
%arr.ptr = bitcast [10 x i32]* %arr to i8* %arr.ptr = bitcast [10 x i32]* %arr to i8*
call void @llvm.lifetime.start(i64 40, i8* %arr.ptr) call void @llvm.lifetime.start.p0i8(i64 40, i8* %arr.ptr)
; CHECK-DEFAULT: call void @__asan_unpoison_stack_memory(i64 %{{[^ ]+}}, i64 40) ; CHECK-DEFAULT: call void @__asan_unpoison_stack_memory(i64 %{{[^ ]+}}, i64 40)
; CHECK-NO-DYNAMIC-NOT: call void @__asan_unpoison_stack_memory(i64 %{{[^ ]+}}, i64 40) ; CHECK-NO-DYNAMIC-NOT: call void @__asan_unpoison_stack_memory(i64 %{{[^ ]+}}, i64 40)
store volatile i8 0, i8* %arr.ptr store volatile i8 0, i8* %arr.ptr
; CHECK: store volatile ; CHECK: store volatile
call void @llvm.lifetime.end(i64 40, i8* %arr.ptr) call void @llvm.lifetime.end.p0i8(i64 40, i8* %arr.ptr)
; CHECK-DEFAULT: call void @__asan_poison_stack_memory(i64 %{{[^ ]+}}, i64 40) ; CHECK-DEFAULT: call void @__asan_poison_stack_memory(i64 %{{[^ ]+}}, i64 40)
; CHECK-NO-DYNAMIC-NOT: call void @__asan_poison_stack_memory(i64 %{{[^ ]+}}, i64 40) ; CHECK-NO-DYNAMIC-NOT: call void @__asan_poison_stack_memory(i64 %{{[^ ]+}}, i64 40)
; One more lifetime start/end for the same variable %i. ; One more lifetime start/end for the same variable %i.
call void @llvm.lifetime.start(i64 2, i8* %i.ptr) call void @llvm.lifetime.start.p0i8(i64 2, i8* %i.ptr)
; CHECK: store i8 4, i8* %{{[0-9]+}} ; CHECK: store i8 4, i8* %{{[0-9]+}}
; CHECK-NEXT: llvm.lifetime.start ; CHECK-NEXT: llvm.lifetime.start
store volatile i8 0, i8* %i.ptr store volatile i8 0, i8* %i.ptr
; CHECK: store volatile ; CHECK: store volatile
call void @llvm.lifetime.end(i64 4, i8* %i.ptr) call void @llvm.lifetime.end.p0i8(i64 4, i8* %i.ptr)
; CHECK: store i8 -8, i8* %{{[0-9]+}} ; CHECK: store i8 -8, i8* %{{[0-9]+}}
; CHECK-NEXT: llvm.lifetime.end ; CHECK-NEXT: llvm.lifetime.end
; Memory is unpoisoned at function exit (only once). ; Memory is unpoisoned at function exit (only once).
; CHECK: store i64 0, i64* %{{[0-9]+}} ; CHECK: store i64 0, i64* %{{[0-9]+}}
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
ret void ret void
} }
; Check that arguments of lifetime may come from phi nodes. ; Check that arguments of lifetime may come from phi nodes.
define void @phi_args(i1 %x) sanitize_address { define void @phi_args(i1 %x) sanitize_address {
; CHECK-LABEL: define void @phi_args(i1 %x) ; CHECK-LABEL: define void @phi_args(i1 %x)
entry: entry:
%i = alloca i64, align 4 %i = alloca i64, align 4
%i.ptr = bitcast i64* %i to i8* %i.ptr = bitcast i64* %i to i8*
; Poison memory in prologue: F1F1F1F1F8F3F3F3 ; Poison memory in prologue: F1F1F1F1F8F3F3F3
; CHECK: store i64 -868082052615769615, i64* %{{[0-9]+}} ; CHECK: store i64 -868082052615769615, i64* %{{[0-9]+}}
call void @llvm.lifetime.start(i64 8, i8* %i.ptr) call void @llvm.lifetime.start.p0i8(i64 8, i8* %i.ptr)
; CHECK: store i8 0, i8* %{{[0-9]+}} ; CHECK: store i8 0, i8* %{{[0-9]+}}
; CHECK-NEXT: llvm.lifetime.start ; CHECK-NEXT: llvm.lifetime.start
store volatile i8 0, i8* %i.ptr store volatile i8 0, i8* %i.ptr
; CHECK: store volatile ; CHECK: store volatile
br i1 %x, label %bb0, label %bb1 br i1 %x, label %bb0, label %bb1
bb0: bb0:
%i.ptr2 = bitcast i64* %i to i8* %i.ptr2 = bitcast i64* %i to i8*
br label %bb1 br label %bb1
bb1: bb1:
%i.phi = phi i8* [ %i.ptr, %entry ], [ %i.ptr2, %bb0 ] %i.phi = phi i8* [ %i.ptr, %entry ], [ %i.ptr2, %bb0 ]
call void @llvm.lifetime.end(i64 8, i8* %i.phi) call void @llvm.lifetime.end.p0i8(i64 8, i8* %i.phi)
; CHECK: store i8 -8, i8* %{{[0-9]+}} ; CHECK: store i8 -8, i8* %{{[0-9]+}}
; CHECK-NEXT: llvm.lifetime.end ; CHECK-NEXT: llvm.lifetime.end
ret void ret void
; CHECK: store i64 0, i64* %{{[0-9]+}} ; CHECK: store i64 0, i64* %{{[0-9]+}}
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
} }
; Check that arguments of lifetime may come from getelementptr nodes. ; Check that arguments of lifetime may come from getelementptr nodes.
define void @getelementptr_args() sanitize_address{ define void @getelementptr_args() sanitize_address{
; CHECK-LABEL: define void @getelementptr_args ; CHECK-LABEL: define void @getelementptr_args
entry: entry:
%x = alloca [1024 x i8], align 16 %x = alloca [1024 x i8], align 16
%d = alloca i8*, align 8 %d = alloca i8*, align 8
; F1F1F1F1 ; F1F1F1F1
; CHECK: store i32 -235802127, i32* %{{[0-9]+}} ; CHECK: store i32 -235802127, i32* %{{[0-9]+}}
; F3F3F3F3F3F3F3F3 ; F3F3F3F3F3F3F3F3
; CHECK: store i64 -868082074056920077, i64* %{{[0-9]+}} ; CHECK: store i64 -868082074056920077, i64* %{{[0-9]+}}
; F3F3F3F3F3F3F3F3 ; F3F3F3F3F3F3F3F3
; CHECK: store i64 -868082074056920077, i64* %{{[0-9]+}} ; CHECK: store i64 -868082074056920077, i64* %{{[0-9]+}}
%0 = getelementptr inbounds [1024 x i8], [1024 x i8]* %x, i64 0, i64 0 %0 = getelementptr inbounds [1024 x i8], [1024 x i8]* %x, i64 0, i64 0
call void @llvm.lifetime.start(i64 1024, i8* %0) call void @llvm.lifetime.start.p0i8(i64 1024, i8* %0)
; CHECK: call void @__asan_set_shadow_00(i64 %{{[0-9]+}}, i64 128) ; CHECK: call void @__asan_set_shadow_00(i64 %{{[0-9]+}}, i64 128)
; CHECK-NEXT: call void @llvm.lifetime.start ; CHECK-NEXT: call void @llvm.lifetime.start
store i8* %0, i8** %d, align 8 store i8* %0, i8** %d, align 8
; CHECK: store i8 ; CHECK: store i8
call void @llvm.lifetime.end(i64 1024, i8* %0) call void @llvm.lifetime.end.p0i8(i64 1024, i8* %0)
; CHECK: call void @__asan_set_shadow_f8(i64 %{{[0-9]+}}, i64 128) ; CHECK: call void @__asan_set_shadow_f8(i64 %{{[0-9]+}}, i64 128)
; CHECK-NEXT: call void @llvm.lifetime.end ; CHECK-NEXT: call void @llvm.lifetime.end
ret void ret void
; CHECK: call void @__asan_set_shadow_00(i64 %{{[0-9]+}}, i64 148) ; CHECK: call void @__asan_set_shadow_00(i64 %{{[0-9]+}}, i64 148)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
} }
define void @zero_sized(i64 %a) #0 { define void @zero_sized(i64 %a) #0 {
; CHECK-LABEL: define void @zero_sized(i64 %a) ; CHECK-LABEL: define void @zero_sized(i64 %a)
entry: entry:
%a.addr = alloca i64, align 8 %a.addr = alloca i64, align 8
%b = alloca [0 x i8], align 1 %b = alloca [0 x i8], align 1
store i64 %a, i64* %a.addr, align 8 store i64 %a, i64* %a.addr, align 8
%0 = bitcast [0 x i8]* %b to i8* %0 = bitcast [0 x i8]* %b to i8*
call void @llvm.lifetime.start(i64 0, i8* %0) #2 call void @llvm.lifetime.start.p0i8(i64 0, i8* %0) #2
; CHECK: %{{[0-9]+}} = bitcast ; CHECK: %{{[0-9]+}} = bitcast
; CHECK-NEXT: call void @llvm.lifetime.start ; CHECK-NEXT: call void @llvm.lifetime.start
%1 = bitcast [0 x i8]* %b to i8* %1 = bitcast [0 x i8]* %b to i8*
call void @llvm.lifetime.end(i64 0, i8* %1) #2 call void @llvm.lifetime.end.p0i8(i64 0, i8* %1) #2
; CHECK-NEXT: %{{[0-9]+}} = bitcast ; CHECK-NEXT: %{{[0-9]+}} = bitcast
; CHECK-NEXT: call void @llvm.lifetime.end ; CHECK-NEXT: call void @llvm.lifetime.end
ret void ret void
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
} }

test/Instrumentation/AddressSanitizer/stack-poisoning-and-lifetime-be.ll

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Linesentry:
; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i16]]* ; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i16]]*
; ENTRY-UAS-NEXT: store [[TYPE]] -3085, [[TYPE]]* [[PTR]], align 1 ; ENTRY-UAS-NEXT: store [[TYPE]] -3085, [[TYPE]]* [[PTR]], align 1
; CHECK-LABEL: %xx = getelementptr inbounds ; CHECK-LABEL: %xx = getelementptr inbounds
; CHECK-NEXT: %yy = getelementptr inbounds ; CHECK-NEXT: %yy = getelementptr inbounds
; CHECK-NEXT: %zz = getelementptr inbounds ; CHECK-NEXT: %zz = getelementptr inbounds
call void @llvm.lifetime.start(i64 650, i8* %xx) call void @llvm.lifetime.start.p0i8(i64 650, i8* %xx)
; 0000... ; 0000...
; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 4 ; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 4
; ENTRY-UAS-NEXT: call void @__asan_set_shadow_00(i64 [[OFFSET]], i64 81) ; ENTRY-UAS-NEXT: call void @__asan_set_shadow_00(i64 [[OFFSET]], i64 81)
; 02 ; 02
; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 85 ; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 85
; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i8]]* ; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i8]]*
; ENTRY-UAS-NEXT: store [[TYPE]] 2, [[TYPE]]* [[PTR]], align 1 ; ENTRY-UAS-NEXT: store [[TYPE]] 2, [[TYPE]]* [[PTR]], align 1
; CHECK-NEXT: call void @llvm.lifetime.start(i64 650, i8* %xx) ; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 650, i8* %xx)
call void @Foo(i8* %xx) call void @Foo(i8* %xx)
; CHECK-NEXT: call void @Foo(i8* %xx) ; CHECK-NEXT: call void @Foo(i8* %xx)
call void @llvm.lifetime.end(i64 650, i8* %xx) call void @llvm.lifetime.end.p0i8(i64 650, i8* %xx)
; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 4 ; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 4
; ENTRY-UAS-NEXT: call void @__asan_set_shadow_f8(i64 [[OFFSET]], i64 82) ; ENTRY-UAS-NEXT: call void @__asan_set_shadow_f8(i64 [[OFFSET]], i64 82)
; CHECK-NEXT: call void @llvm.lifetime.end(i64 650, i8* %xx) ; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 650, i8* %xx)
call void @llvm.lifetime.start(i64 13, i8* %yy) call void @llvm.lifetime.start.p0i8(i64 13, i8* %yy)
; 0005 ; 0005
; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 102 ; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 102
; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i16]]* ; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i16]]*
; ENTRY-UAS-NEXT: store [[TYPE]] 5, [[TYPE]]* [[PTR]], align 1 ; ENTRY-UAS-NEXT: store [[TYPE]] 5, [[TYPE]]* [[PTR]], align 1
; CHECK-NEXT: call void @llvm.lifetime.start(i64 13, i8* %yy) ; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 13, i8* %yy)
call void @Foo(i8* %yy) call void @Foo(i8* %yy)
; CHECK-NEXT: call void @Foo(i8* %yy) ; CHECK-NEXT: call void @Foo(i8* %yy)
call void @llvm.lifetime.end(i64 13, i8* %yy) call void @llvm.lifetime.end.p0i8(i64 13, i8* %yy)
; F8F8 ; F8F8
; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 102 ; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 102
; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i16]]* ; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i16]]*
; ENTRY-UAS-NEXT: store [[TYPE]] -1800, [[TYPE]]* [[PTR]], align 1 ; ENTRY-UAS-NEXT: store [[TYPE]] -1800, [[TYPE]]* [[PTR]], align 1
; CHECK-NEXT: call void @llvm.lifetime.end(i64 13, i8* %yy) ; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 13, i8* %yy)
call void @llvm.lifetime.start(i64 40, i8* %zz) call void @llvm.lifetime.start.p0i8(i64 40, i8* %zz)
; 00000000 ; 00000000
; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 106 ; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 106
; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i32]]* ; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i32]]*
; ENTRY-UAS-NEXT: store [[TYPE]] 0, [[TYPE]]* [[PTR]], align 1 ; ENTRY-UAS-NEXT: store [[TYPE]] 0, [[TYPE]]* [[PTR]], align 1
; 00 ; 00
; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 110 ; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 110
; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i8]]* ; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i8]]*
; ENTRY-UAS-NEXT: store [[TYPE]] 0, [[TYPE]]* [[PTR]], align 1 ; ENTRY-UAS-NEXT: store [[TYPE]] 0, [[TYPE]]* [[PTR]], align 1
; CHECK-NEXT: call void @llvm.lifetime.start(i64 40, i8* %zz) ; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 40, i8* %zz)
call void @Foo(i8* %zz) call void @Foo(i8* %zz)
; CHECK-NEXT: call void @Foo(i8* %zz) ; CHECK-NEXT: call void @Foo(i8* %zz)
call void @llvm.lifetime.end(i64 40, i8* %zz) call void @llvm.lifetime.end.p0i8(i64 40, i8* %zz)
; F8F8F8F8 ; F8F8F8F8
; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 106 ; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 106
; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i32]]* ; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i32]]*
; ENTRY-UAS-NEXT: store [[TYPE]] -117901064, [[TYPE]]* [[PTR]], align 1 ; ENTRY-UAS-NEXT: store [[TYPE]] -117901064, [[TYPE]]* [[PTR]], align 1
; F8 ; F8
; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 110 ; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 110
; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i8]]* ; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i8]]*
; ENTRY-UAS-NEXT: store [[TYPE]] -8, [[TYPE]]* [[PTR]], align 1 ; ENTRY-UAS-NEXT: store [[TYPE]] -8, [[TYPE]]* [[PTR]], align 1
; CHECK-NEXT: call void @llvm.lifetime.end(i64 40, i8* %zz) ; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 40, i8* %zz)
; CHECK-LABEL: <label> ; CHECK-LABEL: <label>
; CHECK-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 0 ; CHECK-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 0
; CHECK-NEXT: call void @__asan_set_shadow_f5(i64 [[OFFSET]], i64 128) ; CHECK-NEXT: call void @__asan_set_shadow_f5(i64 [[OFFSET]], i64 128)
; CHECK-NOT: add i64 [[SHADOW_BASE]] ; CHECK-NOT: add i64 [[SHADOW_BASE]]
Show All 35 Linesentry:
; CHECK-NOT: add i64 [[SHADOW_BASE]] ; CHECK-NOT: add i64 [[SHADOW_BASE]]
ret void ret void
; CHECK-LABEL: <label> ; CHECK-LABEL: <label>
; CHECK: ret void ; CHECK: ret void
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
; CHECK-ON: declare void @__asan_set_shadow_00(i64, i64) ; CHECK-ON: declare void @__asan_set_shadow_00(i64, i64)
; CHECK-ON: declare void @__asan_set_shadow_f1(i64, i64) ; CHECK-ON: declare void @__asan_set_shadow_f1(i64, i64)
; CHECK-ON: declare void @__asan_set_shadow_f2(i64, i64) ; CHECK-ON: declare void @__asan_set_shadow_f2(i64, i64)
; CHECK-ON: declare void @__asan_set_shadow_f3(i64, i64) ; CHECK-ON: declare void @__asan_set_shadow_f3(i64, i64)
; CHECK-ON: declare void @__asan_set_shadow_f5(i64, i64) ; CHECK-ON: declare void @__asan_set_shadow_f5(i64, i64)
; CHECK-ON: declare void @__asan_set_shadow_f8(i64, i64) ; CHECK-ON: declare void @__asan_set_shadow_f8(i64, i64)
; CHECK-OFF-NOT: declare void @__asan_set_shadow_ ; CHECK-OFF-NOT: declare void @__asan_set_shadow_

test/Instrumentation/AddressSanitizer/stack-poisoning-and-lifetime.ll

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Linesentry:
; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i16]]* ; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i16]]*
; ENTRY-UAS-NEXT: store [[TYPE]] -3085, [[TYPE]]* [[PTR]], align 1 ; ENTRY-UAS-NEXT: store [[TYPE]] -3085, [[TYPE]]* [[PTR]], align 1
; CHECK-LABEL: %xx = getelementptr inbounds ; CHECK-LABEL: %xx = getelementptr inbounds
; CHECK-NEXT: %yy = getelementptr inbounds ; CHECK-NEXT: %yy = getelementptr inbounds
; CHECK-NEXT: %zz = getelementptr inbounds ; CHECK-NEXT: %zz = getelementptr inbounds
call void @llvm.lifetime.start(i64 650, i8* %xx) call void @llvm.lifetime.start.p0i8(i64 650, i8* %xx)
; 0000... ; 0000...
; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 4 ; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 4
; ENTRY-UAS-NEXT: call void @__asan_set_shadow_00(i64 [[OFFSET]], i64 81) ; ENTRY-UAS-NEXT: call void @__asan_set_shadow_00(i64 [[OFFSET]], i64 81)
; 02 ; 02
; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 85 ; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 85
; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i8]]* ; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i8]]*
; ENTRY-UAS-NEXT: store [[TYPE]] 2, [[TYPE]]* [[PTR]], align 1 ; ENTRY-UAS-NEXT: store [[TYPE]] 2, [[TYPE]]* [[PTR]], align 1
; CHECK-NEXT: call void @llvm.lifetime.start(i64 650, i8* %xx) ; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 650, i8* %xx)
call void @Foo(i8* %xx) call void @Foo(i8* %xx)
; CHECK-NEXT: call void @Foo(i8* %xx) ; CHECK-NEXT: call void @Foo(i8* %xx)
call void @llvm.lifetime.end(i64 650, i8* %xx) call void @llvm.lifetime.end.p0i8(i64 650, i8* %xx)
; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 4 ; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 4
; ENTRY-UAS-NEXT: call void @__asan_set_shadow_f8(i64 [[OFFSET]], i64 82) ; ENTRY-UAS-NEXT: call void @__asan_set_shadow_f8(i64 [[OFFSET]], i64 82)
; CHECK-NEXT: call void @llvm.lifetime.end(i64 650, i8* %xx) ; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 650, i8* %xx)
call void @llvm.lifetime.start(i64 13, i8* %yy) call void @llvm.lifetime.start.p0i8(i64 13, i8* %yy)
; 0005 ; 0005
; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 102 ; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 102
; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i16]]* ; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i16]]*
; ENTRY-UAS-NEXT: store [[TYPE]] 1280, [[TYPE]]* [[PTR]], align 1 ; ENTRY-UAS-NEXT: store [[TYPE]] 1280, [[TYPE]]* [[PTR]], align 1
; CHECK-NEXT: call void @llvm.lifetime.start(i64 13, i8* %yy) ; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 13, i8* %yy)
call void @Foo(i8* %yy) call void @Foo(i8* %yy)
; CHECK-NEXT: call void @Foo(i8* %yy) ; CHECK-NEXT: call void @Foo(i8* %yy)
call void @llvm.lifetime.end(i64 13, i8* %yy) call void @llvm.lifetime.end.p0i8(i64 13, i8* %yy)
; F8F8 ; F8F8
; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 102 ; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 102
; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i16]]* ; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i16]]*
; ENTRY-UAS-NEXT: store [[TYPE]] -1800, [[TYPE]]* [[PTR]], align 1 ; ENTRY-UAS-NEXT: store [[TYPE]] -1800, [[TYPE]]* [[PTR]], align 1
; CHECK-NEXT: call void @llvm.lifetime.end(i64 13, i8* %yy) ; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 13, i8* %yy)
call void @llvm.lifetime.start(i64 40, i8* %zz) call void @llvm.lifetime.start.p0i8(i64 40, i8* %zz)
; 00000000 ; 00000000
; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 106 ; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 106
; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i32]]* ; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i32]]*
; ENTRY-UAS-NEXT: store [[TYPE]] 0, [[TYPE]]* [[PTR]], align 1 ; ENTRY-UAS-NEXT: store [[TYPE]] 0, [[TYPE]]* [[PTR]], align 1
; 00 ; 00
; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 110 ; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 110
; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i8]]* ; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i8]]*
; ENTRY-UAS-NEXT: store [[TYPE]] 0, [[TYPE]]* [[PTR]], align 1 ; ENTRY-UAS-NEXT: store [[TYPE]] 0, [[TYPE]]* [[PTR]], align 1
; CHECK-NEXT: call void @llvm.lifetime.start(i64 40, i8* %zz) ; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 40, i8* %zz)
call void @Foo(i8* %zz) call void @Foo(i8* %zz)
; CHECK-NEXT: call void @Foo(i8* %zz) ; CHECK-NEXT: call void @Foo(i8* %zz)
call void @llvm.lifetime.end(i64 40, i8* %zz) call void @llvm.lifetime.end.p0i8(i64 40, i8* %zz)
; F8F8F8F8 ; F8F8F8F8
; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 106 ; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 106
; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i32]]* ; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i32]]*
; ENTRY-UAS-NEXT: store [[TYPE]] -117901064, [[TYPE]]* [[PTR]], align 1 ; ENTRY-UAS-NEXT: store [[TYPE]] -117901064, [[TYPE]]* [[PTR]], align 1
; F8 ; F8
; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 110 ; ENTRY-UAS-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 110
; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i8]]* ; ENTRY-UAS-NEXT: [[PTR:%[0-9]+]] = inttoptr i64 [[OFFSET]] to [[TYPE:i8]]*
; ENTRY-UAS-NEXT: store [[TYPE]] -8, [[TYPE]]* [[PTR]], align 1 ; ENTRY-UAS-NEXT: store [[TYPE]] -8, [[TYPE]]* [[PTR]], align 1
; CHECK-NEXT: call void @llvm.lifetime.end(i64 40, i8* %zz) ; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 40, i8* %zz)
; CHECK-LABEL: <label> ; CHECK-LABEL: <label>
; CHECK-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 0 ; CHECK-NEXT: [[OFFSET:%[0-9]+]] = add i64 [[SHADOW_BASE]], 0
; CHECK-NEXT: call void @__asan_set_shadow_f5(i64 [[OFFSET]], i64 128) ; CHECK-NEXT: call void @__asan_set_shadow_f5(i64 [[OFFSET]], i64 128)
; CHECK-NOT: add i64 [[SHADOW_BASE]] ; CHECK-NOT: add i64 [[SHADOW_BASE]]
Show All 35 Linesentry:
; CHECK-NOT: add i64 [[SHADOW_BASE]] ; CHECK-NOT: add i64 [[SHADOW_BASE]]
ret void ret void
; CHECK-LABEL: <label> ; CHECK-LABEL: <label>
; CHECK: ret void ; CHECK: ret void
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
; CHECK-ON: declare void @__asan_set_shadow_00(i64, i64) ; CHECK-ON: declare void @__asan_set_shadow_00(i64, i64)
; CHECK-ON: declare void @__asan_set_shadow_f1(i64, i64) ; CHECK-ON: declare void @__asan_set_shadow_f1(i64, i64)
; CHECK-ON: declare void @__asan_set_shadow_f2(i64, i64) ; CHECK-ON: declare void @__asan_set_shadow_f2(i64, i64)
; CHECK-ON: declare void @__asan_set_shadow_f3(i64, i64) ; CHECK-ON: declare void @__asan_set_shadow_f3(i64, i64)
; CHECK-ON: declare void @__asan_set_shadow_f5(i64, i64) ; CHECK-ON: declare void @__asan_set_shadow_f5(i64, i64)
; CHECK-ON: declare void @__asan_set_shadow_f8(i64, i64) ; CHECK-ON: declare void @__asan_set_shadow_f8(i64, i64)
; CHECK-OFF-NOT: declare void @__asan_set_shadow_ ; CHECK-OFF-NOT: declare void @__asan_set_shadow_

test/Instrumentation/AddressSanitizer/stack_layout.ll

; Test the ASan's stack layout. ; Test the ASan's stack layout.
; More tests in tests/Transforms/Utils/ASanStackFrameLayoutTest.cpp ; More tests in tests/Transforms/Utils/ASanStackFrameLayoutTest.cpp
; RUN: opt < %s -asan -asan-module -asan-stack-dynamic-alloca=0 -asan-use-after-scope -S \ ; RUN: opt < %s -asan -asan-module -asan-stack-dynamic-alloca=0 -asan-use-after-scope -S \
; RUN: | FileCheck %s --check-prefixes=CHECK,CHECK-STATIC ; RUN: | FileCheck %s --check-prefixes=CHECK,CHECK-STATIC
; RUN: opt < %s -asan -asan-module -asan-stack-dynamic-alloca=1 -asan-use-after-scope -S \ ; RUN: opt < %s -asan -asan-module -asan-stack-dynamic-alloca=1 -asan-use-after-scope -S \
; RUN: | FileCheck %s --check-prefixes=CHECK,CHECK-DYNAMIC ; RUN: | FileCheck %s --check-prefixes=CHECK,CHECK-DYNAMIC
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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
declare void @Use(i8*) declare void @Use(i8*)
declare void @llvm.lifetime.start(i64, i8* nocapture) nounwind declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) nounwind declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) nounwind
; CHECK: private unnamed_addr constant{{.*}}3 32 10 3 XXX 64 20 3 YYY 128 30 3 ZZZ\0 ; CHECK: private unnamed_addr constant{{.*}}3 32 10 3 XXX 64 20 3 YYY 128 30 3 ZZZ\0
; CHECK: private unnamed_addr constant{{.*}}3 32 5 3 AAA 64 55 3 BBB 160 555 3 CCC\0 ; CHECK: private unnamed_addr constant{{.*}}3 32 5 3 AAA 64 55 3 BBB 160 555 3 CCC\0
; CHECK: private unnamed_addr constant{{.*}}3 256 128 3 CCC 448 128 3 BBB 608 128 3 AAA\0 ; CHECK: private unnamed_addr constant{{.*}}3 256 128 3 CCC 448 128 3 BBB 608 128 3 AAA\0
; CHECK: private unnamed_addr constant{{.*}}2 32 4 3 AAA 48 4 5 BBB:7\0 ; CHECK: private unnamed_addr constant{{.*}}2 32 4 3 AAA 48 4 5 BBB:7\0
define void @Func1() sanitize_address { define void @Func1() sanitize_address {
entry: entry:
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines
} }
; Check that line numbers are attached to variable names if variable ; Check that line numbers are attached to variable names if variable
; in the same file as a function. ; in the same file as a function.
define void @Func5() sanitize_address #0 !dbg !11 { define void @Func5() sanitize_address #0 !dbg !11 {
%AAA = alloca i32, align 4 ; File is not the same as !11 %AAA = alloca i32, align 4 ; File is not the same as !11
%BBB = alloca i32, align 4 ; File is the same as !11 %BBB = alloca i32, align 4 ; File is the same as !11
%BBB.ptr = bitcast i32* %BBB to i8* %BBB.ptr = bitcast i32* %BBB to i8*
call void @llvm.lifetime.start(i64 4, i8* nonnull %BBB.ptr), !dbg !12 call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %BBB.ptr), !dbg !12
store volatile i32 5, i32* %BBB, align 4 store volatile i32 5, i32* %BBB, align 4
%AAA.ptr = bitcast i32* %AAA to i8* %AAA.ptr = bitcast i32* %AAA to i8*
call void @llvm.lifetime.start(i64 4, i8* nonnull %AAA.ptr), !dbg !14 call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %AAA.ptr), !dbg !14
store volatile i32 3, i32* %AAA, align 4 store volatile i32 3, i32* %AAA, align 4
call void @llvm.lifetime.end(i64 4, i8* nonnull %AAA.ptr), !dbg !17 call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %AAA.ptr), !dbg !17
call void @llvm.lifetime.end(i64 4, i8* nonnull %BBB.ptr), !dbg !18 call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %BBB.ptr), !dbg !18
ret void ret void
} }
!llvm.dbg.cu = !{!0} !llvm.dbg.cu = !{!0}
!llvm.module.flags = !{!3, !4} !llvm.module.flags = !{!3, !4}
!3 = !{i32 2, !"Dwarf Version", i32 4} !3 = !{i32 2, !"Dwarf Version", i32 4}
!4 = !{i32 2, !"Debug Info Version", i32 3} !4 = !{i32 2, !"Debug Info Version", i32 3}
Show All 11 Lines

test/Instrumentation/MemorySanitizer/AArch64/vararg.ll

; RUN: opt < %s -msan -S | FileCheck %s ; RUN: opt < %s -msan -S | FileCheck %s
target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128" target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
target triple = "aarch64-unknown-linux-gnu" target triple = "aarch64-unknown-linux-gnu"
%struct.__va_list = type { i8*, i8*, i8*, i32, i32 } %struct.__va_list = type { i8*, i8*, i8*, i32, i32 }
define i32 @foo(i32 %guard, ...) { define i32 @foo(i32 %guard, ...) {
%vl = alloca %struct.__va_list, align 8 %vl = alloca %struct.__va_list, align 8
%1 = bitcast %struct.__va_list* %vl to i8* %1 = bitcast %struct.__va_list* %vl to i8*
call void @llvm.lifetime.start(i64 32, i8* %1) call void @llvm.lifetime.start.p0i8(i64 32, i8* %1)
call void @llvm.va_start(i8* %1) call void @llvm.va_start(i8* %1)
call void @llvm.va_end(i8* %1) call void @llvm.va_end(i8* %1)
call void @llvm.lifetime.end(i64 32, i8* %1) call void @llvm.lifetime.end.p0i8(i64 32, i8* %1)
ret i32 0 ret i32 0
} }
; First check if the variadic shadow values are saved in stack with correct ; First check if the variadic shadow values are saved in stack with correct
; size (192 is total of general purpose registers size, 64, plus total of ; size (192 is total of general purpose registers size, 64, plus total of
; floating-point registers size, 128). ; floating-point registers size, 128).
; CHECK-LABEL: @foo ; CHECK-LABEL: @foo
Show All 18 Lines
; CHECK: [[VRSIZE:%.*]] = sub i64 128, {{%.*}} ; CHECK: [[VRSIZE:%.*]] = sub i64 128, {{%.*}}
; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* {{%.*}}, i8* [[VRP]], i64 [[VRSIZE]], i32 8, i1 false) ; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* {{%.*}}, i8* [[VRP]], i64 [[VRSIZE]], i32 8, i1 false)
; Copy the remaining shadow values on the va_list::__stack position (it is ; Copy the remaining shadow values on the va_list::__stack position (it is
; on the constant offset of 192 from __msan_va_arg_tls). ; on the constant offset of 192 from __msan_va_arg_tls).
; CHECK: [[STACK:%.*]] = getelementptr inbounds i8, i8* {{%.*}}, i32 192 ; CHECK: [[STACK:%.*]] = getelementptr inbounds i8, i8* {{%.*}}, i32 192
; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* {{%.*}}, i8* [[STACK]], i64 {{%.*}}, i32 16, i1 false) ; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* {{%.*}}, i8* [[STACK]], i64 {{%.*}}, i32 16, i1 false)
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
declare void @llvm.va_start(i8*) #2 declare void @llvm.va_start(i8*) #2
declare void @llvm.va_end(i8*) #2 declare void @llvm.va_end(i8*) #2
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
define i32 @bar() { define i32 @bar() {
%1 = call i32 (i32, ...) @foo(i32 0, i32 1, i32 2, double 3.000000e+00, %1 = call i32 (i32, ...) @foo(i32 0, i32 1, i32 2, double 3.000000e+00,
double 4.000000e+00, i32 5, i32 6, double 4.000000e+00, i32 5, i32 6,
double 7.000000e+00, i32 8, i32 9, i32 10, i32 11) double 7.000000e+00, i32 8, i32 9, i32 10, i32 11)
ret i32 %1 ret i32 %1
} }
Show All 16 Lines

test/Instrumentation/MemorySanitizer/Mips/vararg-mips64.ll

; RUN: opt < %s -msan -S | FileCheck %s ; RUN: opt < %s -msan -S | FileCheck %s
target datalayout = "E-m:m-i8:8:32-i16:16:32-i64:64-n32:64-S128" target datalayout = "E-m:m-i8:8:32-i16:16:32-i64:64-n32:64-S128"
target triple = "mips64--linux" target triple = "mips64--linux"
define i32 @foo(i32 %guard, ...) { define i32 @foo(i32 %guard, ...) {
%vl = alloca i8*, align 8 %vl = alloca i8*, align 8
%1 = bitcast i8** %vl to i8* %1 = bitcast i8** %vl to i8*
call void @llvm.lifetime.start(i64 32, i8* %1) call void @llvm.lifetime.start.p0i8(i64 32, i8* %1)
call void @llvm.va_start(i8* %1) call void @llvm.va_start(i8* %1)
call void @llvm.va_end(i8* %1) call void @llvm.va_end(i8* %1)
call void @llvm.lifetime.end(i64 32, i8* %1) call void @llvm.lifetime.end.p0i8(i64 32, i8* %1)
ret i32 0 ret i32 0
} }
; First, check allocation of the save area. ; First, check allocation of the save area.
; CHECK-LABEL: @foo ; CHECK-LABEL: @foo
; CHECK: [[A:%.*]] = load {{.*}} @__msan_va_arg_overflow_size_tls ; CHECK: [[A:%.*]] = load {{.*}} @__msan_va_arg_overflow_size_tls
; CHECK: [[B:%.*]] = add i64 0, [[A]] ; CHECK: [[B:%.*]] = add i64 0, [[A]]
; CHECK: [[C:%.*]] = alloca {{.*}} [[B]] ; CHECK: [[C:%.*]] = alloca {{.*}} [[B]]
; CHECK: [[STACK:%.*]] = bitcast {{.*}} @__msan_va_arg_tls to i8* ; CHECK: [[STACK:%.*]] = bitcast {{.*}} @__msan_va_arg_tls to i8*
; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[C]], i8* [[STACK]], i64 [[B]], i32 8, i1 false) ; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[C]], i8* [[STACK]], i64 [[B]], i32 8, i1 false)
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
declare void @llvm.va_start(i8*) #2 declare void @llvm.va_start(i8*) #2
declare void @llvm.va_end(i8*) #2 declare void @llvm.va_end(i8*) #2
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
define i32 @bar() { define i32 @bar() {
%1 = call i32 (i32, ...) @foo(i32 0, i32 1, i64 2, double 3.000000e+00) %1 = call i32 (i32, ...) @foo(i32 0, i32 1, i64 2, double 3.000000e+00)
ret i32 %1 ret i32 %1
} }
; Save the incoming shadow value from the arguments in the __msan_va_arg_tls ; Save the incoming shadow value from the arguments in the __msan_va_arg_tls
; array. The first argument is stored at position 4, since it's right ; array. The first argument is stored at position 4, since it's right
Show All 18 Lines

test/Instrumentation/MemorySanitizer/Mips/vararg-mips64el.ll

; RUN: opt < %s -msan -S | FileCheck %s ; RUN: opt < %s -msan -S | FileCheck %s
target datalayout = "e-m:m-i8:8:32-i16:16:32-i64:64-n32:64-S128" target datalayout = "e-m:m-i8:8:32-i16:16:32-i64:64-n32:64-S128"
target triple = "mips64el--linux" target triple = "mips64el--linux"
define i32 @foo(i32 %guard, ...) { define i32 @foo(i32 %guard, ...) {
%vl = alloca i8*, align 8 %vl = alloca i8*, align 8
%1 = bitcast i8** %vl to i8* %1 = bitcast i8** %vl to i8*
call void @llvm.lifetime.start(i64 32, i8* %1) call void @llvm.lifetime.start.p0i8(i64 32, i8* %1)
call void @llvm.va_start(i8* %1) call void @llvm.va_start(i8* %1)
call void @llvm.va_end(i8* %1) call void @llvm.va_end(i8* %1)
call void @llvm.lifetime.end(i64 32, i8* %1) call void @llvm.lifetime.end.p0i8(i64 32, i8* %1)
ret i32 0 ret i32 0
} }
; First, check allocation of the save area. ; First, check allocation of the save area.
; CHECK-LABEL: @foo ; CHECK-LABEL: @foo
; CHECK: [[A:%.*]] = load {{.*}} @__msan_va_arg_overflow_size_tls ; CHECK: [[A:%.*]] = load {{.*}} @__msan_va_arg_overflow_size_tls
; CHECK: [[B:%.*]] = add i64 0, [[A]] ; CHECK: [[B:%.*]] = add i64 0, [[A]]
; CHECK: [[C:%.*]] = alloca {{.*}} [[B]] ; CHECK: [[C:%.*]] = alloca {{.*}} [[B]]
; CHECK: [[STACK:%.*]] = bitcast {{.*}} @__msan_va_arg_tls to i8* ; CHECK: [[STACK:%.*]] = bitcast {{.*}} @__msan_va_arg_tls to i8*
; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[C]], i8* [[STACK]], i64 [[B]], i32 8, i1 false) ; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[C]], i8* [[STACK]], i64 [[B]], i32 8, i1 false)
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
declare void @llvm.va_start(i8*) #2 declare void @llvm.va_start(i8*) #2
declare void @llvm.va_end(i8*) #2 declare void @llvm.va_end(i8*) #2
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
define i32 @bar() { define i32 @bar() {
%1 = call i32 (i32, ...) @foo(i32 0, i32 1, i64 2, double 3.000000e+00) %1 = call i32 (i32, ...) @foo(i32 0, i32 1, i64 2, double 3.000000e+00)
ret i32 %1 ret i32 %1
} }
; Save the incoming shadow value from the arguments in the __msan_va_arg_tls ; Save the incoming shadow value from the arguments in the __msan_va_arg_tls
; array. ; array.
Show All 17 Lines

test/Instrumentation/MemorySanitizer/PowerPC/vararg-ppc64.ll

; RUN: opt < %s -msan -S | FileCheck %s ; RUN: opt < %s -msan -S | FileCheck %s
target datalayout = "E-m:e-i64:64-n32:64" target datalayout = "E-m:e-i64:64-n32:64"
target triple = "powerpc64--linux" target triple = "powerpc64--linux"
define i32 @foo(i32 %guard, ...) { define i32 @foo(i32 %guard, ...) {
%vl = alloca i8*, align 8 %vl = alloca i8*, align 8
%1 = bitcast i8** %vl to i8* %1 = bitcast i8** %vl to i8*
call void @llvm.lifetime.start(i64 32, i8* %1) call void @llvm.lifetime.start.p0i8(i64 32, i8* %1)
call void @llvm.va_start(i8* %1) call void @llvm.va_start(i8* %1)
call void @llvm.va_end(i8* %1) call void @llvm.va_end(i8* %1)
call void @llvm.lifetime.end(i64 32, i8* %1) call void @llvm.lifetime.end.p0i8(i64 32, i8* %1)
ret i32 0 ret i32 0
} }
; First, check allocation of the save area. ; First, check allocation of the save area.
; CHECK-LABEL: @foo ; CHECK-LABEL: @foo
; CHECK: [[A:%.*]] = load {{.*}} @__msan_va_arg_overflow_size_tls ; CHECK: [[A:%.*]] = load {{.*}} @__msan_va_arg_overflow_size_tls
; CHECK: [[B:%.*]] = add i64 0, [[A]] ; CHECK: [[B:%.*]] = add i64 0, [[A]]
; CHECK: [[C:%.*]] = alloca {{.*}} [[B]] ; CHECK: [[C:%.*]] = alloca {{.*}} [[B]]
; CHECK: [[STACK:%.*]] = bitcast {{.*}} @__msan_va_arg_tls to i8* ; CHECK: [[STACK:%.*]] = bitcast {{.*}} @__msan_va_arg_tls to i8*
; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[C]], i8* [[STACK]], i64 [[B]], i32 8, i1 false) ; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[C]], i8* [[STACK]], i64 [[B]], i32 8, i1 false)
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
declare void @llvm.va_start(i8*) #2 declare void @llvm.va_start(i8*) #2
declare void @llvm.va_end(i8*) #2 declare void @llvm.va_end(i8*) #2
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
define i32 @bar() { define i32 @bar() {
%1 = call i32 (i32, ...) @foo(i32 0, i32 1, i64 2, double 3.000000e+00) %1 = call i32 (i32, ...) @foo(i32 0, i32 1, i64 2, double 3.000000e+00)
ret i32 %1 ret i32 %1
} }
; Save the incoming shadow value from the arguments in the __msan_va_arg_tls ; Save the incoming shadow value from the arguments in the __msan_va_arg_tls
; array. The first argument is stored at position 4, since it's right ; array. The first argument is stored at position 4, since it's right
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

test/Instrumentation/MemorySanitizer/PowerPC/vararg-ppc64le.ll

; RUN: opt < %s -msan -S | FileCheck %s ; RUN: opt < %s -msan -S | FileCheck %s
target datalayout = "e-m:e-i64:64-n32:64" target datalayout = "e-m:e-i64:64-n32:64"
target triple = "powerpc64le--linux" target triple = "powerpc64le--linux"
define i32 @foo(i32 %guard, ...) { define i32 @foo(i32 %guard, ...) {
%vl = alloca i8*, align 8 %vl = alloca i8*, align 8
%1 = bitcast i8** %vl to i8* %1 = bitcast i8** %vl to i8*
call void @llvm.lifetime.start(i64 32, i8* %1) call void @llvm.lifetime.start.p0i8(i64 32, i8* %1)
call void @llvm.va_start(i8* %1) call void @llvm.va_start(i8* %1)
call void @llvm.va_end(i8* %1) call void @llvm.va_end(i8* %1)
call void @llvm.lifetime.end(i64 32, i8* %1) call void @llvm.lifetime.end.p0i8(i64 32, i8* %1)
ret i32 0 ret i32 0
} }
; First, check allocation of the save area. ; First, check allocation of the save area.
; CHECK-LABEL: @foo ; CHECK-LABEL: @foo
; CHECK: [[A:%.*]] = load {{.*}} @__msan_va_arg_overflow_size_tls ; CHECK: [[A:%.*]] = load {{.*}} @__msan_va_arg_overflow_size_tls
; CHECK: [[B:%.*]] = add i64 0, [[A]] ; CHECK: [[B:%.*]] = add i64 0, [[A]]
; CHECK: [[C:%.*]] = alloca {{.*}} [[B]] ; CHECK: [[C:%.*]] = alloca {{.*}} [[B]]
; CHECK: [[STACK:%.*]] = bitcast {{.*}} @__msan_va_arg_tls to i8* ; CHECK: [[STACK:%.*]] = bitcast {{.*}} @__msan_va_arg_tls to i8*
; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[C]], i8* [[STACK]], i64 [[B]], i32 8, i1 false) ; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[C]], i8* [[STACK]], i64 [[B]], i32 8, i1 false)
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
declare void @llvm.va_start(i8*) #2 declare void @llvm.va_start(i8*) #2
declare void @llvm.va_end(i8*) #2 declare void @llvm.va_end(i8*) #2
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
define i32 @bar() { define i32 @bar() {
%1 = call i32 (i32, ...) @foo(i32 0, i32 1, i64 2, double 3.000000e+00) %1 = call i32 (i32, ...) @foo(i32 0, i32 1, i64 2, double 3.000000e+00)
ret i32 %1 ret i32 %1
} }
; Save the incoming shadow value from the arguments in the __msan_va_arg_tls ; Save the incoming shadow value from the arguments in the __msan_va_arg_tls
; array. ; array.
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

test/Transforms/AddDiscriminators/call.ll

; RUN: opt < %s -add-discriminators -S | FileCheck %s ; RUN: opt < %s -add-discriminators -S | FileCheck %s
; RUN: opt < %s -passes=add-discriminators -S | FileCheck %s ; RUN: opt < %s -passes=add-discriminators -S | FileCheck %s
; Discriminator support for calls that are defined in one line: ; Discriminator support for calls that are defined in one line:
; #1 void bar(); ; #1 void bar();
; #2 ; #2
; #3 void foo() { ; #3 void foo() {
; #4 bar();bar()/*discriminator 2*/;bar()/*discriminator 4*/; ; #4 bar();bar()/*discriminator 2*/;bar()/*discriminator 4*/;
; #5 } ; #5 }
; Function Attrs: uwtable ; Function Attrs: uwtable
define void @_Z3foov() #0 !dbg !4 { define void @_Z3foov() #0 !dbg !4 {
call void @_Z3barv(), !dbg !10 call void @_Z3barv(), !dbg !10
; CHECK: call void @_Z3barv(), !dbg ![[CALL0:[0-9]+]] ; CHECK: call void @_Z3barv(), !dbg ![[CALL0:[0-9]+]]
%a = alloca [100 x i8], align 16 %a = alloca [100 x i8], align 16
%b = bitcast [100 x i8]* %a to i8* %b = bitcast [100 x i8]* %a to i8*
call void @llvm.lifetime.start(i64 100, i8* %b), !dbg !11 call void @llvm.lifetime.start.p0i8(i64 100, i8* %b), !dbg !11
call void @llvm.lifetime.end(i64 100, i8* %b), !dbg !11 call void @llvm.lifetime.end.p0i8(i64 100, i8* %b), !dbg !11
call void @_Z3barv(), !dbg !11 call void @_Z3barv(), !dbg !11
; CHECK: call void @_Z3barv(), !dbg ![[CALL1:[0-9]+]] ; CHECK: call void @_Z3barv(), !dbg ![[CALL1:[0-9]+]]
call void @_Z3barv(), !dbg !12 call void @_Z3barv(), !dbg !12
; CHECK: call void @_Z3barv(), !dbg ![[CALL2:[0-9]+]] ; CHECK: call void @_Z3barv(), !dbg ![[CALL2:[0-9]+]]
ret void, !dbg !13 ret void, !dbg !13
} }
declare void @_Z3barv() #1 declare void @_Z3barv() #1
declare void @llvm.lifetime.start(i64, i8* nocapture) nounwind argmemonly declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind argmemonly
declare void @llvm.lifetime.end(i64, i8* nocapture) nounwind argmemonly declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) nounwind argmemonly
attributes #0 = { uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #0 = { uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #1 = { "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" }
!llvm.dbg.cu = !{!0} !llvm.dbg.cu = !{!0}
!llvm.module.flags = !{!7, !8} !llvm.module.flags = !{!7, !8}
!llvm.ident = !{!9} !llvm.ident = !{!9}
Show All 18 Lines

test/Transforms/AtomicExpand/SPARC/libcalls.ll

Show All 37 Linesdefine i16 @test_exchange_i16(i16* %arg, i16 %val) {
%ret = atomicrmw xchg i16* %arg, i16 %val seq_cst %ret = atomicrmw xchg i16* %arg, i16 %val seq_cst
ret i16 %ret ret i16 %ret
} }
; CHECK-LABEL: @test_cmpxchg_i16( ; CHECK-LABEL: @test_cmpxchg_i16(
; CHECK: %1 = bitcast i16* %arg to i8* ; CHECK: %1 = bitcast i16* %arg to i8*
; CHECK: %2 = alloca i16, align 2 ; CHECK: %2 = alloca i16, align 2
; CHECK: %3 = bitcast i16* %2 to i8* ; CHECK: %3 = bitcast i16* %2 to i8*
; CHECK: call void @llvm.lifetime.start(i64 2, i8* %3) ; CHECK: call void @llvm.lifetime.start.p0i8(i64 2, i8* %3)
; CHECK: store i16 %old, i16* %2, align 2 ; CHECK: store i16 %old, i16* %2, align 2
; CHECK: %4 = call zeroext i1 @__atomic_compare_exchange_2(i8* %1, i8* %3, i16 %new, i32 5, i32 0) ; CHECK: %4 = call zeroext i1 @__atomic_compare_exchange_2(i8* %1, i8* %3, i16 %new, i32 5, i32 0)
; CHECK: %5 = load i16, i16* %2, align 2 ; CHECK: %5 = load i16, i16* %2, align 2
; CHECK: call void @llvm.lifetime.end(i64 2, i8* %3) ; CHECK: call void @llvm.lifetime.end.p0i8(i64 2, i8* %3)
; CHECK: %6 = insertvalue { i16, i1 } undef, i16 %5, 0 ; CHECK: %6 = insertvalue { i16, i1 } undef, i16 %5, 0
; CHECK: %7 = insertvalue { i16, i1 } %6, i1 %4, 1 ; CHECK: %7 = insertvalue { i16, i1 } %6, i1 %4, 1
; CHECK: %ret = extractvalue { i16, i1 } %7, 0 ; CHECK: %ret = extractvalue { i16, i1 } %7, 0
; CHECK: ret i16 %ret ; CHECK: ret i16 %ret
define i16 @test_cmpxchg_i16(i16* %arg, i16 %old, i16 %new) { define i16 @test_cmpxchg_i16(i16* %arg, i16 %old, i16 %new) {
%ret_succ = cmpxchg i16* %arg, i16 %old, i16 %new seq_cst monotonic %ret_succ = cmpxchg i16* %arg, i16 %old, i16 %new seq_cst monotonic
%ret = extractvalue { i16, i1 } %ret_succ, 0 %ret = extractvalue { i16, i1 } %ret_succ, 0
ret i16 %ret ret i16 %ret
Show All 12 Lines
;; Now, check the output for the unsized libcalls. i128 is used for ;; Now, check the output for the unsized libcalls. i128 is used for
;; these tests because the "16" suffixed functions aren't available on ;; these tests because the "16" suffixed functions aren't available on
;; 32-bit i386. ;; 32-bit i386.
; CHECK-LABEL: @test_load_i128( ; CHECK-LABEL: @test_load_i128(
; CHECK: %1 = bitcast i128* %arg to i8* ; CHECK: %1 = bitcast i128* %arg to i8*
; CHECK: %2 = alloca i128, align 8 ; CHECK: %2 = alloca i128, align 8
; CHECK: %3 = bitcast i128* %2 to i8* ; CHECK: %3 = bitcast i128* %2 to i8*
; CHECK: call void @llvm.lifetime.start(i64 16, i8* %3) ; CHECK: call void @llvm.lifetime.start.p0i8(i64 16, i8* %3)
; CHECK: call void @__atomic_load(i32 16, i8* %1, i8* %3, i32 5) ; CHECK: call void @__atomic_load(i32 16, i8* %1, i8* %3, i32 5)
; CHECK: %4 = load i128, i128* %2, align 8 ; CHECK: %4 = load i128, i128* %2, align 8
; CHECK: call void @llvm.lifetime.end(i64 16, i8* %3) ; CHECK: call void @llvm.lifetime.end.p0i8(i64 16, i8* %3)
; CHECK: ret i128 %4 ; CHECK: ret i128 %4
define i128 @test_load_i128(i128* %arg) { define i128 @test_load_i128(i128* %arg) {
%ret = load atomic i128, i128* %arg seq_cst, align 16 %ret = load atomic i128, i128* %arg seq_cst, align 16
ret i128 %ret ret i128 %ret
} }
; CHECK-LABEL @test_store_i128( ; CHECK-LABEL @test_store_i128(
; CHECK: %1 = bitcast i128* %arg to i8* ; CHECK: %1 = bitcast i128* %arg to i8*
; CHECK: %2 = alloca i128, align 8 ; CHECK: %2 = alloca i128, align 8
; CHECK: %3 = bitcast i128* %2 to i8* ; CHECK: %3 = bitcast i128* %2 to i8*
; CHECK: call void @llvm.lifetime.start(i64 16, i8* %3) ; CHECK: call void @llvm.lifetime.start.p0i8(i64 16, i8* %3)
; CHECK: store i128 %val, i128* %2, align 8 ; CHECK: store i128 %val, i128* %2, align 8
; CHECK: call void @__atomic_store(i32 16, i8* %1, i8* %3, i32 5) ; CHECK: call void @__atomic_store(i32 16, i8* %1, i8* %3, i32 5)
; CHECK: call void @llvm.lifetime.end(i64 16, i8* %3) ; CHECK: call void @llvm.lifetime.end.p0i8(i64 16, i8* %3)
; CHECK: ret void ; CHECK: ret void
define void @test_store_i128(i128* %arg, i128 %val) { define void @test_store_i128(i128* %arg, i128 %val) {
store atomic i128 %val, i128* %arg seq_cst, align 16 store atomic i128 %val, i128* %arg seq_cst, align 16
ret void ret void
} }
; CHECK-LABEL: @test_exchange_i128( ; CHECK-LABEL: @test_exchange_i128(
; CHECK: %1 = bitcast i128* %arg to i8* ; CHECK: %1 = bitcast i128* %arg to i8*
; CHECK: %2 = alloca i128, align 8 ; CHECK: %2 = alloca i128, align 8
; CHECK: %3 = bitcast i128* %2 to i8* ; CHECK: %3 = bitcast i128* %2 to i8*
; CHECK: call void @llvm.lifetime.start(i64 16, i8* %3) ; CHECK: call void @llvm.lifetime.start.p0i8(i64 16, i8* %3)
; CHECK: store i128 %val, i128* %2, align 8 ; CHECK: store i128 %val, i128* %2, align 8
; CHECK: %4 = alloca i128, align 8 ; CHECK: %4 = alloca i128, align 8
; CHECK: %5 = bitcast i128* %4 to i8* ; CHECK: %5 = bitcast i128* %4 to i8*
; CHECK: call void @llvm.lifetime.start(i64 16, i8* %5) ; CHECK: call void @llvm.lifetime.start.p0i8(i64 16, i8* %5)
; CHECK: call void @__atomic_exchange(i32 16, i8* %1, i8* %3, i8* %5, i32 5) ; CHECK: call void @__atomic_exchange(i32 16, i8* %1, i8* %3, i8* %5, i32 5)
; CHECK: call void @llvm.lifetime.end(i64 16, i8* %3) ; CHECK: call void @llvm.lifetime.end.p0i8(i64 16, i8* %3)
; CHECK: %6 = load i128, i128* %4, align 8 ; CHECK: %6 = load i128, i128* %4, align 8
; CHECK: call void @llvm.lifetime.end(i64 16, i8* %5) ; CHECK: call void @llvm.lifetime.end.p0i8(i64 16, i8* %5)
; CHECK: ret i128 %6 ; CHECK: ret i128 %6
define i128 @test_exchange_i128(i128* %arg, i128 %val) { define i128 @test_exchange_i128(i128* %arg, i128 %val) {
%ret = atomicrmw xchg i128* %arg, i128 %val seq_cst %ret = atomicrmw xchg i128* %arg, i128 %val seq_cst
ret i128 %ret ret i128 %ret
} }
; CHECK-LABEL: @test_cmpxchg_i128( ; CHECK-LABEL: @test_cmpxchg_i128(
; CHECK: %1 = bitcast i128* %arg to i8* ; CHECK: %1 = bitcast i128* %arg to i8*
; CHECK: %2 = alloca i128, align 8 ; CHECK: %2 = alloca i128, align 8
; CHECK: %3 = bitcast i128* %2 to i8* ; CHECK: %3 = bitcast i128* %2 to i8*
; CHECK: call void @llvm.lifetime.start(i64 16, i8* %3) ; CHECK: call void @llvm.lifetime.start.p0i8(i64 16, i8* %3)
; CHECK: store i128 %old, i128* %2, align 8 ; CHECK: store i128 %old, i128* %2, align 8
; CHECK: %4 = alloca i128, align 8 ; CHECK: %4 = alloca i128, align 8
; CHECK: %5 = bitcast i128* %4 to i8* ; CHECK: %5 = bitcast i128* %4 to i8*
; CHECK: call void @llvm.lifetime.start(i64 16, i8* %5) ; CHECK: call void @llvm.lifetime.start.p0i8(i64 16, i8* %5)
; CHECK: store i128 %new, i128* %4, align 8 ; CHECK: store i128 %new, i128* %4, align 8
; CHECK: %6 = call zeroext i1 @__atomic_compare_exchange(i32 16, i8* %1, i8* %3, i8* %5, i32 5, i32 0) ; CHECK: %6 = call zeroext i1 @__atomic_compare_exchange(i32 16, i8* %1, i8* %3, i8* %5, i32 5, i32 0)
; CHECK: call void @llvm.lifetime.end(i64 16, i8* %5) ; CHECK: call void @llvm.lifetime.end.p0i8(i64 16, i8* %5)
; CHECK: %7 = load i128, i128* %2, align 8 ; CHECK: %7 = load i128, i128* %2, align 8
; CHECK: call void @llvm.lifetime.end(i64 16, i8* %3) ; CHECK: call void @llvm.lifetime.end.p0i8(i64 16, i8* %3)
; CHECK: %8 = insertvalue { i128, i1 } undef, i128 %7, 0 ; CHECK: %8 = insertvalue { i128, i1 } undef, i128 %7, 0
; CHECK: %9 = insertvalue { i128, i1 } %8, i1 %6, 1 ; CHECK: %9 = insertvalue { i128, i1 } %8, i1 %6, 1
; CHECK: %ret = extractvalue { i128, i1 } %9, 0 ; CHECK: %ret = extractvalue { i128, i1 } %9, 0
; CHECK: ret i128 %ret ; CHECK: ret i128 %ret
define i128 @test_cmpxchg_i128(i128* %arg, i128 %old, i128 %new) { define i128 @test_cmpxchg_i128(i128* %arg, i128 %old, i128 %new) {
%ret_succ = cmpxchg i128* %arg, i128 %old, i128 %new seq_cst monotonic %ret_succ = cmpxchg i128* %arg, i128 %old, i128 %new seq_cst monotonic
%ret = extractvalue { i128, i1 } %ret_succ, 0 %ret = extractvalue { i128, i1 } %ret_succ, 0
ret i128 %ret ret i128 %ret
} }
; This one is a verbose expansion, as there is no generic ; This one is a verbose expansion, as there is no generic
; __atomic_fetch_add function, so it needs to expand to a cmpxchg ; __atomic_fetch_add function, so it needs to expand to a cmpxchg
; loop, which then itself expands into a libcall. ; loop, which then itself expands into a libcall.
; CHECK-LABEL: @test_add_i128( ; CHECK-LABEL: @test_add_i128(
; CHECK: %1 = alloca i128, align 8 ; CHECK: %1 = alloca i128, align 8
; CHECK: %2 = alloca i128, align 8 ; CHECK: %2 = alloca i128, align 8
; CHECK: %3 = load i128, i128* %arg, align 16 ; CHECK: %3 = load i128, i128* %arg, align 16
; CHECK: br label %atomicrmw.start ; CHECK: br label %atomicrmw.start
; CHECK:atomicrmw.start: ; CHECK:atomicrmw.start:
; CHECK: %loaded = phi i128 [ %3, %0 ], [ %newloaded, %atomicrmw.start ] ; CHECK: %loaded = phi i128 [ %3, %0 ], [ %newloaded, %atomicrmw.start ]
; CHECK: %new = add i128 %loaded, %val ; CHECK: %new = add i128 %loaded, %val
; CHECK: %4 = bitcast i128* %arg to i8* ; CHECK: %4 = bitcast i128* %arg to i8*
; CHECK: %5 = bitcast i128* %1 to i8* ; CHECK: %5 = bitcast i128* %1 to i8*
; CHECK: call void @llvm.lifetime.start(i64 16, i8* %5) ; CHECK: call void @llvm.lifetime.start.p0i8(i64 16, i8* %5)
; CHECK: store i128 %loaded, i128* %1, align 8 ; CHECK: store i128 %loaded, i128* %1, align 8
; CHECK: %6 = bitcast i128* %2 to i8* ; CHECK: %6 = bitcast i128* %2 to i8*
; CHECK: call void @llvm.lifetime.start(i64 16, i8* %6) ; CHECK: call void @llvm.lifetime.start.p0i8(i64 16, i8* %6)
; CHECK: store i128 %new, i128* %2, align 8 ; CHECK: store i128 %new, i128* %2, align 8
; CHECK: %7 = call zeroext i1 @__atomic_compare_exchange(i32 16, i8* %4, i8* %5, i8* %6, i32 5, i32 5) ; CHECK: %7 = call zeroext i1 @__atomic_compare_exchange(i32 16, i8* %4, i8* %5, i8* %6, i32 5, i32 5)
; CHECK: call void @llvm.lifetime.end(i64 16, i8* %6) ; CHECK: call void @llvm.lifetime.end.p0i8(i64 16, i8* %6)
; CHECK: %8 = load i128, i128* %1, align 8 ; CHECK: %8 = load i128, i128* %1, align 8
; CHECK: call void @llvm.lifetime.end(i64 16, i8* %5) ; CHECK: call void @llvm.lifetime.end.p0i8(i64 16, i8* %5)
; CHECK: %9 = insertvalue { i128, i1 } undef, i128 %8, 0 ; CHECK: %9 = insertvalue { i128, i1 } undef, i128 %8, 0
; CHECK: %10 = insertvalue { i128, i1 } %9, i1 %7, 1 ; CHECK: %10 = insertvalue { i128, i1 } %9, i1 %7, 1
; CHECK: %success = extractvalue { i128, i1 } %10, 1 ; CHECK: %success = extractvalue { i128, i1 } %10, 1
; CHECK: %newloaded = extractvalue { i128, i1 } %10, 0 ; CHECK: %newloaded = extractvalue { i128, i1 } %10, 0
; CHECK: br i1 %success, label %atomicrmw.end, label %atomicrmw.start ; CHECK: br i1 %success, label %atomicrmw.end, label %atomicrmw.start
; CHECK:atomicrmw.end: ; CHECK:atomicrmw.end:
; CHECK: ret i128 %newloaded ; CHECK: ret i128 %newloaded
define i128 @test_add_i128(i128* %arg, i128 %val) { define i128 @test_add_i128(i128* %arg, i128 %val) {
Show All 22 Linesdefine void @test_store_double(double* %arg, double %val) {
store atomic double %val, double* %arg seq_cst, align 16 store atomic double %val, double* %arg seq_cst, align 16
ret void ret void
} }
; CHECK-LABEL: @test_cmpxchg_ptr( ; CHECK-LABEL: @test_cmpxchg_ptr(
; CHECK: %1 = bitcast i16** %arg to i8* ; CHECK: %1 = bitcast i16** %arg to i8*
; CHECK: %2 = alloca i16*, align 4 ; CHECK: %2 = alloca i16*, align 4
; CHECK: %3 = bitcast i16** %2 to i8* ; CHECK: %3 = bitcast i16** %2 to i8*
; CHECK: call void @llvm.lifetime.start(i64 4, i8* %3) ; CHECK: call void @llvm.lifetime.start.p0i8(i64 4, i8* %3)
; CHECK: store i16* %old, i16** %2, align 4 ; CHECK: store i16* %old, i16** %2, align 4
; CHECK: %4 = ptrtoint i16* %new to i32 ; CHECK: %4 = ptrtoint i16* %new to i32
; CHECK: %5 = call zeroext i1 @__atomic_compare_exchange_4(i8* %1, i8* %3, i32 %4, i32 5, i32 2) ; CHECK: %5 = call zeroext i1 @__atomic_compare_exchange_4(i8* %1, i8* %3, i32 %4, i32 5, i32 2)
; CHECK: %6 = load i16*, i16** %2, align 4 ; CHECK: %6 = load i16*, i16** %2, align 4
; CHECK: call void @llvm.lifetime.end(i64 4, i8* %3) ; CHECK: call void @llvm.lifetime.end.p0i8(i64 4, i8* %3)
; CHECK: %7 = insertvalue { i16*, i1 } undef, i16* %6, 0 ; CHECK: %7 = insertvalue { i16*, i1 } undef, i16* %6, 0
; CHECK: %8 = insertvalue { i16*, i1 } %7, i1 %5, 1 ; CHECK: %8 = insertvalue { i16*, i1 } %7, i1 %5, 1
; CHECK: %ret = extractvalue { i16*, i1 } %8, 0 ; CHECK: %ret = extractvalue { i16*, i1 } %8, 0
; CHECK: ret i16* %ret ; CHECK: ret i16* %ret
; CHECK: } ; CHECK: }
define i16* @test_cmpxchg_ptr(i16** %arg, i16* %old, i16* %new) { define i16* @test_cmpxchg_ptr(i16** %arg, i16* %old, i16* %new) {
%ret_succ = cmpxchg i16** %arg, i16* %old, i16* %new seq_cst acquire %ret_succ = cmpxchg i16** %arg, i16* %old, i16* %new seq_cst acquire
%ret = extractvalue { i16*, i1 } %ret_succ, 0 %ret = extractvalue { i16*, i1 } %ret_succ, 0
ret i16* %ret ret i16* %ret
} }
;; ...and for a non-integer type of large size too. ;; ...and for a non-integer type of large size too.
; CHECK-LABEL: @test_store_fp128 ; CHECK-LABEL: @test_store_fp128
; CHECK: %1 = bitcast fp128* %arg to i8* ; CHECK: %1 = bitcast fp128* %arg to i8*
; CHECK: %2 = alloca fp128, align 8 ; CHECK: %2 = alloca fp128, align 8
; CHECK: %3 = bitcast fp128* %2 to i8* ; CHECK: %3 = bitcast fp128* %2 to i8*
; CHECK: call void @llvm.lifetime.start(i64 16, i8* %3) ; CHECK: call void @llvm.lifetime.start.p0i8(i64 16, i8* %3)
; CHECK: store fp128 %val, fp128* %2, align 8 ; CHECK: store fp128 %val, fp128* %2, align 8
; CHECK: call void @__atomic_store(i32 16, i8* %1, i8* %3, i32 5) ; CHECK: call void @__atomic_store(i32 16, i8* %1, i8* %3, i32 5)
; CHECK: call void @llvm.lifetime.end(i64 16, i8* %3) ; CHECK: call void @llvm.lifetime.end.p0i8(i64 16, i8* %3)
; CHECK: ret void ; CHECK: ret void
define void @test_store_fp128(fp128* %arg, fp128 %val) { define void @test_store_fp128(fp128* %arg, fp128 %val) {
store atomic fp128 %val, fp128* %arg seq_cst, align 16 store atomic fp128 %val, fp128* %arg seq_cst, align 16
ret void ret void
} }
;; Unaligned loads and stores should be expanded to the generic ;; Unaligned loads and stores should be expanded to the generic
;; libcall, just like large loads/stores, and not a specialized one. ;; libcall, just like large loads/stores, and not a specialized one.
Show All 16 Lines

test/Transforms/BBVectorize/X86/wr-aliases.ll

; RUN: opt -mtriple=x86_64-unknown-linux-gnu -mcpu=corei7-avx -disable-basicaa -bb-vectorize -S < %s | FileCheck %s ; RUN: opt -mtriple=x86_64-unknown-linux-gnu -mcpu=corei7-avx -disable-basicaa -bb-vectorize -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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
%class.QBezier.15 = type { double, double, double, double, double, double, double, double } %class.QBezier.15 = type { double, double, double, double, double, double, double, double }
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i32, i1) #0 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i32, i1) #0
; Function Attrs: uwtable ; Function Attrs: uwtable
declare fastcc void @_ZL12printQBezier7QBezier(%class.QBezier.15* byval nocapture readonly align 8) #1 declare fastcc void @_ZL12printQBezier7QBezier(%class.QBezier.15* byval nocapture readonly align 8) #1
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) #0 declare void @llvm.lifetime.start(i64, i8* nocapture) #0
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) #0 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #0
define void @main_arrayctor.cont([10 x %class.QBezier.15]* %beziers, %class.QBezier.15* %agg.tmp.i, %class.QBezier.15* %agg.tmp55.i, %class.QBezier.15* %agg.tmp56.i) { define void @main_arrayctor.cont([10 x %class.QBezier.15]* %beziers, %class.QBezier.15* %agg.tmp.i, %class.QBezier.15* %agg.tmp55.i, %class.QBezier.15* %agg.tmp56.i) {
newFuncRoot: newFuncRoot:
br label %arrayctor.cont br label %arrayctor.cont
arrayctor.cont.ret.exitStub: ; preds = %arrayctor.cont arrayctor.cont.ret.exitStub: ; preds = %arrayctor.cont
ret void ret void
▲ Show 20 Lines • Show All 103 Lines • ▼ Show 20 Linesarrayctor.cont: ; preds = %newFuncRoot
store double %mul52.i, double* %y1.i, align 8 store double %mul52.i, double* %y1.i, align 8
%y454.i = getelementptr inbounds [10 x %class.QBezier.15], [10 x %class.QBezier.15]* %beziers, i64 0, i64 1, i32 7 %y454.i = getelementptr inbounds [10 x %class.QBezier.15], [10 x %class.QBezier.15]* %beziers, i64 0, i64 1, i32 7
store double %mul52.i, double* %y454.i, align 8 store double %mul52.i, double* %y454.i, align 8
%v22 = bitcast %class.QBezier.15* %add.ptr to i8* %v22 = bitcast %class.QBezier.15* %add.ptr to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %v1, i8* %v22, i64 64, i32 8, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %v1, i8* %v22, i64 64, i32 8, i1 false)
call fastcc void @_ZL12printQBezier7QBezier(%class.QBezier.15* byval align 8 %agg.tmp55.i) call fastcc void @_ZL12printQBezier7QBezier(%class.QBezier.15* byval align 8 %agg.tmp55.i)
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %v2, i8* %v3, i64 64, i32 8, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %v2, i8* %v3, i64 64, i32 8, i1 false)
call fastcc void @_ZL12printQBezier7QBezier(%class.QBezier.15* byval align 8 %agg.tmp56.i) call fastcc void @_ZL12printQBezier7QBezier(%class.QBezier.15* byval align 8 %agg.tmp56.i)
call void @llvm.lifetime.end(i64 64, i8* %v0) call void @llvm.lifetime.end.p0i8(i64 64, i8* %v0)
call void @llvm.lifetime.end(i64 64, i8* %v1) call void @llvm.lifetime.end.p0i8(i64 64, i8* %v1)
call void @llvm.lifetime.end(i64 64, i8* %v2) call void @llvm.lifetime.end.p0i8(i64 64, i8* %v2)
br label %arrayctor.cont.ret.exitStub br label %arrayctor.cont.ret.exitStub
} }
attributes #0 = { nounwind } attributes #0 = { nounwind }
attributes #1 = { uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf"="true" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #1 = { uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf"="true" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }

test/Transforms/CodeGenPrepare/builtin-condition.ll

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
@.str = private unnamed_addr constant [8 x i8] c"\0A%d %d\0A\00", align 1 @.str = private unnamed_addr constant [8 x i8] c"\0A%d %d\0A\00", align 1
define i64 @foo1(i32 %flag) { define i64 @foo1(i32 %flag) {
entry: entry:
%chararray = alloca [30 x i8], align 16 %chararray = alloca [30 x i8], align 16
%chararray2 = alloca [10 x i8], align 1 %chararray2 = alloca [10 x i8], align 1
%0 = getelementptr inbounds [30 x i8], [30 x i8]* %chararray, i64 0, i64 0 %0 = getelementptr inbounds [30 x i8], [30 x i8]* %chararray, i64 0, i64 0
call void @llvm.lifetime.start(i64 30, i8* %0) call void @llvm.lifetime.start.p0i8(i64 30, i8* %0)
%1 = getelementptr inbounds [10 x i8], [10 x i8]* %chararray2, i64 0, i64 0 %1 = getelementptr inbounds [10 x i8], [10 x i8]* %chararray2, i64 0, i64 0
call void @llvm.lifetime.start(i64 10, i8* %1) call void @llvm.lifetime.start.p0i8(i64 10, i8* %1)
%tobool = icmp eq i32 %flag, 0 %tobool = icmp eq i32 %flag, 0
%cptr.0 = select i1 %tobool, i8* %0, i8* %1 %cptr.0 = select i1 %tobool, i8* %0, i8* %1
%2 = call i64 @llvm.objectsize.i64.p0i8(i8* %cptr.0, i1 true) %2 = call i64 @llvm.objectsize.i64.p0i8(i8* %cptr.0, i1 true)
call void @llvm.lifetime.end(i64 10, i8* %1) call void @llvm.lifetime.end.p0i8(i64 10, i8* %1)
call void @llvm.lifetime.end(i64 30, i8* %0) call void @llvm.lifetime.end.p0i8(i64 30, i8* %0)
ret i64 %2 ret i64 %2
; CHECK-LABEL: foo1 ; CHECK-LABEL: foo1
; CHECK: ret i64 10 ; CHECK: ret i64 10
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare i64 @llvm.objectsize.i64.p0i8(i8*, i1) declare i64 @llvm.objectsize.i64.p0i8(i8*, i1)
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
define i64 @foo2(i32 %n) { define i64 @foo2(i32 %n) {
entry: entry:
%Small = alloca [10 x i8], align 1 %Small = alloca [10 x i8], align 1
%Large = alloca [20 x i8], align 16 %Large = alloca [20 x i8], align 16
%0 = getelementptr inbounds [10 x i8], [10 x i8]* %Small, i64 0, i64 0 %0 = getelementptr inbounds [10 x i8], [10 x i8]* %Small, i64 0, i64 0
call void @llvm.lifetime.start(i64 10, i8* %0) call void @llvm.lifetime.start.p0i8(i64 10, i8* %0)
%1 = getelementptr inbounds [20 x i8], [20 x i8]* %Large, i64 0, i64 0 %1 = getelementptr inbounds [20 x i8], [20 x i8]* %Large, i64 0, i64 0
call void @llvm.lifetime.start(i64 20, i8* %1) call void @llvm.lifetime.start.p0i8(i64 20, i8* %1)
%tobool = icmp ne i32 %n, 0 %tobool = icmp ne i32 %n, 0
%add.ptr = getelementptr inbounds [20 x i8], [20 x i8]* %Large, i64 0, i64 19 %add.ptr = getelementptr inbounds [20 x i8], [20 x i8]* %Large, i64 0, i64 19
%cond = select i1 %tobool, i8* %0, i8* %add.ptr %cond = select i1 %tobool, i8* %0, i8* %add.ptr
%2 = call i64 @llvm.objectsize.i64.p0i8(i8* %cond, i1 false) %2 = call i64 @llvm.objectsize.i64.p0i8(i8* %cond, i1 false)
call void @llvm.lifetime.end(i64 20, i8* %1) call void @llvm.lifetime.end.p0i8(i64 20, i8* %1)
call void @llvm.lifetime.end(i64 10, i8* %0) call void @llvm.lifetime.end.p0i8(i64 10, i8* %0)
ret i64 %2 ret i64 %2
; CHECK-LABEL: foo2 ; CHECK-LABEL: foo2
; CHECK: ret i64 10 ; CHECK: ret i64 10
} }
define void @foo() { define void @foo() {
entry: entry:
%call = tail call i64 @foo1(i32 0) %call = tail call i64 @foo1(i32 0)
%call1 = tail call i64 @foo2(i32 0) %call1 = tail call i64 @foo2(i32 0)
%call2 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i64 %call, i64 %call1) %call2 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i64 %call, i64 %call1)
ret void ret void
} }
declare i32 @printf(i8* nocapture readonly, ...) declare i32 @printf(i8* nocapture readonly, ...)

test/Transforms/Coroutines/coro-split-dbg.ll

Show All 37 Linescoro_Cleanup: ; preds = %for.cond
br label %coro_Suspend, !dbg !36 br label %coro_Suspend, !dbg !36
coro_Suspend: ; preds = %for.cond, %if.then, %coro_Cleanup coro_Suspend: ; preds = %for.cond, %if.then, %coro_Cleanup
tail call i1 @llvm.coro.end(i8* null, i1 false) #9, !dbg !38 tail call i1 @llvm.coro.end(i8* null, i1 false) #9, !dbg !38
ret i8* %2, !dbg !39 ret i8* %2, !dbg !39
} }
; Function Attrs: argmemonly nounwind ; Function Attrs: argmemonly nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) #4 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #4
; Function Attrs: argmemonly nounwind readonly ; Function Attrs: argmemonly nounwind readonly
declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*) #5 declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*) #5
; Function Attrs: nounwind ; Function Attrs: nounwind
declare noalias i8* @malloc(i64) local_unnamed_addr #6 declare noalias i8* @malloc(i64) local_unnamed_addr #6
declare i64 @llvm.coro.size.i64() #1 declare i64 @llvm.coro.size.i64() #1
declare i8* @llvm.coro.begin(token, i8* writeonly) #7 declare i8* @llvm.coro.begin(token, i8* writeonly) #7
declare token @llvm.coro.save(i8*) #7 declare token @llvm.coro.save(i8*) #7
declare i8 @llvm.coro.suspend(token, i1) #7 declare i8 @llvm.coro.suspend(token, i1) #7
declare void @llvm.lifetime.end(i64, i8* nocapture) #4 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #4
declare i8* @llvm.coro.free(token, i8* nocapture readonly) #5 declare i8* @llvm.coro.free(token, i8* nocapture readonly) #5
declare void @free(i8* nocapture) local_unnamed_addr #6 declare void @free(i8* nocapture) local_unnamed_addr #6
declare i1 @llvm.coro.end(i8*, i1) #7 declare i1 @llvm.coro.end(i8*, i1) #7
declare i8* @llvm.coro.subfn.addr(i8* nocapture readonly, i8) #5 declare i8* @llvm.coro.subfn.addr(i8* nocapture readonly, i8) #5
declare void @llvm.dbg.value(metadata, i64, metadata, metadata) #1 declare void @llvm.dbg.value(metadata, i64, metadata, metadata) #1
attributes #0 = { nounwind uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #0 = { nounwind uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

test/Transforms/CorrelatedValuePropagation/alloca.ll

; RUN: opt -S -correlated-propagation -debug-only=lazy-value-info <%s 2>&1 | FileCheck %s ; RUN: opt -S -correlated-propagation -debug-only=lazy-value-info <%s 2>&1 | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; ;
; Shortcut in Correlated Value Propagation ensures not to take Lazy Value Info ; Shortcut in Correlated Value Propagation ensures not to take Lazy Value Info
; analysis for %a.i and %tmp because %a.i is defined by alloca and %tmp is ; analysis for %a.i and %tmp because %a.i is defined by alloca and %tmp is
; defined by alloca + bitcast. We know the ret value of alloca is nonnull. ; defined by alloca + bitcast. We know the ret value of alloca is nonnull.
; ;
; CHECK-NOT: LVI Getting edge value %a.i = alloca i64, align 8 at 'for.body' ; CHECK-NOT: LVI Getting edge value %a.i = alloca i64, align 8 at 'for.body'
; CHECK-NOT: LVI Getting edge value %tmp = bitcast i64* %a.i to i8* from 'for.cond' to 'for.body' ; CHECK-NOT: LVI Getting edge value %tmp = bitcast i64* %a.i to i8* from 'for.cond' to 'for.body'
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@.str = private unnamed_addr constant [8 x i8] c"a = %l\0A\00", align 1 @.str = private unnamed_addr constant [8 x i8] c"a = %l\0A\00", align 1
; Function Attrs: argmemonly nounwind ; Function Attrs: argmemonly nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @hoo(i64*) declare void @hoo(i64*)
declare i32 @printf(i8* nocapture readonly, ...) declare i32 @printf(i8* nocapture readonly, ...)
; Function Attrs: argmemonly nounwind ; Function Attrs: argmemonly nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
define void @goo(i32 %N, i64* %b) { define void @goo(i32 %N, i64* %b) {
entry: entry:
%a.i = alloca i64, align 8 %a.i = alloca i64, align 8
%tmp = bitcast i64* %a.i to i8* %tmp = bitcast i64* %a.i to i8*
%c = getelementptr inbounds i64, i64* %b, i64 0 %c = getelementptr inbounds i64, i64* %b, i64 0
br label %for.cond br label %for.cond
for.cond: ; preds = %for.body, %entry for.cond: ; preds = %for.body, %entry
%i.0 = phi i32 [ 0, %entry ], [ %inc, %for.body ] %i.0 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
%cmp = icmp slt i32 %i.0, %N %cmp = icmp slt i32 %i.0, %N
br i1 %cmp, label %for.body, label %for.end br i1 %cmp, label %for.body, label %for.end
for.body: ; preds = %for.cond for.body: ; preds = %for.cond
call void @llvm.lifetime.start(i64 8, i8* %tmp) call void @llvm.lifetime.start.p0i8(i64 8, i8* %tmp)
call void @hoo(i64* %a.i) call void @hoo(i64* %a.i)
call void @hoo(i64* %c) call void @hoo(i64* %c)
%tmp1 = load volatile i64, i64* %a.i, align 8 %tmp1 = load volatile i64, i64* %a.i, align 8
%call.i = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i64 %tmp1) %call.i = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i64 %tmp1)
call void @llvm.lifetime.end(i64 8, i8* %tmp) call void @llvm.lifetime.end.p0i8(i64 8, i8* %tmp)
%inc = add nsw i32 %i.0, 1 %inc = add nsw i32 %i.0, 1
br label %for.cond br label %for.cond
for.end: ; preds = %for.cond for.end: ; preds = %for.cond
ret void ret void
} }

test/Transforms/DeadStoreElimination/dominate.ll

; RUN: opt -dse -disable-output < %s ; RUN: opt -dse -disable-output < %s
; test that we don't crash ; test that we don't crash
declare void @bar() declare void @bar()
define void @foo() { define void @foo() {
bb1: bb1:
%memtmp3.i = alloca [21 x i8], align 1 %memtmp3.i = alloca [21 x i8], align 1
%0 = getelementptr inbounds [21 x i8], [21 x i8]* %memtmp3.i, i64 0, i64 0 %0 = getelementptr inbounds [21 x i8], [21 x i8]* %memtmp3.i, i64 0, i64 0
br label %bb3 br label %bb3
bb2: bb2:
call void @llvm.lifetime.end(i64 -1, i8* %0) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %0)
br label %bb3 br label %bb3
bb3: bb3:
call void @bar() call void @bar()
call void @llvm.lifetime.end(i64 -1, i8* %0) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %0)
br label %bb4 br label %bb4
bb4: bb4:
ret void ret void
} }
declare void @llvm.lifetime.end(i64, i8* nocapture) nounwind declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) nounwind

test/Transforms/DeadStoreElimination/lifetime.ll

; RUN: opt -S -basicaa -dse < %s | FileCheck %s ; RUN: opt -S -basicaa -dse < %s | FileCheck %s
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
declare void @llvm.lifetime.start(i64, i8* nocapture) nounwind declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) nounwind declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) nounwind
declare void @llvm.memset.p0i8.i8(i8* nocapture, i8, i8, i32, i1) nounwind declare void @llvm.memset.p0i8.i8(i8* nocapture, i8, i8, i32, i1) nounwind
define void @test1() { define void @test1() {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
%A = alloca i8 %A = alloca i8
store i8 0, i8* %A ;; Written to by memset store i8 0, i8* %A ;; Written to by memset
call void @llvm.lifetime.end(i64 1, i8* %A) call void @llvm.lifetime.end.p0i8(i64 1, i8* %A)
; CHECK: lifetime.end ; CHECK: lifetime.end
call void @llvm.memset.p0i8.i8(i8* %A, i8 0, i8 -1, i32 0, i1 false) call void @llvm.memset.p0i8.i8(i8* %A, i8 0, i8 -1, i32 0, i1 false)
; CHECK-NOT: memset ; CHECK-NOT: memset
ret void ret void
; CHECK: ret void ; CHECK: ret void
} }
define void @test2(i32* %P) { define void @test2(i32* %P) {
; CHECK: test2 ; CHECK: test2
%Q = getelementptr i32, i32* %P, i32 1 %Q = getelementptr i32, i32* %P, i32 1
%R = bitcast i32* %Q to i8* %R = bitcast i32* %Q to i8*
call void @llvm.lifetime.start(i64 4, i8* %R) call void @llvm.lifetime.start.p0i8(i64 4, i8* %R)
; CHECK: lifetime.start ; CHECK: lifetime.start
store i32 0, i32* %Q ;; This store is dead. store i32 0, i32* %Q ;; This store is dead.
; CHECK-NOT: store ; CHECK-NOT: store
call void @llvm.lifetime.end(i64 4, i8* %R) call void @llvm.lifetime.end.p0i8(i64 4, i8* %R)
; CHECK: lifetime.end ; CHECK: lifetime.end
ret void ret void
} }

test/Transforms/GVN/cond_br2.ll

Show All 12 Lines
; CHECK: @_Z4testv() ; CHECK: @_Z4testv()
; CHECK: invoke.cont: ; CHECK: invoke.cont:
; CHECK: br i1 true, label %new.notnull.i11, label %if.end.i14 ; CHECK: br i1 true, label %new.notnull.i11, label %if.end.i14
; CHECK: Retry.i10: ; CHECK: Retry.i10:
entry: entry:
%sv = alloca %"class.llvm::SmallVector", align 16 %sv = alloca %"class.llvm::SmallVector", align 16
%0 = bitcast %"class.llvm::SmallVector"* %sv to i8* %0 = bitcast %"class.llvm::SmallVector"* %sv to i8*
call void @llvm.lifetime.start(i64 64, i8* %0) #1 call void @llvm.lifetime.start.p0i8(i64 64, i8* %0) #1
%BeginX.i.i.i.i.i.i = getelementptr inbounds %"class.llvm::SmallVector", %"class.llvm::SmallVector"* %sv, i64 0, i32 0, i32 0, i32 0, i32 0, i32 0 %BeginX.i.i.i.i.i.i = getelementptr inbounds %"class.llvm::SmallVector", %"class.llvm::SmallVector"* %sv, i64 0, i32 0, i32 0, i32 0, i32 0, i32 0
%FirstEl.i.i.i.i.i.i = getelementptr inbounds %"class.llvm::SmallVector", %"class.llvm::SmallVector"* %sv, i64 0, i32 0, i32 0, i32 0, i32 0, i32 3 %FirstEl.i.i.i.i.i.i = getelementptr inbounds %"class.llvm::SmallVector", %"class.llvm::SmallVector"* %sv, i64 0, i32 0, i32 0, i32 0, i32 0, i32 3
%1 = bitcast %"union.llvm::SmallVectorBase::U"* %FirstEl.i.i.i.i.i.i to i8* %1 = bitcast %"union.llvm::SmallVectorBase::U"* %FirstEl.i.i.i.i.i.i to i8*
store i8* %1, i8** %BeginX.i.i.i.i.i.i, align 16, !tbaa !4 store i8* %1, i8** %BeginX.i.i.i.i.i.i, align 16, !tbaa !4
%EndX.i.i.i.i.i.i = getelementptr inbounds %"class.llvm::SmallVector", %"class.llvm::SmallVector"* %sv, i64 0, i32 0, i32 0, i32 0, i32 0, i32 1 %EndX.i.i.i.i.i.i = getelementptr inbounds %"class.llvm::SmallVector", %"class.llvm::SmallVector"* %sv, i64 0, i32 0, i32 0, i32 0, i32 0, i32 1
store i8* %1, i8** %EndX.i.i.i.i.i.i, align 8, !tbaa !4 store i8* %1, i8** %EndX.i.i.i.i.i.i, align 8, !tbaa !4
%CapacityX.i.i.i.i.i.i = getelementptr inbounds %"class.llvm::SmallVector", %"class.llvm::SmallVector"* %sv, i64 0, i32 0, i32 0, i32 0, i32 0, i32 2 %CapacityX.i.i.i.i.i.i = getelementptr inbounds %"class.llvm::SmallVector", %"class.llvm::SmallVector"* %sv, i64 0, i32 0, i32 0, i32 0, i32 0, i32 2
%add.ptr.i.i.i.i2.i.i = getelementptr inbounds %"union.llvm::SmallVectorBase::U", %"union.llvm::SmallVectorBase::U"* %FirstEl.i.i.i.i.i.i, i64 2 %add.ptr.i.i.i.i2.i.i = getelementptr inbounds %"union.llvm::SmallVectorBase::U", %"union.llvm::SmallVectorBase::U"* %FirstEl.i.i.i.i.i.i, i64 2
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Linesinvoke.cont3: ; preds = %invoke.cont2
%cmp.i.i.i.i19 = icmp eq i8* %11, %1 %cmp.i.i.i.i19 = icmp eq i8* %11, %1
br i1 %cmp.i.i.i.i19, label %_ZN4llvm11SmallVectorIiLj8EED1Ev.exit21, label %if.then.i.i.i20 br i1 %cmp.i.i.i.i19, label %_ZN4llvm11SmallVectorIiLj8EED1Ev.exit21, label %if.then.i.i.i20
if.then.i.i.i20: ; preds = %invoke.cont3 if.then.i.i.i20: ; preds = %invoke.cont3
call void @free(i8* %11) #1 call void @free(i8* %11) #1
br label %_ZN4llvm11SmallVectorIiLj8EED1Ev.exit21 br label %_ZN4llvm11SmallVectorIiLj8EED1Ev.exit21
_ZN4llvm11SmallVectorIiLj8EED1Ev.exit21: ; preds = %invoke.cont3, %if.then.i.i.i20 _ZN4llvm11SmallVectorIiLj8EED1Ev.exit21: ; preds = %invoke.cont3, %if.then.i.i.i20
call void @llvm.lifetime.end(i64 64, i8* %0) #1 call void @llvm.lifetime.end.p0i8(i64 64, i8* %0) #1
ret void ret void
lpad: ; preds = %if.end.i14, %if.end.i, %invoke.cont2 lpad: ; preds = %if.end.i14, %if.end.i, %invoke.cont2
%12 = landingpad { i8*, i32 } %12 = landingpad { i8*, i32 }
cleanup cleanup
%13 = load i8*, i8** %BeginX.i.i.i.i.i.i, align 16, !tbaa !4 %13 = load i8*, i8** %BeginX.i.i.i.i.i.i, align 16, !tbaa !4
%cmp.i.i.i.i = icmp eq i8* %13, %1 %cmp.i.i.i.i = icmp eq i8* %13, %1
br i1 %cmp.i.i.i.i, label %eh.resume, label %if.then.i.i.i br i1 %cmp.i.i.i.i, label %eh.resume, label %if.then.i.i.i
if.then.i.i.i: ; preds = %lpad if.then.i.i.i: ; preds = %lpad
call void @free(i8* %13) #1 call void @free(i8* %13) #1
br label %eh.resume br label %eh.resume
eh.resume: ; preds = %if.then.i.i.i, %lpad eh.resume: ; preds = %if.then.i.i.i, %lpad
resume { i8*, i32 } %12 resume { i8*, i32 } %12
} }
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
declare i32 @__gxx_personality_v0(...) declare i32 @__gxx_personality_v0(...)
declare void @_Z1gRN4llvm11SmallVectorIiLj8EEE(%"class.llvm::SmallVector"*) #2 declare void @_Z1gRN4llvm11SmallVectorIiLj8EEE(%"class.llvm::SmallVector"*) #2
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
declare void @_ZN4llvm15SmallVectorBase8grow_podEmm(%"class.llvm::SmallVectorBase"*, i64, i64) #2 declare void @_ZN4llvm15SmallVectorBase8grow_podEmm(%"class.llvm::SmallVectorBase"*, i64, i64) #2
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @free(i8* nocapture) #3 declare void @free(i8* nocapture) #3
attributes #0 = { ssp uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #0 = { ssp uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { nounwind } attributes #1 = { nounwind }
Show All 9 Lines

test/Transforms/GVN/lifetime-simple.ll

; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basicaa -gvn -S | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin7" target triple = "i386-apple-darwin7"
define i8 @test(i8* %P) nounwind { define i8 @test(i8* %P) nounwind {
; CHECK: lifetime.start ; CHECK: lifetime.start
; CHECK-NOT: load ; CHECK-NOT: load
; CHECK: lifetime.end ; CHECK: lifetime.end
entry: entry:
call void @llvm.lifetime.start(i64 32, i8* %P) call void @llvm.lifetime.start.p0i8(i64 32, i8* %P)
%0 = load i8, i8* %P %0 = load i8, i8* %P
store i8 1, i8* %P store i8 1, i8* %P
call void @llvm.lifetime.end(i64 32, i8* %P) call void @llvm.lifetime.end.p0i8(i64 32, i8* %P)
%1 = load i8, i8* %P %1 = load i8, i8* %P
ret i8 %1 ret i8 %1
} }
declare void @llvm.lifetime.start(i64 %S, i8* nocapture %P) readonly declare void @llvm.lifetime.start.p0i8(i64 %S, i8* nocapture %P) readonly
declare void @llvm.lifetime.end(i64 %S, i8* nocapture %P) declare void @llvm.lifetime.end.p0i8(i64 %S, i8* nocapture %P)

test/Transforms/GVNHoist/pr29034.ll

Show All 32 Lines
%struct._FS_BRK_INFO = type { i32, i32, [8 x i8], i8, i8, i16 } %struct._FS_BRK_INFO = type { i32, i32, [8 x i8], i8, i8, i16 }
@.str = external hidden unnamed_addr constant [10 x i8], align 1 @.str = external hidden unnamed_addr constant [10 x i8], align 1
define void @music_task(i8* nocapture readnone %p) local_unnamed_addr { define void @music_task(i8* nocapture readnone %p) local_unnamed_addr {
entry: entry:
%mapi = alloca %struct._MUSIC_OP_API_*, align 8 %mapi = alloca %struct._MUSIC_OP_API_*, align 8
%0 = bitcast %struct._MUSIC_OP_API_** %mapi to i8* %0 = bitcast %struct._MUSIC_OP_API_** %mapi to i8*
call void @llvm.lifetime.start(i64 8, i8* %0) call void @llvm.lifetime.start.p0i8(i64 8, i8* %0)
store %struct._MUSIC_OP_API_* null, %struct._MUSIC_OP_API_** %mapi, align 8, !tbaa !1 store %struct._MUSIC_OP_API_* null, %struct._MUSIC_OP_API_** %mapi, align 8, !tbaa !1
%call = call i32 @music_decoder_init(%struct._MUSIC_OP_API_** nonnull %mapi) %call = call i32 @music_decoder_init(%struct._MUSIC_OP_API_** nonnull %mapi)
br label %while.cond br label %while.cond
while.cond.loopexit: ; preds = %while.cond2 while.cond.loopexit: ; preds = %while.cond2
br label %while.cond br label %while.cond
while.cond: ; preds = %while.cond.loopexit, %entry while.cond: ; preds = %while.cond.loopexit, %entry
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Linessw.default: ; preds = %while.cond2
%call19 = call i32 @music_play_api(%struct._MUSIC_OP_API_* %13, i32 33, i32 0, i32 22, i8* null) %call19 = call i32 @music_play_api(%struct._MUSIC_OP_API_* %13, i32 33, i32 0, i32 22, i8* null)
br label %while.cond2.backedge br label %while.cond2.backedge
while.cond2.backedge: ; preds = %sw.default, %sw.bb13, %sw.bb7, %sw.bb while.cond2.backedge: ; preds = %sw.default, %sw.bb13, %sw.bb7, %sw.bb
%err.0.be = phi i32 [ %call19, %sw.default ], [ %call18, %sw.bb13 ], [ %call12, %sw.bb7 ], [ 0, %sw.bb ] %err.0.be = phi i32 [ %call19, %sw.default ], [ %call18, %sw.bb13 ], [ %call12, %sw.bb7 ], [ 0, %sw.bb ]
br label %while.cond2 br label %while.cond2
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare i32 @music_decoder_init(%struct._MUSIC_OP_API_**) declare i32 @music_decoder_init(%struct._MUSIC_OP_API_**)
declare i32 @music_play_api(%struct._MUSIC_OP_API_*, i32, i32, i32, i8*) declare i32 @music_play_api(%struct._MUSIC_OP_API_*, i32, i32, i32, i8*)
declare i32 @printf(i8* nocapture readonly, ...) declare i32 @printf(i8* nocapture readonly, ...)
!0 = !{!"clang version 4.0.0 "} !0 = !{!"clang version 4.0.0 "}
!1 = !{!2, !2, i64 0} !1 = !{!2, !2, i64 0}
!2 = !{!"any pointer", !3, i64 0} !2 = !{!"any pointer", !3, i64 0}
!3 = !{!"omnipotent char", !4, i64 0} !3 = !{!"omnipotent char", !4, i64 0}
!4 = !{!"Simple C/C++ TBAA"} !4 = !{!"Simple C/C++ TBAA"}
!5 = !{!6, !2, i64 8} !5 = !{!6, !2, i64 8}
!6 = !{!"_MUSIC_OP_API_", !2, i64 0, !2, i64 8} !6 = !{!"_MUSIC_OP_API_", !2, i64 0, !2, i64 8}
!7 = !{!8, !9, i64 16} !7 = !{!8, !9, i64 16}
!8 = !{!"__MUSIC_API", !2, i64 0, !2, i64 8, !9, i64 16, !10, i64 20, !2, i64 140, !2, i64 148} !8 = !{!"__MUSIC_API", !2, i64 0, !2, i64 8, !9, i64 16, !10, i64 20, !2, i64 140, !2, i64 148}
!9 = !{!"int", !3, i64 0} !9 = !{!"int", !3, i64 0}
!10 = !{!"_DEC_API", !2, i64 0, !2, i64 8, !2, i64 16, !2, i64 24, !2, i64 32, !2, i64 40, !11, i64 48, !9, i64 60, !9, i64 64, !2, i64 72, !2, i64 80, !9, i64 88, !3, i64 92, !2, i64 96, !3, i64 104, !2, i64 112} !10 = !{!"_DEC_API", !2, i64 0, !2, i64 8, !2, i64 16, !2, i64 24, !2, i64 32, !2, i64 40, !11, i64 48, !9, i64 60, !9, i64 64, !2, i64 72, !2, i64 80, !9, i64 88, !3, i64 92, !2, i64 96, !3, i64 104, !2, i64 112}
!11 = !{!"_AAC_DEFAULT_SETTING", !9, i64 0, !9, i64 4, !9, i64 8} !11 = !{!"_AAC_DEFAULT_SETTING", !9, i64 0, !9, i64 4, !9, i64 8}

test/Transforms/IndVarSimplify/exit_value_test2.ll

; PR23538 ; PR23538
; RUN: opt < %s -indvars -loop-deletion -S | FileCheck %s ; RUN: opt < %s -indvars -loop-deletion -S | FileCheck %s
; Check IndVarSimplify should not replace exit value because or else ; Check IndVarSimplify should not replace exit value because or else
; udiv will be introduced by expand and the cost will be high. ; udiv will be introduced by expand and the cost will be high.
; ;
; CHECK-LABEL: @_Z3fooPKcjj( ; CHECK-LABEL: @_Z3fooPKcjj(
; CHECK-NOT: udiv ; CHECK-NOT: udiv
declare void @_Z3mixRjj(i32* dereferenceable(4), i32) declare void @_Z3mixRjj(i32* dereferenceable(4), i32)
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
define i32 @_Z3fooPKcjj(i8* nocapture readonly %s, i32 %len, i32 %c) { define i32 @_Z3fooPKcjj(i8* nocapture readonly %s, i32 %len, i32 %c) {
entry: entry:
%a = alloca i32, align 4 %a = alloca i32, align 4
%tmp = bitcast i32* %a to i8* %tmp = bitcast i32* %a to i8*
call void @llvm.lifetime.start(i64 4, i8* %tmp) call void @llvm.lifetime.start.p0i8(i64 4, i8* %tmp)
store i32 -1640531527, i32* %a, align 4 store i32 -1640531527, i32* %a, align 4
%cmp8 = icmp ugt i32 %len, 11 %cmp8 = icmp ugt i32 %len, 11
br i1 %cmp8, label %while.body.lr.ph, label %while.end br i1 %cmp8, label %while.body.lr.ph, label %while.end
while.body.lr.ph: ; preds = %entry while.body.lr.ph: ; preds = %entry
br label %while.body br label %while.body
while.body: ; preds = %while.body, %while.body.lr.ph while.body: ; preds = %while.body, %while.body.lr.ph
Show All 15 Lines
while.cond.while.end_crit_edge: ; preds = %while.body while.cond.while.end_crit_edge: ; preds = %while.body
%sub.lcssa = phi i32 [ %sub, %while.body ] %sub.lcssa = phi i32 [ %sub, %while.body ]
br label %while.end br label %while.end
while.end: ; preds = %while.cond.while.end_crit_edge, %entry while.end: ; preds = %while.cond.while.end_crit_edge, %entry
%keylen.0.lcssa = phi i32 [ %sub.lcssa, %while.cond.while.end_crit_edge ], [ %len, %entry ] %keylen.0.lcssa = phi i32 [ %sub.lcssa, %while.cond.while.end_crit_edge ], [ %len, %entry ]
call void @_Z3mixRjj(i32* dereferenceable(4) %a, i32 %keylen.0.lcssa) call void @_Z3mixRjj(i32* dereferenceable(4) %a, i32 %keylen.0.lcssa)
%tmp4 = load i32, i32* %a, align 4 %tmp4 = load i32, i32* %a, align 4
call void @llvm.lifetime.end(i64 4, i8* %tmp) call void @llvm.lifetime.end.p0i8(i64 4, i8* %tmp)
ret i32 %tmp4 ret i32 %tmp4
} }

test/Transforms/Inline/alloca-bonus.ll

; RUN: opt -inline < %s -S -o - -inline-threshold=8 | FileCheck %s ; RUN: opt -inline < %s -S -o - -inline-threshold=8 | FileCheck %s
; RUN: opt -passes='cgscc(inline)' < %s -S -o - -inline-threshold=8 | FileCheck %s ; RUN: opt -passes='cgscc(inline)' < %s -S -o - -inline-threshold=8 | FileCheck %s
target datalayout = "p:32:32" target datalayout = "p:32:32"
declare void @llvm.lifetime.start(i64 %size, i8* nocapture %ptr) declare void @llvm.lifetime.start.p0i8(i64 %size, i8* nocapture %ptr)
@glbl = external global i32 @glbl = external global i32
define void @outer1() { define void @outer1() {
; CHECK-LABEL: @outer1( ; CHECK-LABEL: @outer1(
; CHECK-NOT: call void @inner1 ; CHECK-NOT: call void @inner1
%ptr = alloca i32 %ptr = alloca i32
call void @inner1(i32* %ptr) call void @inner1(i32* %ptr)
ret void ret void
} }
define void @inner1(i32 *%ptr) { define void @inner1(i32 *%ptr) {
%A = load i32, i32* %ptr %A = load i32, i32* %ptr
store i32 0, i32* %ptr store i32 0, i32* %ptr
%C = getelementptr inbounds i32, i32* %ptr, i32 0 %C = getelementptr inbounds i32, i32* %ptr, i32 0
%D = getelementptr inbounds i32, i32* %ptr, i32 1 %D = getelementptr inbounds i32, i32* %ptr, i32 1
%E = bitcast i32* %ptr to i8* %E = bitcast i32* %ptr to i8*
%F = select i1 false, i32* %ptr, i32* @glbl %F = select i1 false, i32* %ptr, i32* @glbl
call void @llvm.lifetime.start(i64 0, i8* %E) call void @llvm.lifetime.start.p0i8(i64 0, i8* %E)
call void @extern() call void @extern()
ret void ret void
} }
define void @outer2() { define void @outer2() {
; CHECK-LABEL: @outer2( ; CHECK-LABEL: @outer2(
; CHECK: call void @inner2 ; CHECK: call void @inner2
%ptr = alloca i32 %ptr = alloca i32
call void @inner2(i32* %ptr) call void @inner2(i32* %ptr)
ret void ret void
} }
; %D poisons this call, scalar-repl can't handle that instruction. ; %D poisons this call, scalar-repl can't handle that instruction.
define void @inner2(i32 *%ptr) { define void @inner2(i32 *%ptr) {
%A = load i32, i32* %ptr %A = load i32, i32* %ptr
store i32 0, i32* %ptr store i32 0, i32* %ptr
%C = getelementptr inbounds i32, i32* %ptr, i32 0 %C = getelementptr inbounds i32, i32* %ptr, i32 0
%D = getelementptr inbounds i32, i32* %ptr, i32 %A %D = getelementptr inbounds i32, i32* %ptr, i32 %A
%E = bitcast i32* %ptr to i8* %E = bitcast i32* %ptr to i8*
%F = select i1 false, i32* %ptr, i32* @glbl %F = select i1 false, i32* %ptr, i32* @glbl
call void @llvm.lifetime.start(i64 0, i8* %E) call void @llvm.lifetime.start.p0i8(i64 0, i8* %E)
call void @extern() call void @extern()
ret void ret void
} }
define void @outer3() { define void @outer3() {
; CHECK-LABEL: @outer3( ; CHECK-LABEL: @outer3(
; CHECK-NOT: call void @inner3 ; CHECK-NOT: call void @inner3
%ptr = alloca i32 %ptr = alloca i32
▲ Show 20 Lines • Show All 92 Lines • ▼ Show 20 Linesdefine void @inner5(i1 %flag, i32 *%ptr) {
call void @extern() call void @extern()
%C = getelementptr inbounds i32, i32* %ptr, i32 0 %C = getelementptr inbounds i32, i32* %ptr, i32 0
br i1 %flag, label %if.then, label %exit br i1 %flag, label %if.then, label %exit
if.then: if.then:
%D = getelementptr inbounds i32, i32* %ptr, i32 %A %D = getelementptr inbounds i32, i32* %ptr, i32 %A
%E = bitcast i32* %ptr to i8* %E = bitcast i32* %ptr to i8*
%F = select i1 false, i32* %ptr, i32* @glbl %F = select i1 false, i32* %ptr, i32* @glbl
call void @llvm.lifetime.start(i64 0, i8* %E) call void @llvm.lifetime.start.p0i8(i64 0, i8* %E)
ret void ret void
exit: exit:
ret void ret void
} }
declare void @extern() declare void @extern()

test/Transforms/Inline/crash-lifetime-marker.ll

Show All 9 Lines
define i32 @callee1(i32 %count) { define i32 @callee1(i32 %count) {
%a0 = alloca i8, i32 %count, align 4 %a0 = alloca i8, i32 %count, align 4
%call0 = call i32 @callee2(i8* %a0) %call0 = call i32 @callee2(i8* %a0)
ret i32 %call0 ret i32 %call0
} }
; CHECK-LABEL: define i32 @caller1( ; CHECK-LABEL: define i32 @caller1(
; CHECK: [[ALLOCA:%[a-z0-9\.]+]] = alloca i8 ; CHECK: [[ALLOCA:%[a-z0-9\.]+]] = alloca i8
; CHECK-NOT: call void @llvm.lifetime.start( ; CHECK-NOT: call void @llvm.lifetime.start.p0i8(
; CHECK: call i32 @callee2(i8* [[ALLOCA]]) ; CHECK: call i32 @callee2(i8* [[ALLOCA]])
; CHECK-NOT: call void @llvm.lifetime.end( ; CHECK-NOT: call void @llvm.lifetime.end.p0i8(
define i32 @caller1(i32 %count) { define i32 @caller1(i32 %count) {
%call0 = call i32 @callee1(i32 0) %call0 = call i32 @callee1(i32 0)
ret i32 %call0 ret i32 %call0
} }

test/Transforms/Inline/lifetime-no-datalayout.ll

; RUN: opt -inline -S < %s | FileCheck %s ; RUN: opt -inline -S < %s | FileCheck %s
; RUN: opt -passes='cgscc(inline)' -S < %s | FileCheck %s ; RUN: opt -passes='cgscc(inline)' -S < %s | FileCheck %s
declare void @use(i8* %a) declare void @use(i8* %a)
define void @helper() { define void @helper() {
%a = alloca i8 %a = alloca i8
call void @use(i8* %a) call void @use(i8* %a)
ret void ret void
} }
; Size in llvm.lifetime.X should be 1 (default for i8). ; Size in llvm.lifetime.X should be 1 (default for i8).
define void @test() { define void @test() {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NOT: lifetime ; CHECK-NOT: lifetime
; CHECK: llvm.lifetime.start(i64 1 ; CHECK: llvm.lifetime.start.p0i8(i64 1
; CHECK-NOT: lifetime ; CHECK-NOT: lifetime
; CHECK: llvm.lifetime.end(i64 1 ; CHECK: llvm.lifetime.end.p0i8(i64 1
call void @helper() call void @helper()
; CHECK-NOT: lifetime ; CHECK-NOT: lifetime
; CHECK: ret void ; CHECK: ret void
ret void ret void
} }

test/Transforms/Inline/lifetime.ll

; RUN: opt -inline -S < %s | FileCheck %s ; RUN: opt -inline -S < %s | FileCheck %s
; RUN: opt -passes='cgscc(inline)' -S < %s | FileCheck %s ; RUN: opt -passes='cgscc(inline)' -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.lifetime.start(i64, i8*) declare void @llvm.lifetime.start.p0i8(i64, i8*)
declare void @llvm.lifetime.end(i64, i8*) declare void @llvm.lifetime.end.p0i8(i64, i8*)
define void @helper_both_markers() { define void @helper_both_markers() {
%a = alloca i8 %a = alloca i8
; Size in llvm.lifetime.start / llvm.lifetime.end differs from ; Size in llvm.lifetime.start / llvm.lifetime.end differs from
; allocation size. We should use the former. ; allocation size. We should use the former.
call void @llvm.lifetime.start(i64 2, i8* %a) call void @llvm.lifetime.start.p0i8(i64 2, i8* %a)
call void @llvm.lifetime.end(i64 2, i8* %a) call void @llvm.lifetime.end.p0i8(i64 2, i8* %a)
ret void ret void
} }
define void @test_both_markers() { define void @test_both_markers() {
; CHECK-LABEL: @test_both_markers( ; CHECK-LABEL: @test_both_markers(
; CHECK: llvm.lifetime.start(i64 2 ; CHECK: llvm.lifetime.start.p0i8(i64 2
; CHECK-NEXT: llvm.lifetime.end(i64 2 ; CHECK-NEXT: llvm.lifetime.end.p0i8(i64 2
call void @helper_both_markers() call void @helper_both_markers()
; CHECK-NEXT: llvm.lifetime.start(i64 2 ; CHECK-NEXT: llvm.lifetime.start.p0i8(i64 2
; CHECK-NEXT: llvm.lifetime.end(i64 2 ; CHECK-NEXT: llvm.lifetime.end.p0i8(i64 2
call void @helper_both_markers() call void @helper_both_markers()
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
ret void ret void
} }
;; Without this, the inliner will simplify out @test_no_marker before adding ;; Without this, the inliner will simplify out @test_no_marker before adding
;; any lifetime markers. ;; any lifetime markers.
declare void @use(i8* %a) declare void @use(i8* %a)
define void @helper_no_markers() { define void @helper_no_markers() {
%a = alloca i8 ; Allocation size is 1 byte. %a = alloca i8 ; Allocation size is 1 byte.
call void @use(i8* %a) call void @use(i8* %a)
ret void ret void
} }
;; We can't use CHECK-NEXT because there's an extra call void @use in between. ;; We can't use CHECK-NEXT because there's an extra call void @use in between.
;; Instead, we use CHECK-NOT to verify that there are no other lifetime calls. ;; Instead, we use CHECK-NOT to verify that there are no other lifetime calls.
define void @test_no_marker() { define void @test_no_marker() {
; CHECK-LABEL: @test_no_marker( ; CHECK-LABEL: @test_no_marker(
; CHECK-NOT: lifetime ; CHECK-NOT: lifetime
; CHECK: llvm.lifetime.start(i64 1 ; CHECK: llvm.lifetime.start.p0i8(i64 1
; CHECK-NOT: lifetime ; CHECK-NOT: lifetime
; CHECK: llvm.lifetime.end(i64 1 ; CHECK: llvm.lifetime.end.p0i8(i64 1
call void @helper_no_markers() call void @helper_no_markers()
; CHECK-NOT: lifetime ; CHECK-NOT: lifetime
; CHECK: llvm.lifetime.start(i64 1 ; CHECK: llvm.lifetime.start.p0i8(i64 1
; CHECK-NOT: lifetime ; CHECK-NOT: lifetime
; CHECK: llvm.lifetime.end(i64 1 ; CHECK: llvm.lifetime.end.p0i8(i64 1
call void @helper_no_markers() call void @helper_no_markers()
; CHECK-NOT: lifetime ; CHECK-NOT: lifetime
; CHECK: ret void ; CHECK: ret void
ret void ret void
} }
define void @helper_two_casts() { define void @helper_two_casts() {
%a = alloca i32 %a = alloca i32
%b = bitcast i32* %a to i8* %b = bitcast i32* %a to i8*
call void @llvm.lifetime.start(i64 4, i8* %b) call void @llvm.lifetime.start.p0i8(i64 4, i8* %b)
%c = bitcast i32* %a to i8* %c = bitcast i32* %a to i8*
call void @llvm.lifetime.end(i64 4, i8* %c) call void @llvm.lifetime.end.p0i8(i64 4, i8* %c)
ret void ret void
} }
define void @test_two_casts() { define void @test_two_casts() {
; CHECK-LABEL: @test_two_casts( ; CHECK-LABEL: @test_two_casts(
; CHECK-NOT: lifetime ; CHECK-NOT: lifetime
; CHECK: llvm.lifetime.start(i64 4 ; CHECK: llvm.lifetime.start.p0i8(i64 4
; CHECK-NOT: lifetime ; CHECK-NOT: lifetime
; CHECK: llvm.lifetime.end(i64 4 ; CHECK: llvm.lifetime.end.p0i8(i64 4
call void @helper_two_casts() call void @helper_two_casts()
; CHECK-NOT: lifetime ; CHECK-NOT: lifetime
; CHECK: llvm.lifetime.start(i64 4 ; CHECK: llvm.lifetime.start.p0i8(i64 4
; CHECK-NOT: lifetime ; CHECK-NOT: lifetime
; CHECK: llvm.lifetime.end(i64 4 ; CHECK: llvm.lifetime.end.p0i8(i64 4
call void @helper_two_casts() call void @helper_two_casts()
; CHECK-NOT: lifetime ; CHECK-NOT: lifetime
; CHECK: ret void ; CHECK: ret void
ret void ret void
} }
define void @helper_arrays_alloca() { define void @helper_arrays_alloca() {
%a = alloca [10 x i32], align 16 %a = alloca [10 x i32], align 16
%1 = bitcast [10 x i32]* %a to i8* %1 = bitcast [10 x i32]* %a to i8*
call void @use(i8* %1) call void @use(i8* %1)
ret void ret void
} }
define void @test_arrays_alloca() { define void @test_arrays_alloca() {
; CHECK-LABEL: @test_arrays_alloca( ; CHECK-LABEL: @test_arrays_alloca(
; CHECK-NOT: lifetime ; CHECK-NOT: lifetime
; CHECK: llvm.lifetime.start(i64 40, ; CHECK: llvm.lifetime.start.p0i8(i64 40,
; CHECK-NOT: lifetime ; CHECK-NOT: lifetime
; CHECK: llvm.lifetime.end(i64 40, ; CHECK: llvm.lifetime.end.p0i8(i64 40,
call void @helper_arrays_alloca() call void @helper_arrays_alloca()
; CHECK-NOT: lifetime ; CHECK-NOT: lifetime
; CHECK: ret void ; CHECK: ret void
ret void ret void
} }
%swift.error = type opaque %swift.error = type opaque
Show All 14 Lines

test/Transforms/InstCombine/builtin-object-size-offset.ll

Show All 20 Lines
@.str = private unnamed_addr constant [5 x i8] c"\0A %d\00", align 1 @.str = private unnamed_addr constant [5 x i8] c"\0A %d\00", align 1
define i32 @foo1(i32 %N) { define i32 @foo1(i32 %N) {
entry: entry:
%Big = alloca [20 x i8], align 16 %Big = alloca [20 x i8], align 16
%Small = alloca [10 x i8], align 1 %Small = alloca [10 x i8], align 1
%0 = getelementptr inbounds [20 x i8], [20 x i8]* %Big, i64 0, i64 0 %0 = getelementptr inbounds [20 x i8], [20 x i8]* %Big, i64 0, i64 0
call void @llvm.lifetime.start(i64 20, i8* %0) call void @llvm.lifetime.start.p0i8(i64 20, i8* %0)
%1 = getelementptr inbounds [10 x i8], [10 x i8]* %Small, i64 0, i64 0 %1 = getelementptr inbounds [10 x i8], [10 x i8]* %Small, i64 0, i64 0
call void @llvm.lifetime.start(i64 10, i8* %1) call void @llvm.lifetime.start.p0i8(i64 10, i8* %1)
%tobool = icmp ne i32 %N, 0 %tobool = icmp ne i32 %N, 0
%add.ptr = getelementptr inbounds [20 x i8], [20 x i8]* %Big, i64 0, i64 10 %add.ptr = getelementptr inbounds [20 x i8], [20 x i8]* %Big, i64 0, i64 10
%cond = select i1 %tobool, i8* %add.ptr, i8* %1 %cond = select i1 %tobool, i8* %add.ptr, i8* %1
%2 = call i64 @llvm.objectsize.i64.p0i8(i8* %cond, i1 false) %2 = call i64 @llvm.objectsize.i64.p0i8(i8* %cond, i1 false)
%conv = trunc i64 %2 to i32 %conv = trunc i64 %2 to i32
call void @llvm.lifetime.end(i64 10, i8* %1) call void @llvm.lifetime.end.p0i8(i64 10, i8* %1)
call void @llvm.lifetime.end(i64 20, i8* %0) call void @llvm.lifetime.end.p0i8(i64 20, i8* %0)
ret i32 %conv ret i32 %conv
; CHECK: ret i32 10 ; CHECK: ret i32 10
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare i64 @llvm.objectsize.i64.p0i8(i8*, i1) declare i64 @llvm.objectsize.i64.p0i8(i8*, i1)
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
define void @foo() { define void @foo() {
entry: entry:
%call = tail call i32 @foo1(i32 0) %call = tail call i32 @foo1(i32 0)
%conv = sext i32 %call to i64 %conv = sext i32 %call to i64
%call1 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i64 %conv) %call1 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i64 %conv)
ret void ret void
} }
declare i32 @printf(i8* nocapture readonly, ...) declare i32 @printf(i8* nocapture readonly, ...)

test/Transforms/InstCombine/builtin-object-size-ptr.ll

Show All 10 Lines
; } ; }
%struct.V = type { [10 x i8], i32, [10 x i8] } %struct.V = type { [10 x i8], i32, [10 x i8] }
define i32 @foo() #0 { define i32 @foo() #0 {
entry: entry:
%var = alloca %struct.V, align 4 %var = alloca %struct.V, align 4
%0 = bitcast %struct.V* %var to i8* %0 = bitcast %struct.V* %var to i8*
call void @llvm.lifetime.start(i64 28, i8* %0) #3 call void @llvm.lifetime.start.p0i8(i64 28, i8* %0) #3
%buf1 = getelementptr inbounds %struct.V, %struct.V* %var, i32 0, i32 0 %buf1 = getelementptr inbounds %struct.V, %struct.V* %var, i32 0, i32 0
%arrayidx = getelementptr inbounds [10 x i8], [10 x i8]* %buf1, i64 0, i64 1 %arrayidx = getelementptr inbounds [10 x i8], [10 x i8]* %buf1, i64 0, i64 1
%1 = call i64 @llvm.objectsize.i64.p0i8(i8* %arrayidx, i1 false) %1 = call i64 @llvm.objectsize.i64.p0i8(i8* %arrayidx, i1 false)
%conv = trunc i64 %1 to i32 %conv = trunc i64 %1 to i32
call void @llvm.lifetime.end(i64 28, i8* %0) #3 call void @llvm.lifetime.end.p0i8(i64 28, i8* %0) #3
ret i32 %conv ret i32 %conv
; CHECK: ret i32 27 ; CHECK: ret i32 27
; CHECK-NOT: ret i32 -1 ; CHECK-NOT: ret i32 -1
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
declare i64 @llvm.objectsize.i64.p0i8(i8*, i1) #2 declare i64 @llvm.objectsize.i64.p0i8(i8*, i1) #2
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1

test/Transforms/InstCombine/compare-alloca.ll

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Linesdefine i1 @alloca_argument_compare_escaped_through_store(i64* %arg, i64** %ptr) {
%p = getelementptr i64, i64* %alloc, i64 1 %p = getelementptr i64, i64* %alloc, i64 1
store i64* %p, i64** %ptr store i64* %p, i64** %ptr
ret i1 %cmp ret i1 %cmp
; CHECK-LABEL: alloca_argument_compare_escaped_through_store ; CHECK-LABEL: alloca_argument_compare_escaped_through_store
; CHECK: %cmp = icmp eq i64* %alloc, %arg ; CHECK: %cmp = icmp eq i64* %alloc, %arg
; CHECK: ret i1 %cmp ; CHECK: ret i1 %cmp
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
define i1 @alloca_argument_compare_benign_instrs(i8* %arg) { define i1 @alloca_argument_compare_benign_instrs(i8* %arg) {
%alloc = alloca i8 %alloc = alloca i8
call void @llvm.lifetime.start(i64 1, i8* %alloc) call void @llvm.lifetime.start.p0i8(i64 1, i8* %alloc)
%cmp = icmp eq i8* %arg, %alloc %cmp = icmp eq i8* %arg, %alloc
%x = load i8, i8* %arg %x = load i8, i8* %arg
store i8 %x, i8* %alloc store i8 %x, i8* %alloc
call void @llvm.lifetime.end(i64 1, i8* %alloc) call void @llvm.lifetime.end.p0i8(i64 1, i8* %alloc)
ret i1 %cmp ret i1 %cmp
; CHECK-LABEL: alloca_argument_compare_benign_instrs ; CHECK-LABEL: alloca_argument_compare_benign_instrs
; CHECK: ret i1 false ; CHECK: ret i1 false
} }
declare i64* @allocator() declare i64* @allocator()
define i1 @alloca_call_compare() { define i1 @alloca_call_compare() {
%p = alloca i64 %p = alloca i64
%q = call i64* @allocator() %q = call i64* @allocator()
%cmp = icmp eq i64* %p, %q %cmp = icmp eq i64* %p, %q
ret i1 %cmp ret i1 %cmp
; CHECK-LABEL: alloca_call_compare ; CHECK-LABEL: alloca_call_compare
; CHECK: ret i1 false ; CHECK: ret i1 false
} }

test/Transforms/InstCombine/deadcode.ll

Show All 16 Lines
define i32* @test2(i32 %width) { define i32* @test2(i32 %width) {
%tmp = call i8* @llvm.stacksave( ) %tmp = call i8* @llvm.stacksave( )
%tmp14 = alloca i32, i32 %width %tmp14 = alloca i32, i32 %width
ret i32* %tmp14 ret i32* %tmp14
} }
declare i8* @llvm.stacksave() declare i8* @llvm.stacksave()
declare void @llvm.lifetime.start(i64, i8*) declare void @llvm.lifetime.start.p0i8(i64, i8*)
declare void @llvm.lifetime.end(i64, i8*) declare void @llvm.lifetime.end.p0i8(i64, i8*)
define void @test3() { define void @test3() {
call void @llvm.lifetime.start(i64 -1, i8* undef) call void @llvm.lifetime.start.p0i8(i64 -1, i8* undef)
call void @llvm.lifetime.end(i64 -1, i8* undef) call void @llvm.lifetime.end.p0i8(i64 -1, i8* undef)
ret void ret void
} }

test/Transforms/InstCombine/lifetime-asan.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -instcombine -S | FileCheck %s
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
declare void @foo(i8* nocapture) declare void @foo(i8* nocapture)
define void @asan() sanitize_address { define void @asan() sanitize_address {
entry: entry:
; CHECK-LABEL: @asan( ; CHECK-LABEL: @asan(
%text = alloca i8, align 1 %text = alloca i8, align 1
call void @llvm.lifetime.start(i64 1, i8* %text) call void @llvm.lifetime.start.p0i8(i64 1, i8* %text)
call void @llvm.lifetime.end(i64 1, i8* %text) call void @llvm.lifetime.end.p0i8(i64 1, i8* %text)
; CHECK: call void @llvm.lifetime.start ; CHECK: call void @llvm.lifetime.start
; CHECK-NEXT: call void @llvm.lifetime.end ; CHECK-NEXT: call void @llvm.lifetime.end
call void @foo(i8* %text) ; Keep alloca alive call void @foo(i8* %text) ; Keep alloca alive
ret void ret void
} }
define void @no_asan() { define void @no_asan() {
entry: entry:
; CHECK-LABEL: @no_asan( ; CHECK-LABEL: @no_asan(
%text = alloca i8, align 1 %text = alloca i8, align 1
call void @llvm.lifetime.start(i64 1, i8* %text) call void @llvm.lifetime.start.p0i8(i64 1, i8* %text)
call void @llvm.lifetime.end(i64 1, i8* %text) call void @llvm.lifetime.end.p0i8(i64 1, i8* %text)
; CHECK-NO: call void @llvm.lifetime ; CHECK-NO: call void @llvm.lifetime
call void @foo(i8* %text) ; Keep alloca alive call void @foo(i8* %text) ; Keep alloca alive
ret void ret void
} }

test/Transforms/InstCombine/lifetime.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -instcombine -S | FileCheck %s
declare void @llvm.dbg.declare(metadata, metadata, metadata) declare void @llvm.dbg.declare(metadata, metadata, metadata)
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
declare void @foo(i8* nocapture, i8* nocapture) declare void @foo(i8* nocapture, i8* nocapture)
define void @bar(i1 %flag) !dbg !4 { define void @bar(i1 %flag) !dbg !4 {
entry: entry:
; CHECK-LABEL: @bar( ; CHECK-LABEL: @bar(
; CHECK: %[[T:[^ ]+]] = getelementptr inbounds [1 x i8], [1 x i8]* %text ; CHECK: %[[T:[^ ]+]] = getelementptr inbounds [1 x i8], [1 x i8]* %text
; CHECK: %[[B:[^ ]+]] = getelementptr inbounds [1 x i8], [1 x i8]* %buff ; CHECK: %[[B:[^ ]+]] = getelementptr inbounds [1 x i8], [1 x i8]* %buff
; CHECK: if: ; CHECK: if:
; CHECK-NEXT: br label %bb2 ; CHECK-NEXT: br label %bb2
; CHECK: bb2: ; CHECK: bb2:
; CHECK-NEXT: br label %bb3 ; CHECK-NEXT: br label %bb3
; CHECK: bb3: ; CHECK: bb3:
; CHECK-NEXT: call void @llvm.dbg.declare ; CHECK-NEXT: call void @llvm.dbg.declare
; CHECK-NEXT: br label %fin ; CHECK-NEXT: br label %fin
; CHECK: call void @llvm.lifetime.start(i64 1, i8* %[[T]]) ; CHECK: call void @llvm.lifetime.start.p0i8(i64 1, i8* %[[T]])
; CHECK-NEXT: call void @llvm.lifetime.start(i64 1, i8* %[[B]]) ; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 1, i8* %[[B]])
; CHECK-NEXT: call void @foo(i8* %[[B]], i8* %[[T]]) ; CHECK-NEXT: call void @foo(i8* %[[B]], i8* %[[T]])
; CHECK-NEXT: call void @llvm.lifetime.end(i64 1, i8* %[[B]]) ; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 1, i8* %[[B]])
; CHECK-NEXT: call void @llvm.lifetime.end(i64 1, i8* %[[T]]) ; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 1, i8* %[[T]])
%text = alloca [1 x i8], align 1 %text = alloca [1 x i8], align 1
%buff = alloca [1 x i8], align 1 %buff = alloca [1 x i8], align 1
%0 = getelementptr inbounds [1 x i8], [1 x i8]* %text, i64 0, i64 0 %0 = getelementptr inbounds [1 x i8], [1 x i8]* %text, i64 0, i64 0
%1 = getelementptr inbounds [1 x i8], [1 x i8]* %buff, i64 0, i64 0 %1 = getelementptr inbounds [1 x i8], [1 x i8]* %buff, i64 0, i64 0
br i1 %flag, label %if, label %else br i1 %flag, label %if, label %else
if: if:
call void @llvm.lifetime.start(i64 1, i8* %0) call void @llvm.lifetime.start.p0i8(i64 1, i8* %0)
call void @llvm.lifetime.start(i64 1, i8* %1) call void @llvm.lifetime.start.p0i8(i64 1, i8* %1)
call void @llvm.lifetime.end(i64 1, i8* %1) call void @llvm.lifetime.end.p0i8(i64 1, i8* %1)
call void @llvm.lifetime.end(i64 1, i8* %0) call void @llvm.lifetime.end.p0i8(i64 1, i8* %0)
br label %bb2 br label %bb2
bb2: bb2:
call void @llvm.lifetime.start(i64 1, i8* %0) call void @llvm.lifetime.start.p0i8(i64 1, i8* %0)
call void @llvm.lifetime.start(i64 1, i8* %1) call void @llvm.lifetime.start.p0i8(i64 1, i8* %1)
call void @llvm.lifetime.end(i64 1, i8* %0) call void @llvm.lifetime.end.p0i8(i64 1, i8* %0)
call void @llvm.lifetime.end(i64 1, i8* %1) call void @llvm.lifetime.end.p0i8(i64 1, i8* %1)
br label %bb3 br label %bb3
bb3: bb3:
call void @llvm.lifetime.start(i64 1, i8* %0) call void @llvm.lifetime.start.p0i8(i64 1, i8* %0)
call void @llvm.dbg.declare(metadata [1 x i8]* %text, metadata !14, metadata !25), !dbg !26 call void @llvm.dbg.declare(metadata [1 x i8]* %text, metadata !14, metadata !25), !dbg !26
call void @llvm.lifetime.end(i64 1, i8* %0) call void @llvm.lifetime.end.p0i8(i64 1, i8* %0)
br label %fin br label %fin
else: else:
call void @llvm.lifetime.start(i64 1, i8* %0) call void @llvm.lifetime.start.p0i8(i64 1, i8* %0)
call void @llvm.lifetime.start(i64 1, i8* %1) call void @llvm.lifetime.start.p0i8(i64 1, i8* %1)
call void @foo(i8* %1, i8* %0) call void @foo(i8* %1, i8* %0)
call void @llvm.lifetime.end(i64 1, i8* %1) call void @llvm.lifetime.end.p0i8(i64 1, i8* %1)
call void @llvm.lifetime.end(i64 1, i8* %0) call void @llvm.lifetime.end.p0i8(i64 1, i8* %0)
br label %fin br label %fin
fin: fin:
ret void ret void
} }
!llvm.dbg.cu = !{!0} !llvm.dbg.cu = !{!0}
!llvm.module.flags = !{!22, !23} !llvm.module.flags = !{!22, !23}
Show All 28 Lines

test/Transforms/InstCombine/malloc-free-delete.ll

Show All 18 Lines
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: ret i1 false ; CHECK-NEXT: ret i1 false
%m = call i8* @malloc(i32 1) %m = call i8* @malloc(i32 1)
%z = icmp eq i8* %m, null %z = icmp eq i8* %m, null
call void @free(i8* %m) call void @free(i8* %m)
ret i1 %z ret i1 %z
} }
declare void @llvm.lifetime.start(i64, i8*) declare void @llvm.lifetime.start.p0i8(i64, i8*)
declare void @llvm.lifetime.end(i64, i8*) declare void @llvm.lifetime.end.p0i8(i64, i8*)
declare i64 @llvm.objectsize.i64(i8*, i1) declare i64 @llvm.objectsize.i64(i8*, i1)
declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32, i1) nounwind declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32, i1) nounwind
declare void @llvm.memmove.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32, i1) nounwind declare void @llvm.memmove.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32, i1) nounwind
declare void @llvm.memset.p0i8.i32(i8*, i8, i32, i32, i1) nounwind declare void @llvm.memset.p0i8.i32(i8*, i8, i32, i32, i1) nounwind
define void @test3(i8* %src) { define void @test3(i8* %src) {
; CHECK-LABEL: @test3( ; CHECK-LABEL: @test3(
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
%a = call noalias i8* @malloc(i32 10) %a = call noalias i8* @malloc(i32 10)
call void @llvm.lifetime.start(i64 10, i8* %a) call void @llvm.lifetime.start.p0i8(i64 10, i8* %a)
call void @llvm.lifetime.end(i64 10, i8* %a) call void @llvm.lifetime.end.p0i8(i64 10, i8* %a)
%size = call i64 @llvm.objectsize.i64(i8* %a, i1 true) %size = call i64 @llvm.objectsize.i64(i8* %a, i1 true)
store i8 42, i8* %a store i8 42, i8* %a
call void @llvm.memcpy.p0i8.p0i8.i32(i8* %a, i8* %src, i32 32, i32 1, i1 false) call void @llvm.memcpy.p0i8.p0i8.i32(i8* %a, i8* %src, i32 32, i32 1, i1 false)
call void @llvm.memmove.p0i8.p0i8.i32(i8* %a, i8* %src, i32 32, i32 1, i1 false) call void @llvm.memmove.p0i8.p0i8.i32(i8* %a, i8* %src, i32 32, i32 1, i1 false)
call void @llvm.memset.p0i8.i32(i8* %a, i8 5, i32 32, i32 1, i1 false) call void @llvm.memset.p0i8.i32(i8* %a, i8 5, i32 32, i32 1, i1 false)
%alloc2 = call noalias i8* @calloc(i32 5, i32 7) nounwind %alloc2 = call noalias i8* @calloc(i32 5, i32 7) nounwind
%z = icmp ne i8* %alloc2, null %z = icmp ne i8* %alloc2, null
ret void ret void
▲ Show 20 Lines • Show All 152 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 120 Lines • ▼ Show 20 Linesdefine void @test4() {
%a = bitcast %T* %A to i8* %a = bitcast %T* %A to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* bitcast (%T* @G to i8*), i64 124, i32 4, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* bitcast (%T* @G to i8*), i64 124, i32 4, i1 false)
call void @baz(i8* byval %a) call void @baz(i8* byval %a)
; CHECK-LABEL: @test4( ; CHECK-LABEL: @test4(
; CHECK-NEXT: call void @baz(i8* byval getelementptr inbounds (%T, %T* @G, i64 0, i32 0)) ; CHECK-NEXT: call void @baz(i8* byval getelementptr inbounds (%T, %T* @G, i64 0, i32 0))
ret void ret void
} }
declare void @llvm.lifetime.start(i64, i8*) declare void @llvm.lifetime.start.p0i8(i64, i8*)
define void @test5() { define void @test5() {
%A = alloca %T %A = alloca %T
%a = bitcast %T* %A to i8* %a = bitcast %T* %A to i8*
call void @llvm.lifetime.start(i64 -1, i8* %a) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %a)
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* bitcast (%T* @G to i8*), i64 124, i32 4, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* bitcast (%T* @G to i8*), i64 124, i32 4, i1 false)
call void @baz(i8* byval %a) call void @baz(i8* byval %a)
; CHECK-LABEL: @test5( ; CHECK-LABEL: @test5(
; CHECK-NEXT: call void @baz(i8* byval getelementptr inbounds (%T, %T* @G, i64 0, i32 0)) ; CHECK-NEXT: call void @baz(i8* byval getelementptr inbounds (%T, %T* @G, i64 0, i32 0))
ret void ret void
} }
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

test/Transforms/InstCombine/vararg.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -instcombine -S | FileCheck %s
%struct.__va_list = type { i8*, i8*, i8*, i32, i32 } %struct.__va_list = type { i8*, i8*, i8*, i32, i32 }
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
declare void @llvm.va_start(i8*) declare void @llvm.va_start(i8*)
declare void @llvm.va_end(i8*) declare void @llvm.va_end(i8*)
declare void @llvm.va_copy(i8*, i8*) declare void @llvm.va_copy(i8*, i8*)
define i32 @func(i8* nocapture readnone %fmt, ...) { define i32 @func(i8* nocapture readnone %fmt, ...) {
; CHECK-LABEL: @func( ; CHECK-LABEL: @func(
; CHECK: entry: ; CHECK: entry:
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
entry: entry:
%va0 = alloca %struct.__va_list, align 8 %va0 = alloca %struct.__va_list, align 8
%va1 = alloca %struct.__va_list, align 8 %va1 = alloca %struct.__va_list, align 8
%0 = bitcast %struct.__va_list* %va0 to i8* %0 = bitcast %struct.__va_list* %va0 to i8*
%1 = bitcast %struct.__va_list* %va1 to i8* %1 = bitcast %struct.__va_list* %va1 to i8*
call void @llvm.lifetime.start(i64 32, i8* %0) call void @llvm.lifetime.start.p0i8(i64 32, i8* %0)
call void @llvm.va_start(i8* %0) call void @llvm.va_start(i8* %0)
call void @llvm.lifetime.start(i64 32, i8* %1) call void @llvm.lifetime.start.p0i8(i64 32, i8* %1)
call void @llvm.va_copy(i8* %1, i8* %0) call void @llvm.va_copy(i8* %1, i8* %0)
call void @llvm.va_end(i8* %1) call void @llvm.va_end(i8* %1)
call void @llvm.lifetime.end(i64 32, i8* %1) call void @llvm.lifetime.end.p0i8(i64 32, i8* %1)
call void @llvm.va_end(i8* %0) call void @llvm.va_end(i8* %0)
call void @llvm.lifetime.end(i64 32, i8* %0) call void @llvm.lifetime.end.p0i8(i64 32, i8* %0)
ret i32 0 ret i32 0
} }

test/Transforms/LoopVectorize/lifetime.ll

; RUN: opt -S -loop-vectorize -force-vector-width=2 -force-vector-interleave=1 < %s | FileCheck %s ; RUN: opt -S -loop-vectorize -force-vector-width=2 -force-vector-interleave=1 < %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"
; Make sure we can vectorize loops which contain lifetime markers. ; Make sure we can vectorize loops which contain lifetime markers.
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK: call void @llvm.lifetime.end ; CHECK: call void @llvm.lifetime.end
; CHECK: store <2 x i32> ; CHECK: store <2 x i32>
; CHECK: call void @llvm.lifetime.start ; CHECK: call void @llvm.lifetime.start
define void @test(i32 *%d) { define void @test(i32 *%d) {
entry: entry:
%arr = alloca [1024 x i32], align 16 %arr = alloca [1024 x i32], align 16
%0 = bitcast [1024 x i32]* %arr to i8* %0 = bitcast [1024 x i32]* %arr to i8*
call void @llvm.lifetime.start(i64 4096, i8* %0) #1 call void @llvm.lifetime.start.p0i8(i64 4096, i8* %0) #1
br label %for.body br label %for.body
for.body: for.body:
%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ] %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
call void @llvm.lifetime.end(i64 4096, i8* %0) #1 call void @llvm.lifetime.end.p0i8(i64 4096, i8* %0) #1
%arrayidx = getelementptr inbounds i32, i32* %d, i64 %indvars.iv %arrayidx = getelementptr inbounds i32, i32* %d, i64 %indvars.iv
%1 = load i32, i32* %arrayidx, align 8 %1 = load i32, i32* %arrayidx, align 8
store i32 100, i32* %arrayidx, align 8 store i32 100, i32* %arrayidx, align 8
call void @llvm.lifetime.start(i64 4096, i8* %0) #1 call void @llvm.lifetime.start.p0i8(i64 4096, i8* %0) #1
%indvars.iv.next = add i64 %indvars.iv, 1 %indvars.iv.next = add i64 %indvars.iv, 1
%lftr.wideiv = trunc i64 %indvars.iv.next to i32 %lftr.wideiv = trunc i64 %indvars.iv.next to i32
%exitcond = icmp ne i32 %lftr.wideiv, 128 %exitcond = icmp ne i32 %lftr.wideiv, 128
br i1 %exitcond, label %for.body, label %for.end br i1 %exitcond, label %for.body, label %for.end
for.end: for.end:
call void @llvm.lifetime.end(i64 4096, i8* %0) #1 call void @llvm.lifetime.end.p0i8(i64 4096, i8* %0) #1
ret void ret void
} }
; CHECK-LABEL: @testbitcast( ; CHECK-LABEL: @testbitcast(
; CHECK: call void @llvm.lifetime.end ; CHECK: call void @llvm.lifetime.end
; CHECK: store <2 x i32> ; CHECK: store <2 x i32>
; CHECK: call void @llvm.lifetime.start ; CHECK: call void @llvm.lifetime.start
define void @testbitcast(i32 *%d) { define void @testbitcast(i32 *%d) {
entry: entry:
%arr = alloca [1024 x i32], align 16 %arr = alloca [1024 x i32], align 16
%0 = bitcast [1024 x i32]* %arr to i8* %0 = bitcast [1024 x i32]* %arr to i8*
call void @llvm.lifetime.start(i64 4096, i8* %0) #1 call void @llvm.lifetime.start.p0i8(i64 4096, i8* %0) #1
br label %for.body br label %for.body
for.body: for.body:
%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ] %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
%1 = bitcast [1024 x i32]* %arr to i8* %1 = bitcast [1024 x i32]* %arr to i8*
call void @llvm.lifetime.end(i64 4096, i8* %1) #1 call void @llvm.lifetime.end.p0i8(i64 4096, i8* %1) #1
%arrayidx = getelementptr inbounds i32, i32* %d, i64 %indvars.iv %arrayidx = getelementptr inbounds i32, i32* %d, i64 %indvars.iv
%2 = load i32, i32* %arrayidx, align 8 %2 = load i32, i32* %arrayidx, align 8
store i32 100, i32* %arrayidx, align 8 store i32 100, i32* %arrayidx, align 8
call void @llvm.lifetime.start(i64 4096, i8* %1) #1 call void @llvm.lifetime.start.p0i8(i64 4096, i8* %1) #1
%indvars.iv.next = add i64 %indvars.iv, 1 %indvars.iv.next = add i64 %indvars.iv, 1
%lftr.wideiv = trunc i64 %indvars.iv.next to i32 %lftr.wideiv = trunc i64 %indvars.iv.next to i32
%exitcond = icmp ne i32 %lftr.wideiv, 128 %exitcond = icmp ne i32 %lftr.wideiv, 128
br i1 %exitcond, label %for.body, label %for.end br i1 %exitcond, label %for.body, label %for.end
for.end: for.end:
call void @llvm.lifetime.end(i64 4096, i8* %0) #1 call void @llvm.lifetime.end.p0i8(i64 4096, i8* %0) #1
ret void ret void
} }
; CHECK-LABEL: @testloopvariant( ; CHECK-LABEL: @testloopvariant(
; CHECK: call void @llvm.lifetime.end ; CHECK: call void @llvm.lifetime.end
; CHECK: store <2 x i32> ; CHECK: store <2 x i32>
; CHECK: call void @llvm.lifetime.start ; CHECK: call void @llvm.lifetime.start
define void @testloopvariant(i32 *%d) { define void @testloopvariant(i32 *%d) {
entry: entry:
%arr = alloca [1024 x i32], align 16 %arr = alloca [1024 x i32], align 16
br label %for.body br label %for.body
for.body: for.body:
%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ] %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
%0 = getelementptr [1024 x i32], [1024 x i32]* %arr, i32 0, i64 %indvars.iv %0 = getelementptr [1024 x i32], [1024 x i32]* %arr, i32 0, i64 %indvars.iv
%1 = bitcast [1024 x i32]* %arr to i8* %1 = bitcast [1024 x i32]* %arr to i8*
call void @llvm.lifetime.end(i64 4096, i8* %1) #1 call void @llvm.lifetime.end.p0i8(i64 4096, i8* %1) #1
%arrayidx = getelementptr inbounds i32, i32* %d, i64 %indvars.iv %arrayidx = getelementptr inbounds i32, i32* %d, i64 %indvars.iv
%2 = load i32, i32* %arrayidx, align 8 %2 = load i32, i32* %arrayidx, align 8
store i32 100, i32* %arrayidx, align 8 store i32 100, i32* %arrayidx, align 8
call void @llvm.lifetime.start(i64 4096, i8* %1) #1 call void @llvm.lifetime.start.p0i8(i64 4096, i8* %1) #1
%indvars.iv.next = add i64 %indvars.iv, 1 %indvars.iv.next = add i64 %indvars.iv, 1
%lftr.wideiv = trunc i64 %indvars.iv.next to i32 %lftr.wideiv = trunc i64 %indvars.iv.next to i32
%exitcond = icmp ne i32 %lftr.wideiv, 128 %exitcond = icmp ne i32 %lftr.wideiv, 128
br i1 %exitcond, label %for.body, label %for.end br i1 %exitcond, label %for.body, label %for.end
for.end: for.end:
ret void ret void
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1

test/Transforms/Mem2Reg/ignore-lifetime.ll

; RUN: opt -mem2reg -S -o - < %s | FileCheck %s ; RUN: opt -mem2reg -S -o - < %s | FileCheck %s
declare void @llvm.lifetime.start(i64 %size, i8* nocapture %ptr) declare void @llvm.lifetime.start.p0i8(i64 %size, i8* nocapture %ptr)
declare void @llvm.lifetime.end(i64 %size, i8* nocapture %ptr) declare void @llvm.lifetime.end.p0i8(i64 %size, i8* nocapture %ptr)
define void @test1() { define void @test1() {
; CHECK: test1 ; CHECK: test1
; CHECK-NOT: alloca ; CHECK-NOT: alloca
%A = alloca i32 %A = alloca i32
%B = bitcast i32* %A to i8* %B = bitcast i32* %A to i8*
call void @llvm.lifetime.start(i64 2, i8* %B) call void @llvm.lifetime.start.p0i8(i64 2, i8* %B)
store i32 1, i32* %A store i32 1, i32* %A
call void @llvm.lifetime.end(i64 2, i8* %B) call void @llvm.lifetime.end.p0i8(i64 2, i8* %B)
ret void ret void
} }
define void @test2() { define void @test2() {
; CHECK: test2 ; CHECK: test2
; CHECK-NOT: alloca ; CHECK-NOT: alloca
%A = alloca {i8, i16} %A = alloca {i8, i16}
%B = getelementptr {i8, i16}, {i8, i16}* %A, i32 0, i32 0 %B = getelementptr {i8, i16}, {i8, i16}* %A, i32 0, i32 0
call void @llvm.lifetime.start(i64 2, i8* %B) call void @llvm.lifetime.start.p0i8(i64 2, i8* %B)
store {i8, i16} zeroinitializer, {i8, i16}* %A store {i8, i16} zeroinitializer, {i8, i16}* %A
call void @llvm.lifetime.end(i64 2, i8* %B) call void @llvm.lifetime.end.p0i8(i64 2, i8* %B)
ret void ret void
} }

test/Transforms/MemCpyOpt/lifetime.ll

; RUN: opt < %s -O1 -S | FileCheck %s ; RUN: opt < %s -O1 -S | FileCheck %s
; performCallSlotOptzn in MemCpy should not exchange the calls to ; performCallSlotOptzn in MemCpy should not exchange the calls to
; @llvm.lifetime.start and @llvm.memcpy. ; @llvm.lifetime.start and @llvm.memcpy.
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i32, i1) #1 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i32, i1) #1
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
define void @_ZN4CordC2EOS_(i8* nocapture dereferenceable(16) %arg1) { define void @_ZN4CordC2EOS_(i8* nocapture dereferenceable(16) %arg1) {
bb: bb:
; CHECK-LABEL: @_ZN4CordC2EOS_ ; CHECK-LABEL: @_ZN4CordC2EOS_
; CHECK-NOT: call void @llvm.lifetime.start ; CHECK-NOT: call void @llvm.lifetime.start
; CHECK: ret void ; CHECK: ret void
%tmp = alloca [8 x i8], align 8 %tmp = alloca [8 x i8], align 8
%tmp5 = bitcast [8 x i8]* %tmp to i8* %tmp5 = bitcast [8 x i8]* %tmp to i8*
call void @llvm.lifetime.start(i64 16, i8* %tmp5) call void @llvm.lifetime.start.p0i8(i64 16, i8* %tmp5)
%tmp10 = getelementptr inbounds i8, i8* %tmp5, i64 7 %tmp10 = getelementptr inbounds i8, i8* %tmp5, i64 7
store i8 0, i8* %tmp10, align 1 store i8 0, i8* %tmp10, align 1
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %arg1, i8* %tmp5, i64 16, i32 8, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %arg1, i8* %tmp5, i64 16, i32 8, i1 false)
call void @llvm.lifetime.end(i64 16, i8* %tmp5) call void @llvm.lifetime.end.p0i8(i64 16, i8* %tmp5)
ret void ret void
} }
attributes #1 = { argmemonly nounwind } attributes #1 = { argmemonly nounwind }

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

; RUN: opt -basicaa -memcpyopt -instcombine -S < %s | FileCheck %s ; RUN: opt -basicaa -memcpyopt -instcombine -S < %s | FileCheck %s
target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @foo([8 x i64]* noalias nocapture sret dereferenceable(64) %sret) { define void @foo([8 x i64]* noalias nocapture sret dereferenceable(64) %sret) {
entry-block: entry-block:
%a = alloca [8 x i64], align 8 %a = alloca [8 x i64], align 8
%a.cast = bitcast [8 x i64]* %a to i8* %a.cast = bitcast [8 x i64]* %a to i8*
call void @llvm.lifetime.start(i64 64, i8* %a.cast) call void @llvm.lifetime.start.p0i8(i64 64, i8* %a.cast)
call void @llvm.memset.p0i8.i64(i8* %a.cast, i8 0, i64 64, i32 8, i1 false) call void @llvm.memset.p0i8.i64(i8* %a.cast, i8 0, i64 64, i32 8, i1 false)
%sret.cast = bitcast [8 x i64]* %sret to i8* %sret.cast = bitcast [8 x i64]* %sret to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %sret.cast, i8* %a.cast, i64 64, i32 8, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %sret.cast, i8* %a.cast, i64 64, i32 8, i1 false)
call void @llvm.lifetime.end(i64 64, i8* %a.cast) call void @llvm.lifetime.end.p0i8(i64 64, i8* %a.cast)
ret void ret void
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK: %[[sret_cast:[^=]+]] = bitcast [8 x i64]* %sret to i8* ; CHECK: %[[sret_cast:[^=]+]] = bitcast [8 x i64]* %sret to i8*
; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* %[[sret_cast]], i8 0, i64 64 ; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* %[[sret_cast]], i8 0, i64 64
; CHECK-NOT: call void @llvm.memcpy ; CHECK-NOT: call void @llvm.memcpy
; CHECK: ret void ; CHECK: ret void
} }
define void @bar([8 x i64]* noalias nocapture sret dereferenceable(64) %sret, [8 x i64]* noalias nocapture dereferenceable(64) %out) { define void @bar([8 x i64]* noalias nocapture sret dereferenceable(64) %sret, [8 x i64]* noalias nocapture dereferenceable(64) %out) {
entry-block: entry-block:
%a = alloca [8 x i64], align 8 %a = alloca [8 x i64], align 8
%a.cast = bitcast [8 x i64]* %a to i8* %a.cast = bitcast [8 x i64]* %a to i8*
call void @llvm.lifetime.start(i64 64, i8* %a.cast) call void @llvm.lifetime.start.p0i8(i64 64, i8* %a.cast)
call void @llvm.memset.p0i8.i64(i8* %a.cast, i8 0, i64 64, i32 8, i1 false) call void @llvm.memset.p0i8.i64(i8* %a.cast, i8 0, i64 64, i32 8, i1 false)
%sret.cast = bitcast [8 x i64]* %sret to i8* %sret.cast = bitcast [8 x i64]* %sret to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %sret.cast, i8* %a.cast, i64 64, i32 8, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %sret.cast, i8* %a.cast, i64 64, i32 8, i1 false)
call void @llvm.memset.p0i8.i64(i8* %a.cast, i8 42, i64 32, i32 8, i1 false) call void @llvm.memset.p0i8.i64(i8* %a.cast, i8 42, i64 32, i32 8, i1 false)
%out.cast = bitcast [8 x i64]* %out to i8* %out.cast = bitcast [8 x i64]* %out to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %out.cast, i8* %a.cast, i64 64, i32 8, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %out.cast, i8* %a.cast, i64 64, i32 8, i1 false)
call void @llvm.lifetime.end(i64 64, i8* %a.cast) call void @llvm.lifetime.end.p0i8(i64 64, i8* %a.cast)
ret void ret void
; CHECK-LABEL: @bar( ; CHECK-LABEL: @bar(
; CHECK: %[[a:[^=]+]] = alloca [8 x i64] ; CHECK: %[[a:[^=]+]] = alloca [8 x i64]
; CHECK: %[[a_cast:[^=]+]] = bitcast [8 x i64]* %[[a]] to i8* ; CHECK: %[[a_cast:[^=]+]] = bitcast [8 x i64]* %[[a]] to i8*
; CHECK: call void @llvm.memset.p0i8.i64(i8* %[[a_cast]], i8 0, i64 64 ; CHECK: call void @llvm.memset.p0i8.i64(i8* %[[a_cast]], i8 0, i64 64
; CHECK: %[[sret_cast:[^=]+]] = bitcast [8 x i64]* %sret to i8* ; CHECK: %[[sret_cast:[^=]+]] = bitcast [8 x i64]* %sret to i8*
; CHECK: call void @llvm.memset.p0i8.i64(i8* %[[sret_cast]], i8 0, i64 64 ; CHECK: call void @llvm.memset.p0i8.i64(i8* %[[sret_cast]], i8 0, i64 64
; CHECK: call void @llvm.memset.p0i8.i64(i8* %[[a_cast]], i8 42, i64 32 ; CHECK: call void @llvm.memset.p0i8.i64(i8* %[[a_cast]], i8 42, i64 32
; CHECK: %[[out_cast:[^=]+]] = bitcast [8 x i64]* %out to i8* ; CHECK: %[[out_cast:[^=]+]] = bitcast [8 x i64]* %out to i8*
; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* %[[out_cast]], i8* %[[a_cast]], i64 64 ; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* %[[out_cast]], i8* %[[a_cast]], i64 64
; CHECK-NOT: call void @llvm.memcpy ; CHECK-NOT: call void @llvm.memcpy
; CHECK: ret void ; CHECK: ret void
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) nounwind declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) nounwind declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) nounwind
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i32, i1) nounwind declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i32, i1) nounwind
declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i32, i1) nounwind declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i32, i1) nounwind

test/Transforms/MemCpyOpt/memcpy-undef.ll

Show All 16 Linesdefine i32 @test1(%struct.foo* nocapture %foobie) nounwind noinline ssp uwtable {
ret i32 undef ret i32 undef
; Check that the memcpy is removed. ; Check that the memcpy is removed.
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NOT: call void @llvm.memcpy ; CHECK-NOT: call void @llvm.memcpy
} }
define void @test2(i8* sret noalias nocapture %out, i8* %in) nounwind noinline ssp uwtable { define void @test2(i8* sret noalias nocapture %out, i8* %in) nounwind noinline ssp uwtable {
call void @llvm.lifetime.start(i64 8, i8* %in) call void @llvm.lifetime.start.p0i8(i64 8, i8* %in)
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %out, i8* %in, i64 8, i32 1, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %out, i8* %in, i64 8, i32 1, i1 false)
ret void ret void
; Check that the memcpy is removed. ; Check that the memcpy is removed.
; CHECK-LABEL: @test2( ; CHECK-LABEL: @test2(
; CHECK-NOT: call void @llvm.memcpy ; CHECK-NOT: call void @llvm.memcpy
} }
define void @test3(i8* sret noalias nocapture %out, i8* %in) nounwind noinline ssp uwtable { define void @test3(i8* sret noalias nocapture %out, i8* %in) nounwind noinline ssp uwtable {
call void @llvm.lifetime.start(i64 4, i8* %in) call void @llvm.lifetime.start.p0i8(i64 4, i8* %in)
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %out, i8* %in, i64 8, i32 1, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %out, i8* %in, i64 8, i32 1, i1 false)
ret void ret void
; Check that the memcpy is not removed. ; Check that the memcpy is not removed.
; CHECK-LABEL: @test3( ; CHECK-LABEL: @test3(
; CHECK: call void @llvm.memcpy ; CHECK: call void @llvm.memcpy
} }
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i32, i1) nounwind declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i32, i1) nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) nounwind declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind

test/Transforms/MemCpyOpt/pr29105.ll

; RUN: opt -memcpyopt -instcombine -S %s | FileCheck %s ; RUN: opt -memcpyopt -instcombine -S %s | FileCheck %s
%Foo = type { [2048 x i64] } %Foo = type { [2048 x i64] }
; Make sure that all mempcy calls are converted to memset calls, or removed. ; Make sure that all mempcy calls are converted to memset calls, or removed.
; CHECK-LABEL: @baz( ; CHECK-LABEL: @baz(
; CHECK-NOT: call void @llvm.memcpy ; CHECK-NOT: call void @llvm.memcpy
define void @baz() unnamed_addr #0 { define void @baz() unnamed_addr #0 {
entry-block: entry-block:
%x.sroa.0 = alloca [2048 x i64], align 8 %x.sroa.0 = alloca [2048 x i64], align 8
%tmp0 = alloca [2048 x i64], align 8 %tmp0 = alloca [2048 x i64], align 8
%0 = bitcast [2048 x i64]* %tmp0 to i8* %0 = bitcast [2048 x i64]* %tmp0 to i8*
%tmp2 = alloca %Foo, align 8 %tmp2 = alloca %Foo, align 8
%x.sroa.0.0..sroa_cast6 = bitcast [2048 x i64]* %x.sroa.0 to i8* %x.sroa.0.0..sroa_cast6 = bitcast [2048 x i64]* %x.sroa.0 to i8*
call void @llvm.lifetime.start(i64 16384, i8* %x.sroa.0.0..sroa_cast6) call void @llvm.lifetime.start.p0i8(i64 16384, i8* %x.sroa.0.0..sroa_cast6)
call void @llvm.lifetime.start(i64 16384, i8* %0) call void @llvm.lifetime.start.p0i8(i64 16384, i8* %0)
call void @llvm.memset.p0i8.i64(i8* %0, i8 0, i64 16384, i32 8, i1 false) call void @llvm.memset.p0i8.i64(i8* %0, i8 0, i64 16384, i32 8, i1 false)
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %x.sroa.0.0..sroa_cast6, i8* %0, i64 16384, i32 8, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %x.sroa.0.0..sroa_cast6, i8* %0, i64 16384, i32 8, i1 false)
call void @llvm.lifetime.end(i64 16384, i8* %0) call void @llvm.lifetime.end.p0i8(i64 16384, i8* %0)
%1 = bitcast %Foo* %tmp2 to i8* %1 = bitcast %Foo* %tmp2 to i8*
call void @llvm.lifetime.start(i64 16384, i8* %1) call void @llvm.lifetime.start.p0i8(i64 16384, i8* %1)
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %1, i8* %x.sroa.0.0..sroa_cast6, i64 16384, i32 8, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %1, i8* %x.sroa.0.0..sroa_cast6, i64 16384, i32 8, i1 false)
call void @bar(%Foo* noalias nocapture nonnull dereferenceable(16384) %tmp2) call void @bar(%Foo* noalias nocapture nonnull dereferenceable(16384) %tmp2)
call void @llvm.lifetime.end(i64 16384, i8* %1) call void @llvm.lifetime.end.p0i8(i64 16384, i8* %1)
call void @llvm.lifetime.end(i64 16384, i8* %x.sroa.0.0..sroa_cast6) call void @llvm.lifetime.end.p0i8(i64 16384, i8* %x.sroa.0.0..sroa_cast6)
ret void ret void
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32, i1) #1 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32, i1) #1
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
declare void @bar(%Foo* noalias nocapture readonly dereferenceable(16384)) unnamed_addr #0 declare void @bar(%Foo* noalias nocapture readonly dereferenceable(16384)) unnamed_addr #0
declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i32, i1) #1 declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i32, i1) #1
attributes #0 = { uwtable } attributes #0 = { uwtable }
attributes #1 = { argmemonly nounwind } attributes #1 = { argmemonly nounwind }

test/Transforms/NewGVN/cond_br2.ll

Show All 13 Lines
; CHECK: @_Z4testv() ; CHECK: @_Z4testv()
; CHECK: invoke.cont: ; CHECK: invoke.cont:
; CHECK: br i1 true, label %new.notnull.i11, label %if.end.i14 ; CHECK: br i1 true, label %new.notnull.i11, label %if.end.i14
; CHECK: Retry.i10: ; CHECK: Retry.i10:
entry: entry:
%sv = alloca %"class.llvm::SmallVector", align 16 %sv = alloca %"class.llvm::SmallVector", align 16
%0 = bitcast %"class.llvm::SmallVector"* %sv to i8* %0 = bitcast %"class.llvm::SmallVector"* %sv to i8*
call void @llvm.lifetime.start(i64 64, i8* %0) #1 call void @llvm.lifetime.start.p0i8(i64 64, i8* %0) #1
%BeginX.i.i.i.i.i.i = getelementptr inbounds %"class.llvm::SmallVector", %"class.llvm::SmallVector"* %sv, i64 0, i32 0, i32 0, i32 0, i32 0, i32 0 %BeginX.i.i.i.i.i.i = getelementptr inbounds %"class.llvm::SmallVector", %"class.llvm::SmallVector"* %sv, i64 0, i32 0, i32 0, i32 0, i32 0, i32 0
%FirstEl.i.i.i.i.i.i = getelementptr inbounds %"class.llvm::SmallVector", %"class.llvm::SmallVector"* %sv, i64 0, i32 0, i32 0, i32 0, i32 0, i32 3 %FirstEl.i.i.i.i.i.i = getelementptr inbounds %"class.llvm::SmallVector", %"class.llvm::SmallVector"* %sv, i64 0, i32 0, i32 0, i32 0, i32 0, i32 3
%1 = bitcast %"union.llvm::SmallVectorBase::U"* %FirstEl.i.i.i.i.i.i to i8* %1 = bitcast %"union.llvm::SmallVectorBase::U"* %FirstEl.i.i.i.i.i.i to i8*
store i8* %1, i8** %BeginX.i.i.i.i.i.i, align 16, !tbaa !4 store i8* %1, i8** %BeginX.i.i.i.i.i.i, align 16, !tbaa !4
%EndX.i.i.i.i.i.i = getelementptr inbounds %"class.llvm::SmallVector", %"class.llvm::SmallVector"* %sv, i64 0, i32 0, i32 0, i32 0, i32 0, i32 1 %EndX.i.i.i.i.i.i = getelementptr inbounds %"class.llvm::SmallVector", %"class.llvm::SmallVector"* %sv, i64 0, i32 0, i32 0, i32 0, i32 0, i32 1
store i8* %1, i8** %EndX.i.i.i.i.i.i, align 8, !tbaa !4 store i8* %1, i8** %EndX.i.i.i.i.i.i, align 8, !tbaa !4
%CapacityX.i.i.i.i.i.i = getelementptr inbounds %"class.llvm::SmallVector", %"class.llvm::SmallVector"* %sv, i64 0, i32 0, i32 0, i32 0, i32 0, i32 2 %CapacityX.i.i.i.i.i.i = getelementptr inbounds %"class.llvm::SmallVector", %"class.llvm::SmallVector"* %sv, i64 0, i32 0, i32 0, i32 0, i32 0, i32 2
%add.ptr.i.i.i.i2.i.i = getelementptr inbounds %"union.llvm::SmallVectorBase::U", %"union.llvm::SmallVectorBase::U"* %FirstEl.i.i.i.i.i.i, i64 2 %add.ptr.i.i.i.i2.i.i = getelementptr inbounds %"union.llvm::SmallVectorBase::U", %"union.llvm::SmallVectorBase::U"* %FirstEl.i.i.i.i.i.i, i64 2
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Linesinvoke.cont3: ; preds = %invoke.cont2
%cmp.i.i.i.i19 = icmp eq i8* %11, %1 %cmp.i.i.i.i19 = icmp eq i8* %11, %1
br i1 %cmp.i.i.i.i19, label %_ZN4llvm11SmallVectorIiLj8EED1Ev.exit21, label %if.then.i.i.i20 br i1 %cmp.i.i.i.i19, label %_ZN4llvm11SmallVectorIiLj8EED1Ev.exit21, label %if.then.i.i.i20
if.then.i.i.i20: ; preds = %invoke.cont3 if.then.i.i.i20: ; preds = %invoke.cont3
call void @free(i8* %11) #1 call void @free(i8* %11) #1
br label %_ZN4llvm11SmallVectorIiLj8EED1Ev.exit21 br label %_ZN4llvm11SmallVectorIiLj8EED1Ev.exit21
_ZN4llvm11SmallVectorIiLj8EED1Ev.exit21: ; preds = %invoke.cont3, %if.then.i.i.i20 _ZN4llvm11SmallVectorIiLj8EED1Ev.exit21: ; preds = %invoke.cont3, %if.then.i.i.i20
call void @llvm.lifetime.end(i64 64, i8* %0) #1 call void @llvm.lifetime.end.p0i8(i64 64, i8* %0) #1
ret void ret void
lpad: ; preds = %if.end.i14, %if.end.i, %invoke.cont2 lpad: ; preds = %if.end.i14, %if.end.i, %invoke.cont2
%12 = landingpad { i8*, i32 } %12 = landingpad { i8*, i32 }
cleanup cleanup
%13 = load i8*, i8** %BeginX.i.i.i.i.i.i, align 16, !tbaa !4 %13 = load i8*, i8** %BeginX.i.i.i.i.i.i, align 16, !tbaa !4
%cmp.i.i.i.i = icmp eq i8* %13, %1 %cmp.i.i.i.i = icmp eq i8* %13, %1
br i1 %cmp.i.i.i.i, label %eh.resume, label %if.then.i.i.i br i1 %cmp.i.i.i.i, label %eh.resume, label %if.then.i.i.i
if.then.i.i.i: ; preds = %lpad if.then.i.i.i: ; preds = %lpad
call void @free(i8* %13) #1 call void @free(i8* %13) #1
br label %eh.resume br label %eh.resume
eh.resume: ; preds = %if.then.i.i.i, %lpad eh.resume: ; preds = %if.then.i.i.i, %lpad
resume { i8*, i32 } %12 resume { i8*, i32 } %12
} }
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
declare i32 @__gxx_personality_v0(...) declare i32 @__gxx_personality_v0(...)
declare void @_Z1gRN4llvm11SmallVectorIiLj8EEE(%"class.llvm::SmallVector"*) #2 declare void @_Z1gRN4llvm11SmallVectorIiLj8EEE(%"class.llvm::SmallVector"*) #2
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
declare void @_ZN4llvm15SmallVectorBase8grow_podEmm(%"class.llvm::SmallVectorBase"*, i64, i64) #2 declare void @_ZN4llvm15SmallVectorBase8grow_podEmm(%"class.llvm::SmallVectorBase"*, i64, i64) #2
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @free(i8* nocapture) #3 declare void @free(i8* nocapture) #3
attributes #0 = { ssp uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #0 = { ssp uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { nounwind } attributes #1 = { nounwind }
Show All 9 Lines

test/Transforms/NewGVN/lifetime-simple.ll

; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin7" target triple = "i386-apple-darwin7"
define i8 @test(i8* %P) nounwind { define i8 @test(i8* %P) nounwind {
; CHECK: lifetime.start ; CHECK: lifetime.start
; CHECK-NOT: load ; CHECK-NOT: load
; CHECK: lifetime.end ; CHECK: lifetime.end
entry: entry:
call void @llvm.lifetime.start(i64 32, i8* %P) call void @llvm.lifetime.start.p0i8(i64 32, i8* %P)
%0 = load i8, i8* %P %0 = load i8, i8* %P
store i8 1, i8* %P store i8 1, i8* %P
call void @llvm.lifetime.end(i64 32, i8* %P) call void @llvm.lifetime.end.p0i8(i64 32, i8* %P)
%1 = load i8, i8* %P %1 = load i8, i8* %P
ret i8 %1 ret i8 %1
} }
declare void @llvm.lifetime.start(i64 %S, i8* nocapture %P) readonly declare void @llvm.lifetime.start.p0i8(i64 %S, i8* nocapture %P) readonly
declare void @llvm.lifetime.end(i64 %S, i8* nocapture %P) declare void @llvm.lifetime.end.p0i8(i64 %S, i8* nocapture %P)

test/Transforms/SROA/basictest.ll

; RUN: opt < %s -sroa -S | FileCheck %s ; RUN: opt < %s -sroa -S | FileCheck %s
; RUN: opt < %s -passes=sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
target datalayout = "e-p:64:64:64-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64" target datalayout = "e-p:64:64:64-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
define i32 @test0() { define i32 @test0() {
; CHECK-LABEL: @test0( ; CHECK-LABEL: @test0(
; CHECK-NOT: alloca ; CHECK-NOT: alloca
; CHECK: ret i32 ; CHECK: ret i32
entry: entry:
%a1 = alloca i32 %a1 = alloca i32
%a2 = alloca float %a2 = alloca float
%a1.i8 = bitcast i32* %a1 to i8* %a1.i8 = bitcast i32* %a1 to i8*
call void @llvm.lifetime.start(i64 4, i8* %a1.i8) call void @llvm.lifetime.start.p0i8(i64 4, i8* %a1.i8)
store i32 0, i32* %a1 store i32 0, i32* %a1
%v1 = load i32, i32* %a1 %v1 = load i32, i32* %a1
call void @llvm.lifetime.end(i64 4, i8* %a1.i8) call void @llvm.lifetime.end.p0i8(i64 4, i8* %a1.i8)
%a2.i8 = bitcast float* %a2 to i8* %a2.i8 = bitcast float* %a2 to i8*
call void @llvm.lifetime.start(i64 4, i8* %a2.i8) call void @llvm.lifetime.start.p0i8(i64 4, i8* %a2.i8)
store float 0.0, float* %a2 store float 0.0, float* %a2
%v2 = load float , float * %a2 %v2 = load float , float * %a2
%v2.int = bitcast float %v2 to i32 %v2.int = bitcast float %v2 to i32
%sum1 = add i32 %v1, %v2.int %sum1 = add i32 %v1, %v2.int
call void @llvm.lifetime.end(i64 4, i8* %a2.i8) call void @llvm.lifetime.end.p0i8(i64 4, i8* %a2.i8)
ret i32 %sum1 ret i32 %sum1
} }
define i32 @test1() { define i32 @test1() {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NOT: alloca ; CHECK-NOT: alloca
; CHECK: ret i32 0 ; CHECK: ret i32 0
▲ Show 20 Lines • Show All 1,009 Lines • ▼ Show 20 Lines
; via integers can be promoted away. ; via integers can be promoted away.
; CHECK: @PR14059.1 ; CHECK: @PR14059.1
; CHECK-NOT: alloca ; CHECK-NOT: alloca
; CHECK: ret void ; CHECK: ret void
entry: entry:
%X.sroa.0.i = alloca double, align 8 %X.sroa.0.i = alloca double, align 8
%0 = bitcast double* %X.sroa.0.i to i8* %0 = bitcast double* %X.sroa.0.i to i8*
call void @llvm.lifetime.start(i64 -1, i8* %0) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %0)
; Store to the low 32-bits... ; Store to the low 32-bits...
%X.sroa.0.0.cast2.i = bitcast double* %X.sroa.0.i to i32* %X.sroa.0.0.cast2.i = bitcast double* %X.sroa.0.i to i32*
store i32 0, i32* %X.sroa.0.0.cast2.i, align 8 store i32 0, i32* %X.sroa.0.0.cast2.i, align 8
; Also use a memset to the middle 32-bits for fun. ; Also use a memset to the middle 32-bits for fun.
%X.sroa.0.2.raw_idx2.i = getelementptr inbounds i8, i8* %0, i32 2 %X.sroa.0.2.raw_idx2.i = getelementptr inbounds i8, i8* %0, i32 2
call void @llvm.memset.p0i8.i64(i8* %X.sroa.0.2.raw_idx2.i, i8 0, i64 4, i32 1, i1 false) call void @llvm.memset.p0i8.i64(i8* %X.sroa.0.2.raw_idx2.i, i8 0, i64 4, i32 1, i1 false)
Show All 10 Linesentry:
%X.sroa.0.4.cast5.i = bitcast i8* %X.sroa.0.4.raw_idx4.i to i32* %X.sroa.0.4.cast5.i = bitcast i8* %X.sroa.0.4.raw_idx4.i to i32*
store i32 1072693248, i32* %X.sroa.0.4.cast5.i, align 4 store i32 1072693248, i32* %X.sroa.0.4.cast5.i, align 4
; Do the actual math... ; Do the actual math...
%X.sroa.0.0.load1.i = load double, double* %X.sroa.0.i, align 8 %X.sroa.0.0.load1.i = load double, double* %X.sroa.0.i, align 8
%accum.real.i = load double, double* %d, align 8 %accum.real.i = load double, double* %d, align 8
%add.r.i = fadd double %accum.real.i, %X.sroa.0.0.load1.i %add.r.i = fadd double %accum.real.i, %X.sroa.0.0.load1.i
store double %add.r.i, double* %d, align 8 store double %add.r.i, double* %d, align 8
call void @llvm.lifetime.end(i64 -1, i8* %0) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %0)
ret void ret void
} }
define i64 @PR14059.2({ float, float }* %phi) { define i64 @PR14059.2({ float, float }* %phi) {
; Check that SROA can split up alloca-wide integer loads and stores where the ; Check that SROA can split up alloca-wide integer loads and stores where the
; underlying alloca has smaller components that are accessed independently. This ; underlying alloca has smaller components that are accessed independently. This
; shows up particularly with ABI lowering patterns coming out of Clang that rely ; shows up particularly with ABI lowering patterns coming out of Clang that rely
; on the particular register placement of a single large integer return value. ; on the particular register placement of a single large integer return value.
▲ Show 20 Lines • Show All 551 Lines • ▼ Show 20 Lines
; CHECK: %[[HIINSERT:.*]] = or i64 %[[HIMASK]], %[[HISHL]] ; CHECK: %[[HIINSERT:.*]] = or i64 %[[HIMASK]], %[[HISHL]]
; CHECK: %[[LOZEXT:.*]] = zext i32 1123418112 to i64 ; CHECK: %[[LOZEXT:.*]] = zext i32 1123418112 to i64
; CHECK: %[[LOMASK:.*]] = and i64 %[[HIINSERT]], -4294967296 ; CHECK: %[[LOMASK:.*]] = and i64 %[[HIINSERT]], -4294967296
; CHECK: %[[LOINSERT:.*]] = or i64 %[[LOMASK]], %[[LOZEXT]] ; CHECK: %[[LOINSERT:.*]] = or i64 %[[LOMASK]], %[[LOZEXT]]
; CHECK: store i64 %[[LOINSERT]] ; CHECK: store i64 %[[LOINSERT]]
entry: entry:
%tmpData = alloca %struct.STest, align 8 %tmpData = alloca %struct.STest, align 8
%0 = bitcast %struct.STest* %tmpData to i8* %0 = bitcast %struct.STest* %tmpData to i8*
call void @llvm.lifetime.start(i64 16, i8* %0) call void @llvm.lifetime.start.p0i8(i64 16, i8* %0)
%x = getelementptr inbounds %struct.STest, %struct.STest* %tmpData, i64 0, i32 0, i32 0 %x = getelementptr inbounds %struct.STest, %struct.STest* %tmpData, i64 0, i32 0, i32 0
store float 1.230000e+02, float* %x, align 8 store float 1.230000e+02, float* %x, align 8
%y = getelementptr inbounds %struct.STest, %struct.STest* %tmpData, i64 0, i32 0, i32 1 %y = getelementptr inbounds %struct.STest, %struct.STest* %tmpData, i64 0, i32 0, i32 1
store float 4.560000e+02, float* %y, align 4 store float 4.560000e+02, float* %y, align 4
%m_posB = getelementptr inbounds %struct.STest, %struct.STest* %tmpData, i64 0, i32 1 %m_posB = getelementptr inbounds %struct.STest, %struct.STest* %tmpData, i64 0, i32 1
%1 = bitcast %struct.STest* %tmpData to i64* %1 = bitcast %struct.STest* %tmpData to i64*
%2 = bitcast %struct.SPos* %m_posB to i64* %2 = bitcast %struct.SPos* %m_posB to i64*
%3 = load i64, i64* %1, align 8 %3 = load i64, i64* %1, align 8
store i64 %3, i64* %2, align 8 store i64 %3, i64* %2, align 8
%4 = bitcast %struct.STest* %outData to i8* %4 = bitcast %struct.STest* %outData to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %4, i8* %0, i64 16, i32 4, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %4, i8* %0, i64 16, i32 4, i1 false)
call void @llvm.lifetime.end(i64 16, i8* %0) call void @llvm.lifetime.end.p0i8(i64 16, i8* %0)
ret void ret void
} }
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i32, i1) nounwind declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i32, i1) nounwind
define void @PR27999() unnamed_addr { define void @PR27999() unnamed_addr {
; CHECK-LABEL: @PR27999( ; CHECK-LABEL: @PR27999(
; CHECK: entry-block: ; CHECK: entry-block:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
entry-block: entry-block:
%0 = alloca [2 x i64], align 8 %0 = alloca [2 x i64], align 8
%1 = bitcast [2 x i64]* %0 to i8* %1 = bitcast [2 x i64]* %0 to i8*
call void @llvm.lifetime.start(i64 16, i8* %1) call void @llvm.lifetime.start.p0i8(i64 16, i8* %1)
%2 = getelementptr inbounds [2 x i64], [2 x i64]* %0, i32 0, i32 1 %2 = getelementptr inbounds [2 x i64], [2 x i64]* %0, i32 0, i32 1
%3 = bitcast i64* %2 to i8* %3 = bitcast i64* %2 to i8*
call void @llvm.lifetime.end(i64 8, i8* %3) call void @llvm.lifetime.end.p0i8(i64 8, i8* %3)
ret void ret void
} }
define void @PR29139() { define void @PR29139() {
; CHECK-LABEL: @PR29139( ; CHECK-LABEL: @PR29139(
; CHECK: bb1: ; CHECK: bb1:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
bb1: bb1:
%e.7.sroa.6.i = alloca i32, align 1 %e.7.sroa.6.i = alloca i32, align 1
%e.7.sroa.6.0.load81.i = load i32, i32* %e.7.sroa.6.i, align 1 %e.7.sroa.6.0.load81.i = load i32, i32* %e.7.sroa.6.i, align 1
%0 = bitcast i32* %e.7.sroa.6.i to i8* %0 = bitcast i32* %e.7.sroa.6.i to i8*
call void @llvm.lifetime.end(i64 2, i8* %0) call void @llvm.lifetime.end.p0i8(i64 2, i8* %0)
ret void ret void
} }

test/Transforms/SROA/pr26972.ll

; RUN: opt < %s -sroa -S | FileCheck %s ; RUN: opt < %s -sroa -S | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-linux" target triple = "x86_64-pc-linux"
; Make sure we properly handle allocas where the allocated ; Make sure we properly handle allocas where the allocated
; size overflows a uint32_t. This specific constant results in ; size overflows a uint32_t. This specific constant results in
; the size in bits being 32 after truncation to a 32-bit int. ; the size in bits being 32 after truncation to a 32-bit int.
; CHECK-LABEL: fn1 ; CHECK-LABEL: fn1
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
define void @fn1() { define void @fn1() {
%a = alloca [1073741825 x i32], align 16 %a = alloca [1073741825 x i32], align 16
%t0 = bitcast [1073741825 x i32]* %a to i8* %t0 = bitcast [1073741825 x i32]* %a to i8*
call void @llvm.lifetime.end(i64 4294967300, i8* %t0) call void @llvm.lifetime.end.p0i8(i64 4294967300, i8* %t0)
ret void ret void
} }
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)

test/Transforms/SROA/vector-lifetime-intrinsic.ll

; RUN: opt -sroa -S < %s | FileCheck %s ; RUN: opt -sroa -S < %s | FileCheck %s
target datalayout = "e-p:64:32-i64:32-v32:32-n32-S64" target datalayout = "e-p:64:32-i64:32-v32:32-n32-S64"
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) #0 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #0
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) #0 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #0
; CHECK: @wombat ; CHECK: @wombat
; CHECK-NOT: alloca ; CHECK-NOT: alloca
; CHECK: ret void ; CHECK: ret void
define void @wombat(<4 x float> %arg1) { define void @wombat(<4 x float> %arg1) {
bb: bb:
%tmp = alloca <4 x float>, align 16 %tmp = alloca <4 x float>, align 16
%tmp8 = bitcast <4 x float>* %tmp to i8* %tmp8 = bitcast <4 x float>* %tmp to i8*
call void @llvm.lifetime.start(i64 16, i8* %tmp8) call void @llvm.lifetime.start.p0i8(i64 16, i8* %tmp8)
store <4 x float> %arg1, <4 x float>* %tmp, align 16 store <4 x float> %arg1, <4 x float>* %tmp, align 16
%tmp17 = bitcast <4 x float>* %tmp to <3 x float>* %tmp17 = bitcast <4 x float>* %tmp to <3 x float>*
%tmp18 = load <3 x float>, <3 x float>* %tmp17 %tmp18 = load <3 x float>, <3 x float>* %tmp17
%tmp20 = bitcast <4 x float>* %tmp to i8* %tmp20 = bitcast <4 x float>* %tmp to i8*
call void @llvm.lifetime.end(i64 16, i8* %tmp20) call void @llvm.lifetime.end.p0i8(i64 16, i8* %tmp20)
call void @wombat3(<3 x float> %tmp18) call void @wombat3(<3 x float> %tmp18)
ret void ret void
} }
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @wombat3(<3 x float>) #0 declare void @wombat3(<3 x float>) #0
attributes #0 = { nounwind } attributes #0 = { nounwind }

test/Transforms/SafeStack/X86/call.ll

Show First 20 Lines • Show All 153 Lines • ▼ Show 20 Lines
; Lifetime intrinsics are always safe. ; Lifetime intrinsics are always safe.
define void @call_lifetime(i32* %p) { define void @call_lifetime(i32* %p) {
; CHECK-LABEL: define void @call_lifetime ; CHECK-LABEL: define void @call_lifetime
; CHECK-NOT: @__safestack_unsafe_stack_ptr ; CHECK-NOT: @__safestack_unsafe_stack_ptr
; CHECK: ret void ; CHECK: ret void
entry: entry:
%q = alloca [100 x i8], align 16 %q = alloca [100 x i8], align 16
%0 = bitcast [100 x i8]* %q to i8* %0 = bitcast [100 x i8]* %q to i8*
call void @llvm.lifetime.start(i64 100, i8* %0) call void @llvm.lifetime.start.p0i8(i64 100, i8* %0)
call void @llvm.lifetime.end(i64 100, i8* %0) call void @llvm.lifetime.end.p0i8(i64 100, i8* %0)
ret void ret void
} }
declare void @readonly(i8* nocapture) readonly declare void @readonly(i8* nocapture) readonly
declare void @arg_readonly(i8* readonly nocapture) declare void @arg_readonly(i8* readonly nocapture)
declare void @readwrite(i8* nocapture) declare void @readwrite(i8* nocapture)
declare void @capture(i8* readnone) readnone declare void @capture(i8* readnone) readnone
declare void @readnone(i8* nocapture) readnone declare void @readnone(i8* nocapture) readnone
declare void @readnone0(i8* nocapture readnone, i8* nocapture) declare void @readnone0(i8* nocapture readnone, i8* nocapture)
declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i32, i1) nounwind argmemonly declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i32, i1) nounwind argmemonly
declare void @llvm.lifetime.start(i64, i8* nocapture) nounwind argmemonly declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind argmemonly
declare void @llvm.lifetime.end(i64, i8* nocapture) nounwind argmemonly declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) nounwind argmemonly

test/Transforms/SafeStack/X86/coloring-ssp.ll

Show All 10 Lines
; CHECK: %[[StackGuardSlot:.*]] = bitcast i8* %[[A]] to i8** ; CHECK: %[[StackGuardSlot:.*]] = bitcast i8* %[[A]] to i8**
; CHECK: store i8* %{{.*}}, i8** %[[StackGuardSlot]] ; CHECK: store i8* %{{.*}}, i8** %[[StackGuardSlot]]
%x = alloca i64, align 8 %x = alloca i64, align 8
%y = alloca i64, align 8 %y = alloca i64, align 8
%x0 = bitcast i64* %x to i8* %x0 = bitcast i64* %x to i8*
%y0 = bitcast i64* %y to i8* %y0 = bitcast i64* %y to i8*
call void @llvm.lifetime.start(i64 -1, i8* %x0) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %x0)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -16 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -16
call void @capture64(i64* %x) call void @capture64(i64* %x)
call void @llvm.lifetime.end(i64 -1, i8* %x0) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %x0)
call void @llvm.lifetime.start(i64 -1, i8* %y0) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %y0)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -16 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -16
call void @capture64(i64* %y) call void @capture64(i64* %y)
call void @llvm.lifetime.end(i64 -1, i8* %y0) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %y0)
ret void ret void
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
declare void @capture64(i64*) declare void @capture64(i64*)

test/Transforms/SafeStack/X86/coloring.ll

; RUN: opt -safe-stack -S -mtriple=i386-pc-linux-gnu < %s -o - | FileCheck %s ; RUN: opt -safe-stack -S -mtriple=i386-pc-linux-gnu < %s -o - | FileCheck %s
; RUN: opt -safe-stack -S -mtriple=x86_64-pc-linux-gnu < %s -o - | FileCheck %s ; RUN: opt -safe-stack -S -mtriple=x86_64-pc-linux-gnu < %s -o - | FileCheck %s
define void @f() safestack { define void @f() safestack {
entry: entry:
; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr ; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
; CHECK: %[[USST:.*]] = getelementptr i8, i8* %[[USP]], i32 -16 ; CHECK: %[[USST:.*]] = getelementptr i8, i8* %[[USP]], i32 -16
%x = alloca i32, align 4 %x = alloca i32, align 4
%x1 = alloca i32, align 4 %x1 = alloca i32, align 4
%x2 = alloca i32, align 4 %x2 = alloca i32, align 4
%0 = bitcast i32* %x to i8* %0 = bitcast i32* %x to i8*
call void @llvm.lifetime.start(i64 4, i8* %0) call void @llvm.lifetime.start.p0i8(i64 4, i8* %0)
; CHECK: %[[A1:.*]] = getelementptr i8, i8* %[[USP]], i32 -4 ; CHECK: %[[A1:.*]] = getelementptr i8, i8* %[[USP]], i32 -4
; CHECK: %[[A2:.*]] = bitcast i8* %[[A1]] to i32* ; CHECK: %[[A2:.*]] = bitcast i8* %[[A1]] to i32*
; CHECK: call void @capture(i32* nonnull %[[A2]]) ; CHECK: call void @capture(i32* nonnull %[[A2]])
call void @capture(i32* nonnull %x) call void @capture(i32* nonnull %x)
call void @llvm.lifetime.end(i64 4, i8* %0) call void @llvm.lifetime.end.p0i8(i64 4, i8* %0)
%1 = bitcast i32* %x1 to i8* %1 = bitcast i32* %x1 to i8*
call void @llvm.lifetime.start(i64 4, i8* %1) call void @llvm.lifetime.start.p0i8(i64 4, i8* %1)
; CHECK: %[[B1:.*]] = getelementptr i8, i8* %[[USP]], i32 -4 ; CHECK: %[[B1:.*]] = getelementptr i8, i8* %[[USP]], i32 -4
; CHECK: %[[B2:.*]] = bitcast i8* %[[B1]] to i32* ; CHECK: %[[B2:.*]] = bitcast i8* %[[B1]] to i32*
; CHECK: call void @capture(i32* nonnull %[[B2]]) ; CHECK: call void @capture(i32* nonnull %[[B2]])
call void @capture(i32* nonnull %x1) call void @capture(i32* nonnull %x1)
call void @llvm.lifetime.end(i64 4, i8* %1) call void @llvm.lifetime.end.p0i8(i64 4, i8* %1)
%2 = bitcast i32* %x2 to i8* %2 = bitcast i32* %x2 to i8*
call void @llvm.lifetime.start(i64 4, i8* %2) call void @llvm.lifetime.start.p0i8(i64 4, i8* %2)
; CHECK: %[[C1:.*]] = getelementptr i8, i8* %[[USP]], i32 -4 ; CHECK: %[[C1:.*]] = getelementptr i8, i8* %[[USP]], i32 -4
; CHECK: %[[C2:.*]] = bitcast i8* %[[C1]] to i32* ; CHECK: %[[C2:.*]] = bitcast i8* %[[C1]] to i32*
; CHECK: call void @capture(i32* nonnull %[[C2]]) ; CHECK: call void @capture(i32* nonnull %[[C2]])
call void @capture(i32* nonnull %x2) call void @capture(i32* nonnull %x2)
call void @llvm.lifetime.end(i64 4, i8* %2) call void @llvm.lifetime.end.p0i8(i64 4, i8* %2)
ret void ret void
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
declare void @capture(i32*) declare void @capture(i32*)

test/Transforms/SafeStack/X86/coloring2.ll

Show All 9 Lines; CHECK: getelementptr i8, i8* %[[USP]], i32 -16
%x = alloca i32, align 4 %x = alloca i32, align 4
%y = alloca i32, align 4 %y = alloca i32, align 4
%z = alloca i32, align 4 %z = alloca i32, align 4
%x0 = bitcast i32* %x to i8* %x0 = bitcast i32* %x to i8*
%y0 = bitcast i32* %y to i8* %y0 = bitcast i32* %y to i8*
%z0 = bitcast i32* %z to i8* %z0 = bitcast i32* %z to i8*
call void @llvm.lifetime.start(i64 -1, i8* %z0) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %z0)
call void @llvm.lifetime.start(i64 -1, i8* %x0) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %x0)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -4 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
call void @capture32(i32* %x) call void @capture32(i32* %x)
call void @llvm.lifetime.end(i64 -1, i8* %x0) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %x0)
call void @llvm.lifetime.start(i64 -1, i8* %y0) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %y0)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -4 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
call void @capture32(i32* %y) call void @capture32(i32* %y)
call void @llvm.lifetime.end(i64 -1, i8* %y0) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %y0)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -8 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -8
call void @capture32(i32* %z) call void @capture32(i32* %z)
call void @llvm.lifetime.end(i64 -1, i8* %z0) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %z0)
ret void ret void
} }
define void @no_markers() safestack { define void @no_markers() safestack {
; CHECK-LABEL: define void @no_markers( ; CHECK-LABEL: define void @no_markers(
entry: entry:
; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr ; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
; CHECK: getelementptr i8, i8* %[[USP]], i32 -16 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -16
%x = alloca i32, align 4 %x = alloca i32, align 4
%y = alloca i32, align 4 %y = alloca i32, align 4
%x0 = bitcast i32* %x to i8* %x0 = bitcast i32* %x to i8*
call void @llvm.lifetime.start(i64 -1, i8* %x0) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %x0)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -4 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
call void @capture32(i32* %x) call void @capture32(i32* %x)
call void @llvm.lifetime.end(i64 -1, i8* %x0) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %x0)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -8 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -8
call void @capture32(i32* %y) call void @capture32(i32* %y)
ret void ret void
} }
; x and y can't share memory, but they can split z's storage. ; x and y can't share memory, but they can split z's storage.
define void @g() safestack { define void @g() safestack {
; CHECK-LABEL: define void @g ; CHECK-LABEL: define void @g
entry: entry:
; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr ; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
; CHECK: getelementptr i8, i8* %[[USP]], i32 -16 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -16
%x = alloca i32, align 4 %x = alloca i32, align 4
%y = alloca i32, align 4 %y = alloca i32, align 4
%z = alloca i64, align 4 %z = alloca i64, align 4
%x0 = bitcast i32* %x to i8* %x0 = bitcast i32* %x to i8*
%y0 = bitcast i32* %y to i8* %y0 = bitcast i32* %y to i8*
%z0 = bitcast i64* %z to i8* %z0 = bitcast i64* %z to i8*
call void @llvm.lifetime.start(i64 -1, i8* %x0) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %x0)
call void @llvm.lifetime.start(i64 -1, i8* %y0) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %y0)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -4 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
call void @capture32(i32* %x) call void @capture32(i32* %x)
call void @llvm.lifetime.end(i64 -1, i8* %x0) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %x0)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -8 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -8
call void @capture32(i32* %y) call void @capture32(i32* %y)
call void @llvm.lifetime.end(i64 -1, i8* %y0) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %y0)
call void @llvm.lifetime.start(i64 -1, i8* %z0) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %z0)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -8 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -8
call void @capture64(i64* %z) call void @capture64(i64* %z)
call void @llvm.lifetime.end(i64 -1, i8* %z0) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %z0)
ret void ret void
} }
; Both y and z fit in x's alignment gap. ; Both y and z fit in x's alignment gap.
define void @h() safestack { define void @h() safestack {
; CHECK-LABEL: define void @h ; CHECK-LABEL: define void @h
entry: entry:
; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr ; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
; CHECK: getelementptr i8, i8* %[[USP]], i32 -16 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -16
%x = alloca i32, align 16 %x = alloca i32, align 16
%z = alloca i64, align 4 %z = alloca i64, align 4
%y = alloca i32, align 4 %y = alloca i32, align 4
%x0 = bitcast i32* %x to i8* %x0 = bitcast i32* %x to i8*
%y0 = bitcast i32* %y to i8* %y0 = bitcast i32* %y to i8*
%z0 = bitcast i64* %z to i8* %z0 = bitcast i64* %z to i8*
call void @llvm.lifetime.start(i64 -1, i8* %x0) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %x0)
call void @llvm.lifetime.start(i64 -1, i8* %y0) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %y0)
call void @llvm.lifetime.start(i64 -1, i8* %z0) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %z0)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -16 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -16
call void @capture32(i32* %x) call void @capture32(i32* %x)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -12 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -12
call void @capture32(i32* %y) call void @capture32(i32* %y)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -8 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -8
call void @capture64(i64* %z) call void @capture64(i64* %z)
call void @llvm.lifetime.end(i64 -1, i8* %x0) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %x0)
call void @llvm.lifetime.end(i64 -1, i8* %y0) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %y0)
call void @llvm.lifetime.end(i64 -1, i8* %z0) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %z0)
ret void ret void
} }
; void f(bool a, bool b) { ; void f(bool a, bool b) {
; long x1, x2; capture64(&x1); capture64(&x2); ; long x1, x2; capture64(&x1); capture64(&x2);
; if (a) { ; if (a) {
; long y; capture64(&y); ; long y; capture64(&y);
Show All 21 Lines; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -32
%x2 = alloca i64, align 8 %x2 = alloca i64, align 8
%y = alloca i64, align 8 %y = alloca i64, align 8
%y1 = alloca i64, align 8 %y1 = alloca i64, align 8
%y2 = alloca i64, align 8 %y2 = alloca i64, align 8
%z = alloca i64, align 8 %z = alloca i64, align 8
%z1 = alloca i64, align 8 %z1 = alloca i64, align 8
%z2 = alloca i64, align 8 %z2 = alloca i64, align 8
%0 = bitcast i64* %x1 to i8* %0 = bitcast i64* %x1 to i8*
call void @llvm.lifetime.start(i64 -1, i8* %0) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %0)
%1 = bitcast i64* %x2 to i8* %1 = bitcast i64* %x2 to i8*
call void @llvm.lifetime.start(i64 -1, i8* %1) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %1)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -8 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -8
; CHECK: call void @capture64( ; CHECK: call void @capture64(
call void @capture64(i64* nonnull %x1) call void @capture64(i64* nonnull %x1)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -16 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -16
; CHECK: call void @capture64( ; CHECK: call void @capture64(
call void @capture64(i64* nonnull %x2) call void @capture64(i64* nonnull %x2)
br i1 %a, label %if.then, label %if.else4 br i1 %a, label %if.then, label %if.else4
if.then: ; preds = %entry if.then: ; preds = %entry
%2 = bitcast i64* %y to i8* %2 = bitcast i64* %y to i8*
call void @llvm.lifetime.start(i64 -1, i8* %2) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %2)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -24 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -24
; CHECK: call void @capture64( ; CHECK: call void @capture64(
call void @capture64(i64* nonnull %y) call void @capture64(i64* nonnull %y)
br i1 %b, label %if.then3, label %if.else br i1 %b, label %if.then3, label %if.else
if.then3: ; preds = %if.then if.then3: ; preds = %if.then
%3 = bitcast i64* %y1 to i8* %3 = bitcast i64* %y1 to i8*
call void @llvm.lifetime.start(i64 -1, i8* %3) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %3)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -32 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -32
; CHECK: call void @capture64( ; CHECK: call void @capture64(
call void @capture64(i64* nonnull %y1) call void @capture64(i64* nonnull %y1)
call void @llvm.lifetime.end(i64 -1, i8* %3) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %3)
br label %if.end br label %if.end
if.else: ; preds = %if.then if.else: ; preds = %if.then
%4 = bitcast i64* %y2 to i8* %4 = bitcast i64* %y2 to i8*
call void @llvm.lifetime.start(i64 -1, i8* %4) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %4)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -32 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -32
; CHECK: call void @capture64( ; CHECK: call void @capture64(
call void @capture64(i64* nonnull %y2) call void @capture64(i64* nonnull %y2)
call void @llvm.lifetime.end(i64 -1, i8* %4) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %4)
br label %if.end br label %if.end
if.end: ; preds = %if.else, %if.then3 if.end: ; preds = %if.else, %if.then3
call void @llvm.lifetime.end(i64 -1, i8* %2) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %2)
br label %if.end9 br label %if.end9
if.else4: ; preds = %entry if.else4: ; preds = %entry
%5 = bitcast i64* %z to i8* %5 = bitcast i64* %z to i8*
call void @llvm.lifetime.start(i64 -1, i8* %5) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %5)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -24 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -24
; CHECK: call void @capture64( ; CHECK: call void @capture64(
call void @capture64(i64* nonnull %z) call void @capture64(i64* nonnull %z)
br i1 %b, label %if.then6, label %if.else7 br i1 %b, label %if.then6, label %if.else7
if.then6: ; preds = %if.else4 if.then6: ; preds = %if.else4
%6 = bitcast i64* %z1 to i8* %6 = bitcast i64* %z1 to i8*
call void @llvm.lifetime.start(i64 -1, i8* %6) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %6)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -32 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -32
; CHECK: call void @capture64( ; CHECK: call void @capture64(
call void @capture64(i64* nonnull %z1) call void @capture64(i64* nonnull %z1)
call void @llvm.lifetime.end(i64 -1, i8* %6) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %6)
br label %if.end8 br label %if.end8
if.else7: ; preds = %if.else4 if.else7: ; preds = %if.else4
%7 = bitcast i64* %z2 to i8* %7 = bitcast i64* %z2 to i8*
call void @llvm.lifetime.start(i64 -1, i8* %7) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %7)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -32 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -32
; CHECK: call void @capture64( ; CHECK: call void @capture64(
call void @capture64(i64* nonnull %z2) call void @capture64(i64* nonnull %z2)
call void @llvm.lifetime.end(i64 -1, i8* %7) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %7)
br label %if.end8 br label %if.end8
if.end8: ; preds = %if.else7, %if.then6 if.end8: ; preds = %if.else7, %if.then6
call void @llvm.lifetime.end(i64 -1, i8* %5) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %5)
br label %if.end9 br label %if.end9
if.end9: ; preds = %if.end8, %if.end if.end9: ; preds = %if.end8, %if.end
call void @llvm.lifetime.end(i64 -1, i8* %1) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %1)
call void @llvm.lifetime.end(i64 -1, i8* %0) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %0)
ret void ret void
} }
; lifetime for x ends in 2 different BBs ; lifetime for x ends in 2 different BBs
define void @no_merge1(i1 %d) safestack { define void @no_merge1(i1 %d) safestack {
; CHECK-LABEL: define void @no_merge1( ; CHECK-LABEL: define void @no_merge1(
entry: entry:
; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr ; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -16 ; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -16
%x = alloca i32, align 4 %x = alloca i32, align 4
%y = alloca i32, align 4 %y = alloca i32, align 4
%x0 = bitcast i32* %x to i8* %x0 = bitcast i32* %x to i8*
%y0 = bitcast i32* %y to i8* %y0 = bitcast i32* %y to i8*
call void @llvm.lifetime.start(i64 -1, i8* %x0) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %x0)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -4 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
; CHECK: call void @capture32( ; CHECK: call void @capture32(
call void @capture32(i32* %x) call void @capture32(i32* %x)
br i1 %d, label %bb2, label %bb3 br i1 %d, label %bb2, label %bb3
bb2: bb2:
call void @llvm.lifetime.start(i64 -1, i8* %y0) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %y0)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -8 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -8
; CHECK: call void @capture32( ; CHECK: call void @capture32(
call void @capture32(i32* %y) call void @capture32(i32* %y)
call void @llvm.lifetime.end(i64 -1, i8* %y0) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %y0)
call void @llvm.lifetime.end(i64 -1, i8* %x0) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %x0)
ret void ret void
bb3: bb3:
call void @llvm.lifetime.end(i64 -1, i8* %x0) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %x0)
ret void ret void
} }
define void @merge1(i1 %d) safestack { define void @merge1(i1 %d) safestack {
; CHECK-LABEL: define void @merge1( ; CHECK-LABEL: define void @merge1(
entry: entry:
; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr ; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -16 ; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -16
%x = alloca i32, align 4 %x = alloca i32, align 4
%y = alloca i32, align 4 %y = alloca i32, align 4
%x0 = bitcast i32* %x to i8* %x0 = bitcast i32* %x to i8*
%y0 = bitcast i32* %y to i8* %y0 = bitcast i32* %y to i8*
call void @llvm.lifetime.start(i64 -1, i8* %x0) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %x0)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -4 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
; CHECK: call void @capture32( ; CHECK: call void @capture32(
call void @capture32(i32* %x) call void @capture32(i32* %x)
call void @llvm.lifetime.end(i64 -1, i8* %x0) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %x0)
br i1 %d, label %bb2, label %bb3 br i1 %d, label %bb2, label %bb3
bb2: bb2:
call void @llvm.lifetime.start(i64 -1, i8* %y0) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %y0)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -4 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
; CHECK: call void @capture32( ; CHECK: call void @capture32(
call void @capture32(i32* %y) call void @capture32(i32* %y)
call void @llvm.lifetime.end(i64 -1, i8* %y0) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %y0)
ret void ret void
bb3: bb3:
ret void ret void
} }
; Missing lifetime.end ; Missing lifetime.end
define void @merge2_noend(i1 %d) safestack { define void @merge2_noend(i1 %d) safestack {
; CHECK-LABEL: define void @merge2_noend( ; CHECK-LABEL: define void @merge2_noend(
entry: entry:
; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr ; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -16 ; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -16
%x = alloca i32, align 4 %x = alloca i32, align 4
%y = alloca i32, align 4 %y = alloca i32, align 4
%x0 = bitcast i32* %x to i8* %x0 = bitcast i32* %x to i8*
%y0 = bitcast i32* %y to i8* %y0 = bitcast i32* %y to i8*
call void @llvm.lifetime.start(i64 -1, i8* %x0) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %x0)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -4 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
; CHECK: call void @capture32( ; CHECK: call void @capture32(
call void @capture32(i32* %x) call void @capture32(i32* %x)
call void @llvm.lifetime.end(i64 -1, i8* %x0) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %x0)
br i1 %d, label %bb2, label %bb3 br i1 %d, label %bb2, label %bb3
bb2: bb2:
call void @llvm.lifetime.start(i64 -1, i8* %y0) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %y0)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -4 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
; CHECK: call void @capture32( ; CHECK: call void @capture32(
call void @capture32(i32* %y) call void @capture32(i32* %y)
ret void ret void
bb3: bb3:
ret void ret void
} }
; Missing lifetime.end ; Missing lifetime.end
define void @merge3_noend(i1 %d) safestack { define void @merge3_noend(i1 %d) safestack {
; CHECK-LABEL: define void @merge3_noend( ; CHECK-LABEL: define void @merge3_noend(
entry: entry:
; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr ; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -16 ; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -16
%x = alloca i32, align 4 %x = alloca i32, align 4
%y = alloca i32, align 4 %y = alloca i32, align 4
%x0 = bitcast i32* %x to i8* %x0 = bitcast i32* %x to i8*
%y0 = bitcast i32* %y to i8* %y0 = bitcast i32* %y to i8*
call void @llvm.lifetime.start(i64 -1, i8* %x0) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %x0)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -4 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
; CHECK: call void @capture32( ; CHECK: call void @capture32(
call void @capture32(i32* %x) call void @capture32(i32* %x)
br i1 %d, label %bb2, label %bb3 br i1 %d, label %bb2, label %bb3
bb2: bb2:
call void @llvm.lifetime.end(i64 -1, i8* %x0) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %x0)
call void @llvm.lifetime.start(i64 -1, i8* %y0) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %y0)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -4 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
; CHECK: call void @capture32( ; CHECK: call void @capture32(
call void @capture32(i32* %y) call void @capture32(i32* %y)
ret void ret void
bb3: bb3:
ret void ret void
} }
; Missing lifetime.start ; Missing lifetime.start
define void @nomerge4_nostart(i1 %d) safestack { define void @nomerge4_nostart(i1 %d) safestack {
; CHECK-LABEL: define void @nomerge4_nostart( ; CHECK-LABEL: define void @nomerge4_nostart(
entry: entry:
; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr ; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -16 ; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -16
%x = alloca i32, align 4 %x = alloca i32, align 4
%y = alloca i32, align 4 %y = alloca i32, align 4
%x0 = bitcast i32* %x to i8* %x0 = bitcast i32* %x to i8*
%y0 = bitcast i32* %y to i8* %y0 = bitcast i32* %y to i8*
; CHECK: getelementptr i8, i8* %[[USP]], i32 -4 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
; CHECK: call void @capture32( ; CHECK: call void @capture32(
call void @capture32(i32* %x) call void @capture32(i32* %x)
call void @llvm.lifetime.end(i64 -1, i8* %x0) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %x0)
br i1 %d, label %bb2, label %bb3 br i1 %d, label %bb2, label %bb3
bb2: bb2:
call void @llvm.lifetime.start(i64 -1, i8* %y0) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %y0)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -8 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -8
; CHECK: call void @capture32( ; CHECK: call void @capture32(
call void @capture32(i32* %y) call void @capture32(i32* %y)
ret void ret void
bb3: bb3:
ret void ret void
} }
define void @array_merge() safestack { define void @array_merge() safestack {
; CHECK-LABEL: define void @array_merge( ; CHECK-LABEL: define void @array_merge(
entry: entry:
; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr ; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -800 ; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -800
%A.i1 = alloca [100 x i32], align 4 %A.i1 = alloca [100 x i32], align 4
%B.i2 = alloca [100 x i32], align 4 %B.i2 = alloca [100 x i32], align 4
%A.i = alloca [100 x i32], align 4 %A.i = alloca [100 x i32], align 4
%B.i = alloca [100 x i32], align 4 %B.i = alloca [100 x i32], align 4
%0 = bitcast [100 x i32]* %A.i to i8* %0 = bitcast [100 x i32]* %A.i to i8*
call void @llvm.lifetime.start(i64 -1, i8* %0) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %0)
%1 = bitcast [100 x i32]* %B.i to i8* %1 = bitcast [100 x i32]* %B.i to i8*
call void @llvm.lifetime.start(i64 -1, i8* %1) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %1)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -400 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -400
; CHECK: call void @capture100x32( ; CHECK: call void @capture100x32(
call void @capture100x32([100 x i32]* %A.i) call void @capture100x32([100 x i32]* %A.i)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -800 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -800
; CHECK: call void @capture100x32( ; CHECK: call void @capture100x32(
call void @capture100x32([100 x i32]* %B.i) call void @capture100x32([100 x i32]* %B.i)
call void @llvm.lifetime.end(i64 -1, i8* %0) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %0)
call void @llvm.lifetime.end(i64 -1, i8* %1) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %1)
%2 = bitcast [100 x i32]* %A.i1 to i8* %2 = bitcast [100 x i32]* %A.i1 to i8*
call void @llvm.lifetime.start(i64 -1, i8* %2) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %2)
%3 = bitcast [100 x i32]* %B.i2 to i8* %3 = bitcast [100 x i32]* %B.i2 to i8*
call void @llvm.lifetime.start(i64 -1, i8* %3) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %3)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -400 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -400
; CHECK: call void @capture100x32( ; CHECK: call void @capture100x32(
call void @capture100x32([100 x i32]* %A.i1) call void @capture100x32([100 x i32]* %A.i1)
; CHECK: getelementptr i8, i8* %[[USP]], i32 -800 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -800
; CHECK: call void @capture100x32( ; CHECK: call void @capture100x32(
call void @capture100x32([100 x i32]* %B.i2) call void @capture100x32([100 x i32]* %B.i2)
call void @llvm.lifetime.end(i64 -1, i8* %2) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %2)
call void @llvm.lifetime.end(i64 -1, i8* %3) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %3)
ret void ret void
} }
define void @myCall_pr15707() safestack { define void @myCall_pr15707() safestack {
; CHECK-LABEL: define void @myCall_pr15707( ; CHECK-LABEL: define void @myCall_pr15707(
entry: entry:
; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr ; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -200000 ; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -200000
%buf1 = alloca i8, i32 100000, align 16 %buf1 = alloca i8, i32 100000, align 16
%buf2 = alloca i8, i32 100000, align 16 %buf2 = alloca i8, i32 100000, align 16
call void @llvm.lifetime.start(i64 -1, i8* %buf1) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %buf1)
call void @llvm.lifetime.end(i64 -1, i8* %buf1) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %buf1)
call void @llvm.lifetime.start(i64 -1, i8* %buf1) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %buf1)
call void @llvm.lifetime.start(i64 -1, i8* %buf2) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %buf2)
call void @capture8(i8* %buf1) call void @capture8(i8* %buf1)
call void @capture8(i8* %buf2) call void @capture8(i8* %buf2)
ret void ret void
} }
; Check that we don't assert and crash even when there are allocas ; Check that we don't assert and crash even when there are allocas
; outside the declared lifetime regions. ; outside the declared lifetime regions.
define void @bad_range() safestack { define void @bad_range() safestack {
; CHECK-LABEL: define void @bad_range( ; CHECK-LABEL: define void @bad_range(
entry: entry:
; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr ; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
; A.i and B.i unsafe, not merged ; A.i and B.i unsafe, not merged
; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -800 ; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -800
; A.i1 and B.i2 safe ; A.i1 and B.i2 safe
; CHECK: = alloca [100 x i32], align 4 ; CHECK: = alloca [100 x i32], align 4
; CHECK: = alloca [100 x i32], align 4 ; CHECK: = alloca [100 x i32], align 4
%A.i1 = alloca [100 x i32], align 4 %A.i1 = alloca [100 x i32], align 4
%B.i2 = alloca [100 x i32], align 4 %B.i2 = alloca [100 x i32], align 4
%A.i = alloca [100 x i32], align 4 %A.i = alloca [100 x i32], align 4
%B.i = alloca [100 x i32], align 4 %B.i = alloca [100 x i32], align 4
%0 = bitcast [100 x i32]* %A.i to i8* %0 = bitcast [100 x i32]* %A.i to i8*
call void @llvm.lifetime.start(i64 -1, i8* %0) nounwind call void @llvm.lifetime.start.p0i8(i64 -1, i8* %0) nounwind
%1 = bitcast [100 x i32]* %B.i to i8* %1 = bitcast [100 x i32]* %B.i to i8*
call void @llvm.lifetime.start(i64 -1, i8* %1) nounwind call void @llvm.lifetime.start.p0i8(i64 -1, i8* %1) nounwind
call void @capture100x32([100 x i32]* %A.i) call void @capture100x32([100 x i32]* %A.i)
call void @capture100x32([100 x i32]* %B.i) call void @capture100x32([100 x i32]* %B.i)
call void @llvm.lifetime.end(i64 -1, i8* %0) nounwind call void @llvm.lifetime.end.p0i8(i64 -1, i8* %0) nounwind
call void @llvm.lifetime.end(i64 -1, i8* %1) nounwind call void @llvm.lifetime.end.p0i8(i64 -1, i8* %1) nounwind
br label %block2 br label %block2
block2: block2:
; I am used outside the marked lifetime. ; I am used outside the marked lifetime.
call void @capture100x32([100 x i32]* %A.i) call void @capture100x32([100 x i32]* %A.i)
call void @capture100x32([100 x i32]* %B.i) call void @capture100x32([100 x i32]* %B.i)
ret void ret void
} }
%struct.Klass = type { i32, i32 } %struct.Klass = type { i32, i32 }
define i32 @shady_range(i32 %argc, i8** nocapture %argv) safestack { define i32 @shady_range(i32 %argc, i8** nocapture %argv) safestack {
; CHECK-LABEL: define i32 @shady_range( ; CHECK-LABEL: define i32 @shady_range(
entry: entry:
; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr ; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -64 ; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -64
%a.i = alloca [4 x %struct.Klass], align 16 %a.i = alloca [4 x %struct.Klass], align 16
%b.i = alloca [4 x %struct.Klass], align 16 %b.i = alloca [4 x %struct.Klass], align 16
%a8 = bitcast [4 x %struct.Klass]* %a.i to i8* %a8 = bitcast [4 x %struct.Klass]* %a.i to i8*
%b8 = bitcast [4 x %struct.Klass]* %b.i to i8* %b8 = bitcast [4 x %struct.Klass]* %b.i to i8*
; I am used outside the lifetime zone below: ; I am used outside the lifetime zone below:
%z2 = getelementptr inbounds [4 x %struct.Klass], [4 x %struct.Klass]* %a.i, i64 0, i64 0, i32 0 %z2 = getelementptr inbounds [4 x %struct.Klass], [4 x %struct.Klass]* %a.i, i64 0, i64 0, i32 0
call void @llvm.lifetime.start(i64 -1, i8* %a8) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %a8)
call void @llvm.lifetime.start(i64 -1, i8* %b8) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %b8)
call void @capture8(i8* %a8) call void @capture8(i8* %a8)
call void @capture8(i8* %b8) call void @capture8(i8* %b8)
%z3 = load i32, i32* %z2, align 16 %z3 = load i32, i32* %z2, align 16
call void @llvm.lifetime.end(i64 -1, i8* %a8) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %a8)
call void @llvm.lifetime.end(i64 -1, i8* %b8) call void @llvm.lifetime.end.p0i8(i64 -1, i8* %b8)
ret i32 %z3 ret i32 %z3
} }
define void @end_loop() safestack { define void @end_loop() safestack {
; CHECK-LABEL: define void @end_loop() ; CHECK-LABEL: define void @end_loop()
entry: entry:
; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr ; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -16 ; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -16
%x = alloca i8, align 4 %x = alloca i8, align 4
call void @llvm.lifetime.start(i64 4, i8* %x) nounwind call void @llvm.lifetime.start.p0i8(i64 4, i8* %x) nounwind
br label %l2 br label %l2
l2: l2:
call void @capture8(i8* %x) call void @capture8(i8* %x)
call void @llvm.lifetime.end(i64 4, i8* %x) nounwind call void @llvm.lifetime.end.p0i8(i64 4, i8* %x) nounwind
br label %l2 br label %l2
} }
; Check that @x and @y get distinct stack slots => @x lifetime does not break ; Check that @x and @y get distinct stack slots => @x lifetime does not break
; when control re-enters l2. ; when control re-enters l2.
define void @start_loop() safestack { define void @start_loop() safestack {
; CHECK-LABEL: define void @start_loop() ; CHECK-LABEL: define void @start_loop()
entry: entry:
; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr ; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -16 ; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -16
%x = alloca i8, align 4 %x = alloca i8, align 4
%y = alloca i8, align 4 %y = alloca i8, align 4
call void @llvm.lifetime.start(i64 4, i8* %x) nounwind call void @llvm.lifetime.start.p0i8(i64 4, i8* %x) nounwind
br label %l2 br label %l2
l2: l2:
; CHECK: getelementptr i8, i8* %[[USP]], i32 -8 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -8
call void @llvm.lifetime.start(i64 4, i8* %y) nounwind call void @llvm.lifetime.start.p0i8(i64 4, i8* %y) nounwind
call void @capture8(i8* %y) call void @capture8(i8* %y)
call void @llvm.lifetime.end(i64 4, i8* %y) nounwind call void @llvm.lifetime.end.p0i8(i64 4, i8* %y) nounwind
; CHECK: getelementptr i8, i8* %[[USP]], i32 -4 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
call void @llvm.lifetime.start(i64 4, i8* %x) nounwind call void @llvm.lifetime.start.p0i8(i64 4, i8* %x) nounwind
call void @capture8(i8* %x) call void @capture8(i8* %x)
br label %l2 br label %l2
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
declare void @capture8(i8*) declare void @capture8(i8*)
declare void @capture32(i32*) declare void @capture32(i32*)
declare void @capture64(i64*) declare void @capture64(i64*)
declare void @capture100x32([100 x i32]*) declare void @capture100x32([100 x i32]*)

test/Transforms/SafeStack/X86/debug-loc2.ll

Show All 34 Lines
; CHECK: call void @llvm.dbg.value(metadata i8* %[[USP]], i64 0, metadata ![[X2:.*]], metadata ![[X2_EXPR:.*]]) ; CHECK: call void @llvm.dbg.value(metadata i8* %[[USP]], i64 0, metadata ![[X2:.*]], metadata ![[X2_EXPR:.*]])
call void @llvm.dbg.value(metadata i32* %x2, i64 0, metadata !12, metadata !15), !dbg !18 call void @llvm.dbg.value(metadata i32* %x2, i64 0, metadata !12, metadata !15), !dbg !18
call void @capture(i32* nonnull %x2), !dbg !19 call void @capture(i32* nonnull %x2), !dbg !19
ret void, !dbg !20 ret void, !dbg !20
} }
; Function Attrs: argmemonly nounwind ; Function Attrs: argmemonly nounwind
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
declare void @capture(i32*) #2 declare void @capture(i32*) #2
; Function Attrs: argmemonly nounwind ; Function Attrs: argmemonly nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
; Function Attrs: nounwind readnone ; Function Attrs: nounwind readnone
declare void @llvm.dbg.value(metadata, i64, metadata, metadata) #3 declare void @llvm.dbg.value(metadata, i64, metadata, metadata) #3
declare void @llvm.random.metadata.use(metadata) declare void @llvm.random.metadata.use(metadata)
attributes #0 = { noinline safestack uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #0 = { noinline safestack uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { argmemonly nounwind } attributes #1 = { argmemonly nounwind }
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

test/Transforms/SafeStack/X86/layout-frag.ll

; Test that safestack layout reuses a region w/o fragmentation. ; Test that safestack layout reuses a region w/o fragmentation.
; RUN: opt -safe-stack -S -mtriple=x86_64-pc-linux-gnu < %s -o - | FileCheck %s ; RUN: opt -safe-stack -S -mtriple=x86_64-pc-linux-gnu < %s -o - | FileCheck %s
define void @f() safestack { define void @f() safestack {
; CHECK-LABEL: define void @f ; CHECK-LABEL: define void @f
entry: entry:
; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr ; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
; CHECK: getelementptr i8, i8* %[[USP]], i32 -16 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -16
%x0 = alloca i64, align 8 %x0 = alloca i64, align 8
%x1 = alloca i8, align 1 %x1 = alloca i8, align 1
%x2 = alloca i64, align 8 %x2 = alloca i64, align 8
%x0a = bitcast i64* %x0 to i8* %x0a = bitcast i64* %x0 to i8*
%x2a = bitcast i64* %x2 to i8* %x2a = bitcast i64* %x2 to i8*
call void @llvm.lifetime.start(i64 4, i8* %x0a) call void @llvm.lifetime.start.p0i8(i64 4, i8* %x0a)
call void @capture64(i64* %x0) call void @capture64(i64* %x0)
call void @llvm.lifetime.end(i64 4, i8* %x0a) call void @llvm.lifetime.end.p0i8(i64 4, i8* %x0a)
call void @llvm.lifetime.start(i64 4, i8* %x1) call void @llvm.lifetime.start.p0i8(i64 4, i8* %x1)
call void @llvm.lifetime.start(i64 4, i8* %x2a) call void @llvm.lifetime.start.p0i8(i64 4, i8* %x2a)
call void @capture8(i8* %x1) call void @capture8(i8* %x1)
call void @capture64(i64* %x2) call void @capture64(i64* %x2)
call void @llvm.lifetime.end(i64 4, i8* %x1) call void @llvm.lifetime.end.p0i8(i64 4, i8* %x1)
call void @llvm.lifetime.end(i64 4, i8* %x2a) call void @llvm.lifetime.end.p0i8(i64 4, i8* %x2a)
; Test that i64 allocas share space. ; Test that i64 allocas share space.
; CHECK: getelementptr i8, i8* %unsafe_stack_ptr, i32 -8 ; CHECK: getelementptr i8, i8* %unsafe_stack_ptr, i32 -8
; CHECK: getelementptr i8, i8* %unsafe_stack_ptr, i32 -9 ; CHECK: getelementptr i8, i8* %unsafe_stack_ptr, i32 -9
; CHECK: getelementptr i8, i8* %unsafe_stack_ptr, i32 -8 ; CHECK: getelementptr i8, i8* %unsafe_stack_ptr, i32 -8
ret void ret void
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
declare void @capture8(i8*) declare void @capture8(i8*)
declare void @capture64(i64*) declare void @capture64(i64*)

test/Transforms/SampleProfile/remarks.ll

Show All 27 Lines
; CHECK: remark: remarks.cc:9:15: most popular destination for conditional branches at remarks.cc:6:9 ; CHECK: remark: remarks.cc:9:15: most popular destination for conditional branches at remarks.cc:6:9
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define i64 @_Z3foov() #0 !dbg !4 { define i64 @_Z3foov() #0 !dbg !4 {
entry: entry:
%sum = alloca i64, align 8 %sum = alloca i64, align 8
%i = alloca i32, align 4 %i = alloca i32, align 4
%0 = bitcast i64* %sum to i8*, !dbg !19 %0 = bitcast i64* %sum to i8*, !dbg !19
call void @llvm.lifetime.start(i64 8, i8* %0) #4, !dbg !19 call void @llvm.lifetime.start.p0i8(i64 8, i8* %0) #4, !dbg !19
call void @llvm.dbg.declare(metadata i64* %sum, metadata !9, metadata !20), !dbg !21 call void @llvm.dbg.declare(metadata i64* %sum, metadata !9, metadata !20), !dbg !21
store i64 0, i64* %sum, align 8, !dbg !21, !tbaa !22 store i64 0, i64* %sum, align 8, !dbg !21, !tbaa !22
%1 = bitcast i32* %i to i8*, !dbg !26 %1 = bitcast i32* %i to i8*, !dbg !26
call void @llvm.lifetime.start(i64 4, i8* %1) #4, !dbg !26 call void @llvm.lifetime.start.p0i8(i64 4, i8* %1) #4, !dbg !26
call void @llvm.dbg.declare(metadata i32* %i, metadata !10, metadata !20), !dbg !27 call void @llvm.dbg.declare(metadata i32* %i, metadata !10, metadata !20), !dbg !27
store i32 0, i32* %i, align 4, !dbg !27, !tbaa !28 store i32 0, i32* %i, align 4, !dbg !27, !tbaa !28
br label %for.cond, !dbg !26 br label %for.cond, !dbg !26
for.cond: ; preds = %for.inc, %entry for.cond: ; preds = %for.inc, %entry
%2 = load i32, i32* %i, align 4, !dbg !30, !tbaa !28 %2 = load i32, i32* %i, align 4, !dbg !30, !tbaa !28
%cmp = icmp slt i32 %2, 500000000, !dbg !34 %cmp = icmp slt i32 %2, 500000000, !dbg !34
br i1 %cmp, label %for.body, label %for.cond.cleanup, !dbg !35 br i1 %cmp, label %for.body, label %for.cond.cleanup, !dbg !35
for.cond.cleanup: ; preds = %for.cond for.cond.cleanup: ; preds = %for.cond
%3 = bitcast i32* %i to i8*, !dbg !36 %3 = bitcast i32* %i to i8*, !dbg !36
call void @llvm.lifetime.end(i64 4, i8* %3) #4, !dbg !36 call void @llvm.lifetime.end.p0i8(i64 4, i8* %3) #4, !dbg !36
br label %for.end br label %for.end
for.body: ; preds = %for.cond for.body: ; preds = %for.cond
%4 = load i32, i32* %i, align 4, !dbg !38, !tbaa !28 %4 = load i32, i32* %i, align 4, !dbg !38, !tbaa !28
%cmp1 = icmp slt i32 %4, 1000, !dbg !40 %cmp1 = icmp slt i32 %4, 1000, !dbg !40
br i1 %cmp1, label %if.then, label %if.else, !dbg !41 br i1 %cmp1, label %if.then, label %if.else, !dbg !41
if.then: ; preds = %for.body if.then: ; preds = %for.body
Show All 22 Linesfor.inc: ; preds = %if.end
%9 = load i32, i32* %i, align 4, !dbg !51, !tbaa !28 %9 = load i32, i32* %i, align 4, !dbg !51, !tbaa !28
%inc = add nsw i32 %9, 1, !dbg !51 %inc = add nsw i32 %9, 1, !dbg !51
store i32 %inc, i32* %i, align 4, !dbg !51, !tbaa !28 store i32 %inc, i32* %i, align 4, !dbg !51, !tbaa !28
br label %for.cond, !dbg !52 br label %for.cond, !dbg !52
for.end: ; preds = %for.cond.cleanup for.end: ; preds = %for.cond.cleanup
%10 = load i64, i64* %sum, align 8, !dbg !53, !tbaa !22 %10 = load i64, i64* %sum, align 8, !dbg !53, !tbaa !22
%11 = bitcast i64* %sum to i8*, !dbg !54 %11 = bitcast i64* %sum to i8*, !dbg !54
call void @llvm.lifetime.end(i64 8, i8* %11) #4, !dbg !54 call void @llvm.lifetime.end.p0i8(i64 8, i8* %11) #4, !dbg !54
ret i64 %10, !dbg !55 ret i64 %10, !dbg !55
} }
; Function Attrs: nounwind argmemonly ; Function Attrs: nounwind argmemonly
declare void @llvm.lifetime.start(i64, i8* nocapture) #1 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
; Function Attrs: nounwind readnone ; Function Attrs: nounwind readnone
declare void @llvm.dbg.declare(metadata, metadata, metadata) #2 declare void @llvm.dbg.declare(metadata, metadata, metadata) #2
; Function Attrs: nounwind ; Function Attrs: nounwind
declare i32 @rand() #3 declare i32 @rand() #3
; Function Attrs: nounwind argmemonly ; Function Attrs: nounwind argmemonly
declare void @llvm.lifetime.end(i64, i8* nocapture) #1 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define i32 @main() #0 !dbg !13 { define i32 @main() #0 !dbg !13 {
entry: entry:
%retval = alloca i32, align 4 %retval = alloca i32, align 4
store i32 0, i32* %retval, align 4 store i32 0, i32* %retval, align 4
%call = call i64 @_Z3foov(), !dbg !56 %call = call i64 @_Z3foov(), !dbg !56
%cmp = icmp sgt i64 %call, 0, !dbg !57 %cmp = icmp sgt i64 %call, 0, !dbg !57
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

test/Transforms/SimplifyCFG/critedge-assume.ll

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
while.end.loopexit: while.end.loopexit:
br label %while.end br label %while.end
while.end: while.end:
ret void ret void
} }
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare i32 @_ZNK1F5beginEv(%class.F*) declare i32 @_ZNK1F5beginEv(%class.F*)
declare i32 @_ZNK1F3endEv(%class.F*) declare i32 @_ZNK1F3endEv(%class.F*)
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32, i1) declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32, i1)
declare noalias nonnull i8* @_Znwm(i64) declare noalias nonnull i8* @_Znwm(i64)
declare void @_ZN1B6appendEv(%class.B*) declare void @_ZN1B6appendEv(%class.B*)
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
declare i1 @llvm.type.test(i8*, metadata) declare i1 @llvm.type.test(i8*, metadata)
declare void @llvm.assume(i1) declare void @llvm.assume(i1)
!llvm.module.flags = !{!0} !llvm.module.flags = !{!0}
!llvm.ident = !{!1} !llvm.ident = !{!1}
!0 = !{i32 1, !"PIC Level", i32 2} !0 = !{i32 1, !"PIC Level", i32 2}
!1 = !{!"clang version 5.0.0 "} !1 = !{!"clang version 5.0.0 "}

test/Transforms/SimplifyCFG/empty-cleanuppad.ll

Show First 20 Lines • Show All 407 Lines • ▼ Show 20 Lines
; CHECK: entry: ; CHECK: entry:
; CHECK: invoke void @"\01??1S2@@QEAA@XZ"( ; CHECK: invoke void @"\01??1S2@@QEAA@XZ"(
; CHECK-NOT: cleanuppad ; CHECK-NOT: cleanuppad
; CHECK: catch.dispatch: ; CHECK: catch.dispatch:
; CHECK: } ; CHECK: }
define i32 @f9() personality i32 (...)* @__CxxFrameHandler3 { define i32 @f9() personality i32 (...)* @__CxxFrameHandler3 {
entry: entry:
%s = alloca i8, align 1 %s = alloca i8, align 1
call void @llvm.lifetime.start(i64 1, i8* nonnull %s) call void @llvm.lifetime.start.p0i8(i64 1, i8* nonnull %s)
%bc = bitcast i8* %s to %struct.S2* %bc = bitcast i8* %s to %struct.S2*
invoke void @"\01??1S2@@QEAA@XZ"(%struct.S2* %bc) invoke void @"\01??1S2@@QEAA@XZ"(%struct.S2* %bc)
to label %try.cont unwind label %ehcleanup to label %try.cont unwind label %ehcleanup
ehcleanup: ehcleanup:
%cleanup.pad = cleanuppad within none [] %cleanup.pad = cleanuppad within none []
call void @llvm.lifetime.end(i64 1, i8* nonnull %s) call void @llvm.lifetime.end.p0i8(i64 1, i8* nonnull %s)
cleanupret from %cleanup.pad unwind label %catch.dispatch cleanupret from %cleanup.pad unwind label %catch.dispatch
catch.dispatch: catch.dispatch:
%catch.switch = catchswitch within none [label %catch] unwind to caller %catch.switch = catchswitch within none [label %catch] unwind to caller
catch: catch:
%catch.pad = catchpad within %catch.switch [i8* null, i32 0, i8* null] %catch.pad = catchpad within %catch.switch [i8* null, i32 0, i8* null]
catchret from %catch.pad to label %try.cont catchret from %catch.pad to label %try.cont
Show All 29 Lines
%struct.S = type { i8 } %struct.S = type { i8 }
%struct.S2 = type { i8 } %struct.S2 = type { i8 }
declare void @"\01??1S2@@QEAA@XZ"(%struct.S2*) declare void @"\01??1S2@@QEAA@XZ"(%struct.S2*)
declare void @g() declare void @g()
declare void @use_x(i32 %x) declare void @use_x(i32 %x)
declare i32 @__CxxFrameHandler3(...) declare i32 @__CxxFrameHandler3(...)
declare void @llvm.lifetime.start(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @llvm.lifetime.end(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)

test/Transforms/SimplifyCFG/lifetime.ll

; RUN: opt < %s -simplifycfg -S | FileCheck %s ; RUN: opt < %s -simplifycfg -S | FileCheck %s
; Test that a lifetime intrinsic isn't removed because that would change semantics ; Test that a lifetime intrinsic isn't removed because that would change semantics
; CHECK: foo ; CHECK: foo
; CHECK: entry: ; CHECK: entry:
; CHECK: bb0: ; CHECK: bb0:
; CHECK: bb1: ; CHECK: bb1:
; CHECK: ret ; CHECK: ret
define void @foo(i1 %x) { define void @foo(i1 %x) {
entry: entry:
%a = alloca i8 %a = alloca i8
call void @llvm.lifetime.start(i64 -1, i8* %a) nounwind call void @llvm.lifetime.start.p0i8(i64 -1, i8* %a) nounwind
br i1 %x, label %bb0, label %bb1 br i1 %x, label %bb0, label %bb1
bb0: bb0:
call void @llvm.lifetime.end(i64 -1, i8* %a) nounwind call void @llvm.lifetime.end.p0i8(i64 -1, i8* %a) nounwind
br label %bb1 br label %bb1
bb1: bb1:
call void @f() call void @f()
ret void ret void
} }
declare void @f() declare void @f()
declare void @llvm.lifetime.start(i64, i8* nocapture) nounwind declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) nounwind declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) nounwind

test/Transforms/Util/MemorySSA/lifetime-simple.ll

; RUN: opt -basicaa -print-memoryssa -verify-memoryssa -analyze < %s 2>&1 | FileCheck %s ; RUN: opt -basicaa -print-memoryssa -verify-memoryssa -analyze < %s 2>&1 | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -disable-output < %s 2>&1 | FileCheck %s
; This test checks a number of things: ; This test checks a number of things:
; First, the lifetime markers should not clobber any uses of Q or P. ; First, the lifetime markers should not clobber any uses of Q or P.
; Second, the loads of P are MemoryUse(LiveOnEntry) due to the placement of the markers vs the loads. ; Second, the loads of P are MemoryUse(LiveOnEntry) due to the placement of the markers vs the loads.
define i8 @test(i8* %P, i8* %Q) { define i8 @test(i8* %P, i8* %Q) {
entry: entry:
; CHECK: 1 = MemoryDef(liveOnEntry) ; CHECK: 1 = MemoryDef(liveOnEntry)
; CHECK-NEXT: call void @llvm.lifetime.start(i64 32, i8* %P) ; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 32, i8* %P)
call void @llvm.lifetime.start(i64 32, i8* %P) call void @llvm.lifetime.start.p0i8(i64 32, i8* %P)
; CHECK: MemoryUse(liveOnEntry) ; CHECK: MemoryUse(liveOnEntry)
; CHECK-NEXT: %0 = load i8, i8* %P ; CHECK-NEXT: %0 = load i8, i8* %P
%0 = load i8, i8* %P %0 = load i8, i8* %P
; CHECK: 2 = MemoryDef(1) ; CHECK: 2 = MemoryDef(1)
; CHECK-NEXT: store i8 1, i8* %P ; CHECK-NEXT: store i8 1, i8* %P
store i8 1, i8* %P store i8 1, i8* %P
; CHECK: 3 = MemoryDef(2) ; CHECK: 3 = MemoryDef(2)
; CHECK-NEXT: call void @llvm.lifetime.end(i64 32, i8* %P) ; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 32, i8* %P)
call void @llvm.lifetime.end(i64 32, i8* %P) call void @llvm.lifetime.end.p0i8(i64 32, i8* %P)
; CHECK: MemoryUse(liveOnEntry) ; CHECK: MemoryUse(liveOnEntry)
; CHECK-NEXT: %1 = load i8, i8* %P ; CHECK-NEXT: %1 = load i8, i8* %P
%1 = load i8, i8* %P %1 = load i8, i8* %P
; CHECK: MemoryUse(2) ; CHECK: MemoryUse(2)
; CHECK-NEXT: %2 = load i8, i8* %Q ; CHECK-NEXT: %2 = load i8, i8* %Q
%2 = load i8, i8* %Q %2 = load i8, i8* %Q
ret i8 %1 ret i8 %1
} }
declare void @llvm.lifetime.start(i64 %S, i8* nocapture %P) readonly declare void @llvm.lifetime.start.p0i8(i64 %S, i8* nocapture %P) readonly
declare void @llvm.lifetime.end(i64 %S, i8* nocapture %P) declare void @llvm.lifetime.end.p0i8(i64 %S, i8* nocapture %P)