This is an archive of the discontinued LLVM Phabricator instance.

Differential D9870

Support memory markers for nonzero address spaces
Needs ReviewPublic

Authored by johngarvin on May 19 2015, 11:00 PM.

Details

Reviewers
majnemer
resistor
Summary

It would be very helpful to support memory usage markers for address spaces other than zero.

Diff Detail

Event Timeline

johngarvin updated this revision to Diff 26121.May 19 2015, 11:00 PM
johngarvin retitled this revision from to Support memory markers for nonzero address spaces.
johngarvin updated this object.
johngarvin edited the test plan for this revision. (Show Details)
Herald added a subscriber: jholewinski. · View Herald TranscriptMay 19 2015, 11:00 PM
johngarvin added a reviewer: majnemer.May 19 2015, 11:02 PM
johngarvin added a subscriber: Unknown Object (MLST).
johngarvin added a comment.May 19 2015, 11:16 PM

This should be considered together with clang patch http://reviews.llvm.org/D9871 .

johngarvin added a reviewer: resistor.May 20 2015, 8:55 PM
johngarvin added a comment.May 26 2015, 2:28 PM

Ping

John

Revision Contents

PathSize
include/
llvm/
IR/
8 lines
lib/
IR/
64 lines
6 lines
test/
Analysis/
BasicAA/
8 lines
Assembler/
26 lines
CodeGen/
AArch64/
8 lines
ARM/
8 lines
8 lines
Hexagon/
12 lines
12 lines
Mips/
8 lines
12 lines
NVPTX/
8 lines
PowerPC/
8 lines
16 lines
28 lines
Thumb/
16 lines
10 lines
8 lines
Thumb2/
8 lines
WinEH/
10 lines
2 lines
X86/
8 lines
150 lines
4 lines
12 lines
4 lines
4 lines
8 lines
8 lines
8 lines
8 lines
DebugInfo/
AArch64/
12 lines
X86/
8 lines
8 lines
8 lines
Feature/
16 lines
38 lines
Instrumentation/
AddressSanitizer/
12 lines
30 lines
Transforms/
BBVectorize/
X86/
16 lines
DeadStoreElimination/
6 lines
10 lines
GVN/
8 lines
8 lines
GlobalOpt/
4 lines
10 lines
Inline/
8 lines
2 lines
2 lines
4 lines
4 lines
42 lines
InstCombine/
8 lines
8 lines
8 lines
4 lines
LoopVectorize/
36 lines
Mem2Reg/
12 lines
MemCpyOpt/
12 lines
6 lines
SROA/
16 lines
8 lines
ScalarRepl/
16 lines
SimplifyCFG/
8 lines

Diff 26121

include/llvm/IR/Intrinsics.td

Show First 20 Lines • Show All 488 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],
[IntrReadWriteArgMem, NoCapture<1>]>; [IntrReadWriteArgMem, NoCapture<1>]>;
def int_lifetime_end : Intrinsic<[], def int_lifetime_end : Intrinsic<[],
[llvm_i64_ty, llvm_ptr_ty], [llvm_i64_ty, llvm_anyptr_ty],
[IntrReadWriteArgMem, NoCapture<1>]>; [IntrReadWriteArgMem, NoCapture<1>]>;
def int_invariant_start : Intrinsic<[llvm_descriptor_ty], def int_invariant_start : Intrinsic<[llvm_descriptor_ty],
[llvm_i64_ty, llvm_ptr_ty], [llvm_i64_ty, llvm_anyptr_ty],
[IntrReadWriteArgMem, NoCapture<1>]>; [IntrReadWriteArgMem, 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_ptr_ty], llvm_anyptr_ty],
[IntrReadWriteArgMem, NoCapture<2>]>; [IntrReadWriteArgMem, NoCapture<2>]>;
//===------------------------ Stackmap Intrinsics -------------------------===// //===------------------------ Stackmap Intrinsics -------------------------===//
// //
def int_experimental_stackmap : Intrinsic<[], def int_experimental_stackmap : Intrinsic<[],
[llvm_i64_ty, llvm_i32_ty, llvm_vararg_ty], [llvm_i64_ty, llvm_i32_ty, llvm_vararg_ty],
[Throws]>; [Throws]>;
def int_experimental_patchpoint_void : Intrinsic<[], def int_experimental_patchpoint_void : Intrinsic<[],
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

lib/IR/AutoUpgrade.cpp

Show First 20 Lines • Show All 104 Lines • ▼ Show 20 Lines if (Name.startswith("cttz.") && F->arg_size() == 1) {
F->setName(Name + ".old"); F->setName(Name + ".old");
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': {
if (Name == "invariant.start") {
F->setName(Name + ".old");
NewFn = Intrinsic::getDeclaration(F->getParent(),
Intrinsic::invariant_start,
F->getFunctionType()->getParamType(1));
return true;
}
if (Name == "invariant.end") {
F->setName(Name + ".old");
NewFn = Intrinsic::getDeclaration(F->getParent(),
Intrinsic::invariant_end,
F->getFunctionType()->getParamType(2));
return true;
}
break;
}
case 'l': {
if (Name == "lifetime.start") {
F->setName(Name + ".old");
NewFn = Intrinsic::getDeclaration(F->getParent(),
Intrinsic::lifetime_start,
F->getFunctionType()->getParamType(1));
return true;
}
if (Name == "lifetime.end") {
F->setName(Name + ".old");
NewFn = Intrinsic::getDeclaration(F->getParent(),
Intrinsic::lifetime_end,
F->getFunctionType()->getParamType(1));
return true;
}
break;
}
case 'o': case 'o':
// We only need to change the name to match the mangling including the // We only need to change the name to match the mangling including the
// address space. // address space.
if (F->arg_size() == 2 && Name.startswith("objectsize.")) { if (F->arg_size() == 2 && Name.startswith("objectsize.")) {
Type *Tys[2] = { F->getReturnType(), F->arg_begin()->getType() }; Type *Tys[2] = { F->getReturnType(), F->arg_begin()->getType() };
if (F->getName() != Intrinsic::getName(Intrinsic::objectsize, Tys)) { if (F->getName() != Intrinsic::getName(Intrinsic::objectsize, Tys)) {
F->setName(Name + ".old"); F->setName(Name + ".old");
NewFn = Intrinsic::getDeclaration(F->getParent(), NewFn = Intrinsic::getDeclaration(F->getParent(),
▲ Show 20 Lines • Show All 509 Lines • ▼ Show 20 Linesvoid llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) {
case Intrinsic::cttz: case Intrinsic::cttz:
assert(CI->getNumArgOperands() == 1 && assert(CI->getNumArgOperands() == 1 &&
"Mismatch between function args and call args"); "Mismatch between function args and call args");
CI->replaceAllUsesWith(Builder.CreateCall2(NewFn, CI->getArgOperand(0), CI->replaceAllUsesWith(Builder.CreateCall2(NewFn, CI->getArgOperand(0),
Builder.getFalse(), Name)); Builder.getFalse(), Name));
CI->eraseFromParent(); CI->eraseFromParent();
return; return;
case Intrinsic::invariant_start:
CI->replaceAllUsesWith(Builder.CreateCall2(NewFn,
CI->getArgOperand(0),
CI->getArgOperand(1),
Name));
CI->eraseFromParent();
return;
case Intrinsic::invariant_end:
CI->replaceAllUsesWith(Builder.CreateCall3(NewFn,
CI->getArgOperand(0),
CI->getArgOperand(1),
CI->getArgOperand(2),
Name));
CI->eraseFromParent();
return;
case Intrinsic::lifetime_start:
CI->replaceAllUsesWith(Builder.CreateCall2(NewFn,
CI->getArgOperand(0),
CI->getArgOperand(1),
Name));
CI->eraseFromParent();
return;
case Intrinsic::lifetime_end:
CI->replaceAllUsesWith(Builder.CreateCall2(NewFn,
CI->getArgOperand(0),
CI->getArgOperand(1),
Name));
CI->eraseFromParent();
return;
case Intrinsic::objectsize: case Intrinsic::objectsize:
CI->replaceAllUsesWith(Builder.CreateCall2(NewFn, CI->replaceAllUsesWith(Builder.CreateCall2(NewFn,
CI->getArgOperand(0), CI->getArgOperand(0),
CI->getArgOperand(1), CI->getArgOperand(1),
Name)); Name));
CI->eraseFromParent(); CI->eraseFromParent();
return; return;
▲ Show 20 Lines • Show All 173 Lines • Show Last 20 Lines

lib/IR/IRBuilder.cpp

Show First 20 Lines • Show All 164 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::CreateAssumption(Value *Cond) { CallInst *IRBuilderBase::CreateAssumption(Value *Cond) {
assert(Cond->getType() == getInt1Ty() && assert(Cond->getType() == getInt1Ty() &&
"an assumption condition must be of type i1"); "an assumption condition must be of type i1");
Value *Ops[] = { Cond }; Value *Ops[] = { Cond };
▲ Show 20 Lines • Show All 162 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.p0i8
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 59 Lines • Show Last 20 Lines

test/Assembler/auto_upgrade_intrinsics.ll

; Test to make sure intrinsics are automatically upgraded. ; Test to make sure intrinsics are automatically upgraded.
; RUN: llvm-as < %s | llvm-dis | FileCheck %s ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
; RUN: verify-uselistorder %s ; RUN: verify-uselistorder %s
declare i8 @llvm.ctlz.i8(i8) declare i8 @llvm.ctlz.i8(i8)
declare i16 @llvm.ctlz.i16(i16) declare i16 @llvm.ctlz.i16(i16)
declare i32 @llvm.ctlz.i32(i32) declare i32 @llvm.ctlz.i32(i32)
declare i42 @llvm.ctlz.i42(i42) ; Not a power-of-2 declare i42 @llvm.ctlz.i42(i42) ; Not a power-of-2
declare i32 @llvm.objectsize.i32(i8*, i1) nounwind readonly declare i32 @llvm.objectsize.i32(i8*, i1) nounwind readonly
declare void @llvm.lifetime.start(i64, i8* nocapture) nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) nounwind
declare {}* @llvm.invariant.start(i64, i8* nocapture) readonly nounwind
declare void @llvm.invariant.end({}*, i64, i8* nocapture) nounwind
define void @test.ctlz(i8 %a, i16 %b, i32 %c, i42 %d) { define void @test.ctlz(i8 %a, i16 %b, i32 %c, i42 %d) {
; CHECK: @test.ctlz ; CHECK: @test.ctlz
entry: entry:
; CHECK: call i8 @llvm.ctlz.i8(i8 %a, i1 false) ; CHECK: call i8 @llvm.ctlz.i8(i8 %a, i1 false)
call i8 @llvm.ctlz.i8(i8 %a) call i8 @llvm.ctlz.i8(i8 %a)
; CHECK: call i16 @llvm.ctlz.i16(i16 %b, i1 false) ; CHECK: call i16 @llvm.ctlz.i16(i16 %b, i1 false)
Show All 28 Lines
} }
@a = private global [60 x i8] zeroinitializer, align 1 @a = private global [60 x i8] zeroinitializer, align 1
define i32 @test.objectsize() { define i32 @test.objectsize() {
; CHECK-LABEL: @test.objectsize( ; CHECK-LABEL: @test.objectsize(
; CHECK: @llvm.objectsize.i32.p0i8 ; CHECK: @llvm.objectsize.i32.p0i8
; CHECK-DAG: declare i32 @llvm.objectsize.i32.p0i8
%s = call i32 @llvm.objectsize.i32(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i1 false) %s = call i32 @llvm.objectsize.i32(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i1 false)
ret i32 %s ret i32 %s
} }
define void @test.memorymarkers() {
; CHECK-LABEL: @test.memorymarkers(
%y = alloca i8
call void @llvm.lifetime.start(i64 8, i8* %y)
; CHECK: @llvm.lifetime.start.p0i8(
%inv = call {}* @llvm.invariant.start(i64 8, i8* %y)
; CHECK: @llvm.invariant.start.p0i8(
call void @llvm.invariant.end({}* %inv, i64 8, i8* %y)
; CHECK: @llvm.invariant.end.p0i8(
call void @llvm.lifetime.end(i64 8, i8* %y)
; CHECK: @llvm.lifetime.end.p0i8(
ret void
}
; CHECK-DAG: declare void @llvm.lifetime.start.p0i8(
; CHECK-DAG: declare {}* @llvm.invariant.start.p0i8(
; CHECK-DAG: declare void @llvm.invariant.end.p0i8(
; CHECK-DAG: declare void @llvm.lifetime.end.p0i8(
; CHECK-DAG: declare i32 @llvm.objectsize.i32.p0i8

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/ARM/ldrd.ll

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Lines
; CHECK: @Func1 ; CHECK: @Func1
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]]{{\]}}
%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 @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/Hexagon/calling-conv.ll

Show All 17 Lines
entry: entry:
%a.addr = alloca i32, align 4 %a.addr = alloca i32, align 4
%c.addr = alloca i8, align 1 %c.addr = alloca i8, align 1
%z = alloca i32, align 4 %z = alloca i32, align 4
%ret = alloca %struct.test_struct, align 8 %ret = alloca %struct.test_struct, align 8
store i32 %a, i32* %a.addr, align 4 store i32 %a, i32* %a.addr, align 4
store i8 %c, i8* %c.addr, align 1 store i8 %c, i8* %c.addr, align 1
%0 = bitcast i32* %z to i8* %0 = bitcast i32* %z to i8*
call void @llvm.lifetime.start(i64 4, i8* %0) #1 call void @llvm.lifetime.start.p0i8(i64 4, i8* %0) #1
store i32 45, i32* %z, align 4 store i32 45, i32* %z, align 4
%1 = bitcast %struct.test_struct* %ret to i8* %1 = bitcast %struct.test_struct* %ret to i8*
call void @llvm.lifetime.start(i64 16, i8* %1) #1 call void @llvm.lifetime.start.p0i8(i64 16, i8* %1) #1
%2 = load i32, i32* %z, align 4 %2 = load i32, i32* %z, align 4
%3 = load %struct.test_struct*, %struct.test_struct** @mystruct, align 4 %3 = load %struct.test_struct*, %struct.test_struct** @mystruct, align 4
%4 = load %struct.test_struct*, %struct.test_struct** @mystruct, align 4 %4 = load %struct.test_struct*, %struct.test_struct** @mystruct, align 4
%5 = load i8, i8* %c.addr, align 1 %5 = load i8, i8* %c.addr, align 1
%6 = load i32, i32* %a.addr, align 4 %6 = load i32, i32* %a.addr, align 4
%conv = sext i32 %6 to i64 %conv = sext i32 %6 to i64
%add = add nsw i64 %conv, 1 %add = add nsw i64 %conv, 1
%7 = load i32, i32* %a.addr, align 4 %7 = load i32, i32* %a.addr, align 4
%add1 = add nsw i32 %7, 2 %add1 = add nsw i32 %7, 2
%8 = load i32, i32* %a.addr, align 4 %8 = load i32, i32* %a.addr, align 4
%conv2 = sext i32 %8 to i64 %conv2 = sext i32 %8 to i64
%add3 = add nsw i64 %conv2, 3 %add3 = add nsw i64 %conv2, 3
%9 = load i8, i8* %c.addr, align 1 %9 = load i8, i8* %c.addr, align 1
%10 = load i8, i8* %c.addr, align 1 %10 = load i8, i8* %c.addr, align 1
%11 = load i8, i8* %c.addr, align 1 %11 = load i8, i8* %c.addr, align 1
%12 = load i32, i32* %z, align 4 %12 = load i32, i32* %z, align 4
call void @bar(%struct.test_struct* sret %ret, i32 %2, %struct.test_struct* byval %3, %struct.test_struct* byval %4, i8 zeroext %5, i64 %add, i32 %add1, i64 %add3, i8 zeroext %9, i8 zeroext %10, i8 zeroext %11, i32 %12) call void @bar(%struct.test_struct* sret %ret, i32 %2, %struct.test_struct* byval %3, %struct.test_struct* byval %4, i8 zeroext %5, i64 %add, i32 %add1, i64 %add3, i8 zeroext %9, i8 zeroext %10, i8 zeroext %11, i32 %12)
%x = getelementptr inbounds %struct.test_struct, %struct.test_struct* %ret, i32 0, i32 0 %x = getelementptr inbounds %struct.test_struct, %struct.test_struct* %ret, i32 0, i32 0
store i32 20, i32* %x, align 4 store i32 20, i32* %x, align 4
%13 = bitcast %struct.test_struct* %agg.result to i8* %13 = bitcast %struct.test_struct* %agg.result to i8*
%14 = bitcast %struct.test_struct* %ret to i8* %14 = bitcast %struct.test_struct* %ret to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* %13, i8* %14, i32 16, i32 8, i1 false) call void @llvm.memcpy.p0i8.p0i8.i32(i8* %13, i8* %14, i32 16, i32 8, i1 false)
%15 = bitcast %struct.test_struct* %ret to i8* %15 = bitcast %struct.test_struct* %ret to i8*
call void @llvm.lifetime.end(i64 16, i8* %15) #1 call void @llvm.lifetime.end.p0i8(i64 16, i8* %15) #1
%16 = bitcast i32* %z to i8* %16 = bitcast i32* %z to i8*
call void @llvm.lifetime.end(i64 4, i8* %16) #1 call void @llvm.lifetime.end.p0i8(i64 4, i8* %16) #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 void @bar(%struct.test_struct* sret, i32, %struct.test_struct* byval, %struct.test_struct* byval, i8 zeroext, i64, i32, i64, i8 zeroext, i8 zeroext, i8 zeroext, i32) #2 declare void @bar(%struct.test_struct* sret, i32, %struct.test_struct* byval, %struct.test_struct* byval, i8 zeroext, i64, i32, i64, i8 zeroext, i8 zeroext, i8 zeroext, i32) #2
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture readonly, i32, i32, i1) #1 declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture readonly, i32, i32, i1) #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
attributes #0 = { nounwind "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"="hexagonv4" "unsafe-fp-math"="false" "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"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="hexagonv4" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { nounwind } attributes #1 = { nounwind }
attributes #2 = { "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"="hexagonv4" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #2 = { "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"="hexagonv4" "unsafe-fp-math"="false" "use-soft-float"="false" }

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: loop0(.LBB{{.}}_{{.}}, #100) ; CHECK: loop0(.LBB{{.}}_{{.}}, #100)
; CHECK: endloop0 ; CHECK: endloop0
; 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/Mips/stackcoloring.ll

; RUN: llc -march=mipsel < %s | FileCheck %s ; RUN: llc -march=mipsel < %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 First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
; 16_h: lh ${{[0-9]+}}, [[offset2]](${{[0-9]+}}) ; 16_h: lh ${{[0-9]+}}, [[offset2]](${{[0-9]+}})
} }
define i32 @main() nounwind { define i32 @main() nounwind {
entry: entry:
%s.i = alloca i16, align 4 %s.i = alloca i16, align 4
%c.i = alloca i8, align 4 %c.i = alloca i8, align 4
%0 = bitcast i16* %s.i to i8* %0 = bitcast i16* %s.i to i8*
call void @llvm.lifetime.start(i64 -1, i8* %0) nounwind call void @llvm.lifetime.start.p0i8(i64 -1, i8* %0) nounwind
call void @llvm.lifetime.start(i64 -1, i8* %c.i) nounwind call void @llvm.lifetime.start.p0i8(i64 -1, i8* %c.i) nounwind
store i16 16, i16* %s.i, align 4 store i16 16, i16* %s.i, align 4
store i8 99, i8* %c.i, align 4 store i8 99, i8* %c.i, align 4
store i16* %s.i, i16** @sp, align 4 store i16* %s.i, i16** @sp, align 4
store i8* %c.i, i8** @cp, align 4 store i8* %c.i, i8** @cp, align 4
%call.i.i.i = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i32 0, i32 0), i32 16, i32 99) nounwind %call.i.i.i = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i32 0, i32 0), i32 16, i32 99) nounwind
%1 = load i16*, i16** @sp, align 4 %1 = load i16*, i16** @sp, align 4
store i16 32, i16* %1, align 2 store i16 32, i16* %1, align 2
%2 = load i8*, i8** @cp, align 4 %2 = load i8*, i8** @cp, align 4
store i8 97, i8* %2, align 1 store i8 97, i8* %2, align 1
%3 = load i16, i16* %s.i, align 4 %3 = load i16, i16* %s.i, align 4
%4 = load i8, i8* %c.i, align 4 %4 = load i8, i8* %c.i, align 4
%conv.i.i = sext i16 %3 to i32 %conv.i.i = sext i16 %3 to i32
%conv1.i.i = sext i8 %4 to i32 %conv1.i.i = sext i8 %4 to i32
%call.i.i = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i32 0, i32 0), i32 %conv.i.i, i32 %conv1.i.i) nounwind %call.i.i = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i32 0, i32 0), i32 %conv.i.i, i32 %conv1.i.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* %c.i) nounwind call void @llvm.lifetime.end.p0i8(i64 -1, i8* %c.i) nounwind
ret i32 0 ret i32 0
} }
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.ptx.read.ctaid.x() %0 = tail call i32 @llvm.ptx.read.ctaid.x()
%1 = tail call i32 @llvm.ptx.read.ntid.x() %1 = tail call i32 @llvm.ptx.read.ntid.x()
%2 = mul nsw i32 %1, %0 %2 = mul nsw i32 %1, %0
%3 = tail call i32 @llvm.ptx.read.tid.x() %3 = tail call i32 @llvm.ptx.read.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: setp.lt.f32 %p{{[0-9]+}}, %f{{[0-9]+}}, 0f00000000 ; CHECK: setp.lt.f32 %p{{[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.ptx.read.ctaid.x() #1 declare i32 @llvm.ptx.read.ctaid.x() #1
; Function Attrs: nounwind readnone ; Function Attrs: nounwind readnone
declare i32 @llvm.ptx.read.ntid.x() #1 declare i32 @llvm.ptx.read.ntid.x() #1
; Function Attrs: nounwind readnone ; Function Attrs: nounwind readnone
declare i32 @llvm.ptx.read.tid.x() #1 declare i32 @llvm.ptx.read.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/addi-licm.ll

; RUN: llc -mcpu=pwr7 -disable-ppc-preinc-prep < %s | FileCheck %s ; RUN: llc -mcpu=pwr7 -disable-ppc-preinc-prep < %s | FileCheck %s
; RUN: llc -mcpu=pwr7 < %s | FileCheck %s -check-prefix=PIP ; RUN: llc -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/lsa.ll

; RUN: llc < %s -mtriple=powerpc64-unknown-linux-gnu -mcpu=ppc64 | FileCheck %s ; RUN: llc < %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/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/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/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/WinEH/cppeh-nonalloca-frame-values.ll

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines
; CHECK: [[I_REGMEM:\%.+]] = alloca i32 ; CHECK: [[I_REGMEM:\%.+]] = alloca i32
; CHECK: [[B_REGMEM:\%.+]] = alloca i32* ; CHECK: [[B_REGMEM:\%.+]] = alloca i32*
; CHECK: [[A_REGMEM:\%.+]] = alloca i32* ; CHECK: [[A_REGMEM:\%.+]] = alloca i32*
; CHECK: [[E_PTR:\%.+]] = alloca i32, align 4 ; CHECK: [[E_PTR:\%.+]] = alloca i32, align 4
; CHECK: [[EXCEPTIONVAL:\%.+]] = alloca [10 x i32], align 16 ; CHECK: [[EXCEPTIONVAL:\%.+]] = alloca [10 x i32], align 16
; CHECK: [[DATA_PTR:\%.+]] = alloca i64, align 8 ; CHECK: [[DATA_PTR:\%.+]] = alloca i64, align 8
; CHECK: [[TMPCAST:\%.+]] = bitcast i64* [[DATA_PTR]] to %struct.SomeData* ; CHECK: [[TMPCAST:\%.+]] = bitcast i64* [[DATA_PTR]] to %struct.SomeData*
; CHECK: [[TMP:\%.+]] = bitcast [10 x i32]* [[EXCEPTIONVAL]] to i8* ; CHECK: [[TMP:\%.+]] = bitcast [10 x i32]* [[EXCEPTIONVAL]] to i8*
; CHECK: call void @llvm.lifetime.start(i64 40, i8* [[TMP]]) ; CHECK: call void @llvm.lifetime.start.p0i8(i64 40, i8* [[TMP]])
; CHECK: store i64 0, i64* [[DATA_PTR]], align 8 ; CHECK: store i64 0, i64* [[DATA_PTR]], align 8
; CHECK: [[A_PTR:\%.+]] = bitcast i64* [[DATA_PTR]] to i32* ; CHECK: [[A_PTR:\%.+]] = bitcast i64* [[DATA_PTR]] to i32*
; CHECK: store i32* [[A_PTR]], i32** [[A_REGMEM]] ; CHECK: store i32* [[A_PTR]], i32** [[A_REGMEM]]
; CHECK: [[B_PTR:\%.+]] = getelementptr inbounds %struct.SomeData, %struct.SomeData* [[TMPCAST]], i64 0, i32 1 ; CHECK: [[B_PTR:\%.+]] = getelementptr inbounds %struct.SomeData, %struct.SomeData* [[TMPCAST]], i64 0, i32 1
; CHECK: store i32* [[B_PTR]], i32** [[B_REGMEM]] ; CHECK: store i32* [[B_PTR]], i32** [[B_REGMEM]]
; CHECK: call void (...) @llvm.frameescape(i32* %e, i32* %NumExceptions.020.reg2mem, [10 x i32]* [[EXCEPTIONVAL]], i32* %inc.reg2mem, i32* [[I_REGMEM]], i32** [[A_REGMEM]], i32** [[B_REGMEM]]) ; CHECK: call void (...) @llvm.frameescape(i32* %e, i32* %NumExceptions.020.reg2mem, [10 x i32]* [[EXCEPTIONVAL]], i32* %inc.reg2mem, i32* [[I_REGMEM]], i32** [[A_REGMEM]], i32** [[B_REGMEM]])
; CHECK: br label %for.body ; CHECK: br label %for.body
; Function Attrs: uwtable ; Function Attrs: uwtable
define void @"\01?test@@YAXXZ"() #0 { define void @"\01?test@@YAXXZ"() #0 {
entry: entry:
%e = alloca i32, align 4 %e = alloca i32, align 4
%ExceptionVal = alloca [10 x i32], align 16 %ExceptionVal = alloca [10 x i32], align 16
%Data = alloca i64, align 8 %Data = alloca i64, align 8
%tmpcast = bitcast i64* %Data to %struct.SomeData* %tmpcast = bitcast i64* %Data to %struct.SomeData*
%0 = bitcast [10 x i32]* %ExceptionVal to i8* %0 = bitcast [10 x i32]* %ExceptionVal to i8*
call void @llvm.lifetime.start(i64 40, i8* %0) #1 call void @llvm.lifetime.start.p0i8(i64 40, i8* %0) #1
store i64 0, i64* %Data, align 8 store i64 0, i64* %Data, align 8
%a = bitcast i64* %Data to i32* %a = bitcast i64* %Data to i32*
%b = getelementptr inbounds %struct.SomeData, %struct.SomeData* %tmpcast, i64 0, i32 1 %b = getelementptr inbounds %struct.SomeData, %struct.SomeData* %tmpcast, i64 0, i32 1
br label %for.body br label %for.body
; CHECK: for.body: ; CHECK: for.body:
; CHECK: [[NUMEXCEPTIONS_PHI:\%.*]] = phi i32 [ 0, %entry ], [ {{\%NumExceptions.*}}, %try.cont ] ; CHECK: [[NUMEXCEPTIONS_PHI:\%.*]] = phi i32 [ 0, %entry ], [ {{\%NumExceptions.*}}, %try.cont ]
; CHECK: [[I_PHI:\%.*]] = phi i32 [ 0, %entry ], [ {{\%inc.*}}, %try.cont ] ; CHECK: [[I_PHI:\%.*]] = phi i32 [ 0, %entry ], [ {{\%inc.*}}, %try.cont ]
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Linestry.cont: ; preds = %if.end, %invoke.cont
%inc5 = add nuw nsw i32 %i.019, 1 %inc5 = add nuw nsw i32 %i.019, 1
%cmp = icmp slt i32 %inc5, 10 %cmp = icmp slt i32 %inc5, 10
br i1 %cmp, label %for.body, label %for.end br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %try.cont for.end: ; preds = %try.cont
%NumExceptions.1.lcssa = phi i32 [ %NumExceptions.1, %try.cont ] %NumExceptions.1.lcssa = phi i32 [ %NumExceptions.1, %try.cont ]
%arraydecay = getelementptr inbounds [10 x i32], [10 x i32]* %ExceptionVal, i64 0, i64 0 %arraydecay = getelementptr inbounds [10 x i32], [10 x i32]* %ExceptionVal, i64 0, i64 0
call void @"\01?dump@@YAXPEAHHAEAUSomeData@@@Z"(i32* %arraydecay, i32 %NumExceptions.1.lcssa, %struct.SomeData* dereferenceable(8) %tmpcast) call void @"\01?dump@@YAXPEAHHAEAUSomeData@@@Z"(i32* %arraydecay, i32 %NumExceptions.1.lcssa, %struct.SomeData* dereferenceable(8) %tmpcast)
call void @llvm.lifetime.end(i64 40, i8* %0) #1 call void @llvm.lifetime.end.p0i8(i64 40, i8* %0) #1
ret void ret void
eh.resume: ; preds = %lpad eh.resume: ; preds = %lpad
%.lcssa = phi { i8*, i32 } [ %2, %lpad ] %.lcssa = phi { i8*, i32 } [ %2, %lpad ]
resume { i8*, i32 } %.lcssa resume { i8*, i32 } %.lcssa
} }
; The following catch handler should be outlined. ; The following catch handler should be outlined.
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
; CHECK: store i32 [[ADD2]], i32* [[A_RELOAD]], align 8 ; CHECK: store i32 [[ADD2]], i32* [[A_RELOAD]], align 8
; CHECK: br label %if.end ; CHECK: br label %if.end
; ;
; CHECK: if.end:{{[ ]+}}; preds = %if.else, %if.then ; CHECK: if.end:{{[ ]+}}; preds = %if.else, %if.then
; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ", %[[SPLIT_RECOVER_BB]]) ; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ", %[[SPLIT_RECOVER_BB]])
; CHECK: } ; CHECK: }
; 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 void @"\01?may_throw@@YAXXZ"() #2 declare void @"\01?may_throw@@YAXXZ"() #2
declare i32 @__CxxFrameHandler3(...) declare i32 @__CxxFrameHandler3(...)
; Function Attrs: nounwind readnone ; Function Attrs: nounwind readnone
declare i32 @llvm.eh.typeid.for(i8*) #3 declare i32 @llvm.eh.typeid.for(i8*) #3
declare void @llvm.eh.begincatch(i8*, i8*) declare void @llvm.eh.begincatch(i8*, i8*)
declare void @llvm.eh.endcatch() declare void @llvm.eh.endcatch()
declare void @"\01?does_not_throw@@YAXH@Z"(i32) #2 declare void @"\01?does_not_throw@@YAXH@Z"(i32) #2
declare void @"\01?dump@@YAXPEAHHAEAUSomeData@@@Z"(i32*, i32, %struct.SomeData* dereferenceable(8)) #2 declare void @"\01?dump@@YAXPEAHHAEAUSomeData@@@Z"(i32*, i32, %struct.SomeData* dereferenceable(8)) #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
attributes #0 = { uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="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 = { uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="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 = { "less-precise-fpmad"="false" "no-frame-pointer-elim"="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 = { "less-precise-fpmad"="false" "no-frame-pointer-elim"="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 readnone } attributes #3 = { nounwind readnone }
!llvm.module.flags = !{!0} !llvm.module.flags = !{!0}
!llvm.ident = !{!1} !llvm.ident = !{!1}
Show All 10 Lines

test/CodeGen/WinEH/cppeh-prepared-catch-reordered.ll

Show First 20 Lines • Show All 79 Lines • ▼ Show 20 Lines
; Function Attrs: nounwind ; Function Attrs: nounwind
declare i32 @printf(i8* nocapture readonly, ...) #4 declare i32 @printf(i8* nocapture readonly, ...) #4
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.eh.endcatch() #3 declare void @llvm.eh.endcatch() #3
; 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 i8* @llvm.eh.actions(...) #3 declare i8* @llvm.eh.actions(...) #3
define internal i8* @main.catch(i8*, i8*) #5 { define internal i8* @main.catch(i8*, i8*) #5 {
entry: entry:
%e.i8 = call i8* @llvm.framerecover(i8* bitcast (i32 ()* @main to i8*), i8* %1, i32 0) %e.i8 = call i8* @llvm.framerecover(i8* bitcast (i32 ()* @main to i8*), i8* %1, i32 0)
%e = bitcast i8* %e.i8 to i32* %e = bitcast i8* %e.i8 to i32*
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

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 = !DICompileUnit(language: DW_LANG_C89, producer: "clang", isOptimized: true, emissionKind: 0, file: !1, enums: !{}, retainedTypes: !{}) !0 = !DICompileUnit(language: DW_LANG_C89, producer: "clang", isOptimized: true, emissionKind: 0, 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 = !DISubprogram() !2 = !DISubprogram()
!22 = !DILocalVariable(tag: DW_TAG_auto_variable, name: "x", line: 16, scope: !2, file: !1, type: !16) !22 = !DILocalVariable(tag: DW_TAG_auto_variable, 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

; RUN: llc -mcpu=corei7 -no-stack-coloring=false < %s | FileCheck %s --check-prefix=YESCOLOR ; RUN: llc -mcpu=corei7 -no-stack-coloring=false < %s | FileCheck %s --check-prefix=YESCOLOR
; RUN: llc -mcpu=corei7 -no-stack-coloring=true < %s | FileCheck %s --check-prefix=NOCOLOR ; RUN: llc -mcpu=corei7 -no-stack-coloring=true < %s | FileCheck %s --check-prefix=NOCOLOR
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-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
;YESCOLOR: subq $144, %rsp ;YESCOLOR: subq $144, %rsp
;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
} }
;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
} }
;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
} }
;YESCOLOR: subq $200, %rsp ;YESCOLOR: 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
} }
;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
} }
;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
} }
;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
} }
;YESCOLOR: subq $144, %rsp ;YESCOLOR: subq $144, %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'
;YESCOLOR: subq $816, %rsp ;YESCOLOR: subq $816, %rsp
;NOCOLOR: subq $1616, %rsp ;NOCOLOR: subq $1616, %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
} }
;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
} }
;YESCOLOR-LABEL: multi_region_bb: ;YESCOLOR-LABEL: multi_region_bb:
;NOCOLOR-LABEL: multi_region_bb: ;NOCOLOR-LABEL: multi_region_bb:
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
} }
;YESCOLOR: subq $272, %rsp ;YESCOLOR: subq $272, %rsp
;NOCOLOR: subq $272, %rsp ;NOCOLOR: subq $272, %rsp
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.
;YESCOLOR-LABEL: myCall_pr15707: ;YESCOLOR-LABEL: myCall_pr15707:
;YESCOLOR: subq $200008, %rsp ;YESCOLOR: subq $200008, %rsp
;NOCOLOR-LABEL: myCall_pr15707: ;NOCOLOR-LABEL: myCall_pr15707:
;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.
;YESCOLOR-LABEL: bad_range: ;YESCOLOR-LABEL: bad_range:
;NOCOLOR-LABEL: bad_range: ;NOCOLOR-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.
;YESCOLOR-LABEL: shady_range: ;YESCOLOR-LABEL: shady_range:
;NOCOLOR-LABEL: shady_range: ;NOCOLOR-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
} }
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/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/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.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/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*
%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-protector-weight.ll

Show All 11 Lines
; IR: BB#[[SUCCESS]]: ; IR: BB#[[SUCCESS]]:
; IR: BB#[[FAILURE]]: ; IR: BB#[[FAILURE]]:
; IR: CALL64pcrel32 <ga:@__stack_chk_fail> ; IR: CALL64pcrel32 <ga:@__stack_chk_fail>
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 = { ssp "stack-protector-buffer-size"="8" } attributes #0 = { ssp "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 -check-prefix=CHECK ; RUN: llc < %s -mtriple=x86_64-apple-darwin -no-integrated-as | FileCheck %s -check-prefix=CHECK
;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/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/DebugInfo/AArch64/frameindices.ll

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines
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
define void @_Z3f111A(%struct.A* nocapture readonly %p1) #0 { define void @_Z3f111A(%struct.A* nocapture readonly %p1) #0 {
entry: entry:
%agg.tmp.i = alloca %struct.A, align 8 %agg.tmp.i = alloca %struct.A, align 8
tail call void @llvm.dbg.declare(metadata %struct.A* %p1, metadata !33, metadata !46), !dbg !63 tail call void @llvm.dbg.declare(metadata %struct.A* %p1, metadata !33, metadata !46), !dbg !63
%0 = getelementptr inbounds %struct.A, %struct.A* %p1, i64 0, i32 0, !dbg !64 %0 = getelementptr inbounds %struct.A, %struct.A* %p1, i64 0, i32 0, !dbg !64
%1 = getelementptr inbounds %struct.A, %struct.A* %agg.tmp.i, i64 0, i32 0, !dbg !65 %1 = getelementptr inbounds %struct.A, %struct.A* %agg.tmp.i, i64 0, i32 0, !dbg !65
call void @llvm.lifetime.start(i64 24, i8* %1), !dbg !65 call void @llvm.lifetime.start.p0i8(i64 24, i8* %1), !dbg !65
%2 = load i64, i64* @a, align 8, !dbg !67, !tbaa !49 %2 = load i64, i64* @a, align 8, !dbg !67, !tbaa !49
%call.i = tail call noalias i8* @_Znwm(i64 %2) #5, !dbg !68 %call.i = tail call noalias i8* @_Znwm(i64 %2) #5, !dbg !68
store i8* %call.i, i8** bitcast (i32** @b to i8**), align 8, !dbg !69, !tbaa !55 store i8* %call.i, i8** bitcast (i32** @b to i8**), align 8, !dbg !69, !tbaa !55
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %1, i8* %0, i64 24, i32 8, i1 false), !dbg !70 call void @llvm.memcpy.p0i8.p0i8.i64(i8* %1, i8* %0, i64 24, i32 8, i1 false), !dbg !70
call void @_Z2f91A(%struct.A* %agg.tmp.i), !dbg !71 call void @_Z2f91A(%struct.A* %agg.tmp.i), !dbg !71
call void @llvm.lifetime.end(i64 24, i8* %1), !dbg !72 call void @llvm.lifetime.end.p0i8(i64 24, i8* %1), !dbg !72
ret void, !dbg !73 ret void, !dbg !73
} }
define void @_Z3f16v() #0 { define void @_Z3f16v() #0 {
entry: entry:
%agg.tmp.i.i = alloca %struct.A, align 8 %agg.tmp.i.i = alloca %struct.A, align 8
%d = alloca %struct.B, align 1 %d = alloca %struct.B, align 1
%agg.tmp.sroa.2 = alloca [15 x i8], align 1 %agg.tmp.sroa.2 = alloca [15 x i8], align 1
%agg.tmp.sroa.4 = alloca [7 x i8], align 1 %agg.tmp.sroa.4 = alloca [7 x i8], align 1
tail call void @llvm.dbg.declare(metadata [15 x i8]* %agg.tmp.sroa.2, metadata !74, metadata !76), !dbg !77 tail call void @llvm.dbg.declare(metadata [15 x i8]* %agg.tmp.sroa.2, metadata !74, metadata !76), !dbg !77
tail call void @llvm.dbg.declare(metadata [7 x i8]* %agg.tmp.sroa.4, metadata !74, metadata !78), !dbg !77 tail call void @llvm.dbg.declare(metadata [7 x i8]* %agg.tmp.sroa.4, metadata !74, metadata !78), !dbg !77
tail call void @llvm.dbg.declare(metadata %struct.A* undef, metadata !38, metadata !79), !dbg !80 tail call void @llvm.dbg.declare(metadata %struct.A* undef, metadata !38, metadata !79), !dbg !80
%0 = load i64, i64* @a, align 8, !dbg !81, !tbaa !49 %0 = load i64, i64* @a, align 8, !dbg !81, !tbaa !49
tail call void @llvm.dbg.value(metadata %struct.B* %d, i64 0, metadata !39, metadata !79), !dbg !82 tail call void @llvm.dbg.value(metadata %struct.B* %d, i64 0, metadata !39, metadata !79), !dbg !82
%call = call %struct.B* @_ZN1BC1El(%struct.B* %d, i64 %0), !dbg !82 %call = call %struct.B* @_ZN1BC1El(%struct.B* %d, i64 %0), !dbg !82
call void @llvm.dbg.value(metadata i8 1, i64 0, metadata !38, metadata !83), !dbg !80 call void @llvm.dbg.value(metadata i8 1, i64 0, metadata !38, metadata !83), !dbg !80
call void @llvm.dbg.value(metadata i8 1, i64 0, metadata !38, metadata !84), !dbg !80 call void @llvm.dbg.value(metadata i8 1, i64 0, metadata !38, metadata !84), !dbg !80
call void @llvm.dbg.value(metadata i8 1, i64 0, metadata !74, metadata !83), !dbg !77 call void @llvm.dbg.value(metadata i8 1, i64 0, metadata !74, metadata !83), !dbg !77
call void @llvm.dbg.value(metadata i8 1, i64 0, metadata !74, metadata !84), !dbg !77 call void @llvm.dbg.value(metadata i8 1, i64 0, metadata !74, metadata !84), !dbg !77
call void @llvm.dbg.declare(metadata %struct.A* undef, metadata !74, metadata !46), !dbg !77 call void @llvm.dbg.declare(metadata %struct.A* undef, metadata !74, metadata !46), !dbg !77
%1 = getelementptr inbounds %struct.A, %struct.A* %agg.tmp.i.i, i64 0, i32 0, !dbg !85 %1 = getelementptr inbounds %struct.A, %struct.A* %agg.tmp.i.i, i64 0, i32 0, !dbg !85
call void @llvm.lifetime.start(i64 24, i8* %1), !dbg !85 call void @llvm.lifetime.start.p0i8(i64 24, i8* %1), !dbg !85
%2 = load i64, i64* @a, align 8, !dbg !87, !tbaa !49 %2 = load i64, i64* @a, align 8, !dbg !87, !tbaa !49
%call.i.i5 = invoke noalias i8* @_Znwm(i64 %2) #5 %call.i.i5 = invoke noalias i8* @_Znwm(i64 %2) #5
to label %call.i.i.noexc unwind label %lpad, !dbg !88 to label %call.i.i.noexc unwind label %lpad, !dbg !88
call.i.i.noexc: ; preds = %entry call.i.i.noexc: ; preds = %entry
%agg.tmp.sroa.4.17..sroa_idx = getelementptr inbounds [7 x i8], [7 x i8]* %agg.tmp.sroa.4, i64 0, i64 0, !dbg !89 %agg.tmp.sroa.4.17..sroa_idx = getelementptr inbounds [7 x i8], [7 x i8]* %agg.tmp.sroa.4, i64 0, i64 0, !dbg !89
%agg.tmp.sroa.2.1..sroa_idx = getelementptr inbounds [15 x i8], [15 x i8]* %agg.tmp.sroa.2, i64 0, i64 0, !dbg !89 %agg.tmp.sroa.2.1..sroa_idx = getelementptr inbounds [15 x i8], [15 x i8]* %agg.tmp.sroa.2, i64 0, i64 0, !dbg !89
store i8* %call.i.i5, i8** bitcast (i32** @b to i8**), align 8, !dbg !90, !tbaa !55 store i8* %call.i.i5, i8** bitcast (i32** @b to i8**), align 8, !dbg !90, !tbaa !55
store i8 1, i8* %1, align 8, !dbg !91 store i8 1, i8* %1, align 8, !dbg !91
%agg.tmp.sroa.2.0..sroa_raw_idx = getelementptr inbounds i8, i8* %1, i64 1, !dbg !91 %agg.tmp.sroa.2.0..sroa_raw_idx = getelementptr inbounds i8, i8* %1, i64 1, !dbg !91
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %agg.tmp.sroa.2.0..sroa_raw_idx, i8* %agg.tmp.sroa.2.1..sroa_idx, i64 15, i32 1, i1 false), !dbg !91 call void @llvm.memcpy.p0i8.p0i8.i64(i8* %agg.tmp.sroa.2.0..sroa_raw_idx, i8* %agg.tmp.sroa.2.1..sroa_idx, i64 15, i32 1, i1 false), !dbg !91
%agg.tmp.sroa.3.0..sroa_idx = getelementptr inbounds %struct.A, %struct.A* %agg.tmp.i.i, i64 0, i32 2, !dbg !91 %agg.tmp.sroa.3.0..sroa_idx = getelementptr inbounds %struct.A, %struct.A* %agg.tmp.i.i, i64 0, i32 2, !dbg !91
store i8 1, i8* %agg.tmp.sroa.3.0..sroa_idx, align 8, !dbg !91 store i8 1, i8* %agg.tmp.sroa.3.0..sroa_idx, align 8, !dbg !91
%agg.tmp.sroa.4.0..sroa_raw_idx = getelementptr inbounds i8, i8* %1, i64 17, !dbg !91 %agg.tmp.sroa.4.0..sroa_raw_idx = getelementptr inbounds i8, i8* %1, i64 17, !dbg !91
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %agg.tmp.sroa.4.0..sroa_raw_idx, i8* %agg.tmp.sroa.4.17..sroa_idx, i64 7, i32 1, i1 false), !dbg !91 call void @llvm.memcpy.p0i8.p0i8.i64(i8* %agg.tmp.sroa.4.0..sroa_raw_idx, i8* %agg.tmp.sroa.4.17..sroa_idx, i64 7, i32 1, i1 false), !dbg !91
invoke void @_Z2f91A(%struct.A* %agg.tmp.i.i) invoke void @_Z2f91A(%struct.A* %agg.tmp.i.i)
to label %invoke.cont unwind label %lpad, !dbg !92 to label %invoke.cont unwind label %lpad, !dbg !92
invoke.cont: ; preds = %call.i.i.noexc invoke.cont: ; preds = %call.i.i.noexc
call void @llvm.lifetime.end(i64 24, i8* %1), !dbg !93 call void @llvm.lifetime.end.p0i8(i64 24, i8* %1), !dbg !93
call void @llvm.dbg.value(metadata %struct.B* %d, i64 0, metadata !39, metadata !79), !dbg !82 call void @llvm.dbg.value(metadata %struct.B* %d, i64 0, metadata !39, metadata !79), !dbg !82
%call1 = call %struct.B* @_ZN1BD1Ev(%struct.B* %d) #3, !dbg !94 %call1 = call %struct.B* @_ZN1BD1Ev(%struct.B* %d) #3, !dbg !94
ret void, !dbg !94 ret void, !dbg !94
lpad: ; preds = %call.i.i.noexc, %entry lpad: ; preds = %call.i.i.noexc, %entry
%3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) %3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
cleanup, !dbg !94 cleanup, !dbg !94
call void @llvm.dbg.value(metadata %struct.B* %d, i64 0, metadata !39, metadata !79), !dbg !82 call void @llvm.dbg.value(metadata %struct.B* %d, i64 0, metadata !39, metadata !79), !dbg !82
%call2 = call %struct.B* @_ZN1BD1Ev(%struct.B* %d) #3, !dbg !94 %call2 = call %struct.B* @_ZN1BD1Ev(%struct.B* %d) #3, !dbg !94
resume { i8*, i32 } %3, !dbg !94 resume { i8*, i32 } %3, !dbg !94
} }
declare %struct.B* @_ZN1BC1El(%struct.B*, i64) declare %struct.B* @_ZN1BC1El(%struct.B*, i64)
declare i32 @__gxx_personality_v0(...) declare i32 @__gxx_personality_v0(...)
; Function Attrs: nounwind ; Function Attrs: nounwind
declare %struct.B* @_ZN1BD1Ev(%struct.B*) #4 declare %struct.B* @_ZN1BD1Ev(%struct.B*) #4
; Function Attrs: nounwind readnone ; Function Attrs: nounwind readnone
declare void @llvm.dbg.value(metadata, i64, metadata, metadata) #1 declare void @llvm.dbg.value(metadata, i64, metadata, metadata) #1
; 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
attributes #1 = { nounwind readnone } attributes #1 = { nounwind readnone }
attributes #2 = { nobuiltin } attributes #2 = { nobuiltin }
attributes #3 = { nounwind } attributes #3 = { nounwind }
attributes #4 = { nounwind } attributes #4 = { nounwind }
attributes #5 = { builtin } attributes #5 = { builtin }
!llvm.dbg.cu = !{!0} !llvm.dbg.cu = !{!0}
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

test/DebugInfo/X86/debug-ranges-offset.ll

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Lines
define i32 @main() #0 { define i32 @main() #0 {
entry: entry:
%p.i = alloca i32*, align 8 %p.i = alloca i32*, align 8
%0 = ptrtoint i32** %p.i to i64, !dbg !30 %0 = ptrtoint i32** %p.i to i64, !dbg !30
%1 = and i64 %0, -70368744177672, !dbg !30 %1 = and i64 %0, -70368744177672, !dbg !30
%2 = inttoptr i64 %1 to i64*, !dbg !30 %2 = inttoptr i64 %1 to i64*, !dbg !30
store i64 -1, i64* %2, align 8, !dbg !30 store i64 -1, i64* %2, align 8, !dbg !30
%p.i.0..sroa_cast = bitcast i32** %p.i to i8*, !dbg !30 %p.i.0..sroa_cast = bitcast i32** %p.i to i8*, !dbg !30
call void @llvm.lifetime.start(i64 8, i8* %p.i.0..sroa_cast), !dbg !30 call void @llvm.lifetime.start.p0i8(i64 8, i8* %p.i.0..sroa_cast), !dbg !30
store i64 0, i64* getelementptr inbounds ([1000 x i64], [1000 x i64]* @__msan_param_tls, i64 0, i64 0), align 8, !dbg !30 store i64 0, i64* getelementptr inbounds ([1000 x i64], [1000 x i64]* @__msan_param_tls, i64 0, i64 0), align 8, !dbg !30
store i64 0, i64* getelementptr inbounds ([8 x i64], [8 x i64]* @__msan_retval_tls, i64 0, i64 0), align 8, !dbg !30 store i64 0, i64* getelementptr inbounds ([8 x i64], [8 x i64]* @__msan_retval_tls, i64 0, i64 0), align 8, !dbg !30
%call.i = call i8* @_Znwm(i64 4) #4, !dbg !30 %call.i = call i8* @_Znwm(i64 4) #4, !dbg !30
%_msret = load i64, i64* getelementptr inbounds ([8 x i64], [8 x i64]* @__msan_retval_tls, i64 0, i64 0), align 8, !dbg !30 %_msret = load i64, i64* getelementptr inbounds ([8 x i64], [8 x i64]* @__msan_retval_tls, i64 0, i64 0), align 8, !dbg !30
%3 = bitcast i8* %call.i to i32*, !dbg !30 %3 = bitcast i8* %call.i to i32*, !dbg !30
tail call void @llvm.dbg.value(metadata i32* %3, i64 0, metadata !32, metadata !DIExpression()), !dbg !30 tail call void @llvm.dbg.value(metadata i32* %3, i64 0, metadata !32, metadata !DIExpression()), !dbg !30
%4 = inttoptr i64 %1 to i64*, !dbg !30 %4 = inttoptr i64 %1 to i64*, !dbg !30
store i64 %_msret, i64* %4, align 8, !dbg !30 store i64 %_msret, i64* %4, align 8, !dbg !30
Show All 33 Lines
if.then.i: ; preds = %16 if.then.i: ; preds = %16
store i64 0, i64* getelementptr inbounds ([1000 x i64], [1000 x i64]* @__msan_param_tls, i64 0, i64 0), align 8, !dbg !34 store i64 0, i64* getelementptr inbounds ([1000 x i64], [1000 x i64]* @__msan_param_tls, i64 0, i64 0), align 8, !dbg !34
store i32 0, i32* bitcast ([8 x i64]* @__msan_retval_tls to i32*), align 8, !dbg !34 store i32 0, i32* bitcast ([8 x i64]* @__msan_retval_tls to i32*), align 8, !dbg !34
%puts.i = call i32 @puts(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @str, i64 0, i64 0)), !dbg !34 %puts.i = call i32 @puts(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @str, i64 0, i64 0)), !dbg !34
br label %_Z1fv.exit, !dbg !34 br label %_Z1fv.exit, !dbg !34
_Z1fv.exit: ; preds = %16, %if.then.i _Z1fv.exit: ; preds = %16, %if.then.i
call void @llvm.lifetime.end(i64 8, i8* %p.i.0..sroa_cast), !dbg !35 call void @llvm.lifetime.end.p0i8(i64 8, i8* %p.i.0..sroa_cast), !dbg !35
store i32 0, i32* bitcast ([8 x i64]* @__msan_retval_tls to i32*), align 8, !dbg !36 store i32 0, i32* bitcast ([8 x i64]* @__msan_retval_tls to i32*), align 8, !dbg !36
ret i32 0, !dbg !36 ret i32 0, !dbg !36
} }
declare void @__msan_init() declare void @__msan_init()
; Function Attrs: nounwind readnone ; Function Attrs: nounwind readnone
declare void @llvm.dbg.value(metadata, i64, metadata, metadata) #2 declare void @llvm.dbg.value(metadata, i64, metadata, metadata) #2
; Function Attrs: nounwind ; Function Attrs: nounwind
declare i32 @puts(i8* nocapture readonly) #3 declare i32 @puts(i8* nocapture readonly) #3
; 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
declare void @__msan_warning_noreturn() declare void @__msan_warning_noreturn()
declare void @__msan_maybe_warning_1(i8, i32) declare void @__msan_maybe_warning_1(i8, i32)
declare void @__msan_maybe_store_origin_1(i8, i8*, i32) declare void @__msan_maybe_store_origin_1(i8, i8*, i32)
declare void @__msan_maybe_warning_2(i16, i32) declare void @__msan_maybe_warning_2(i16, i32)
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

test/DebugInfo/X86/nodebug_with_debug_loc.ll

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Linesentry:
%str2.i = alloca %struct.string, align 4 %str2.i = alloca %struct.string, align 4
%0 = bitcast %struct.string* %str2.i to i8*, !dbg !26 %0 = bitcast %struct.string* %str2.i to i8*, !dbg !26
%1 = load %struct.string*, %struct.string** @str, align 4 %1 = load %struct.string*, %struct.string** @str, align 4
%mem = getelementptr inbounds %struct.string, %struct.string* %1, i32 0, i32 0 %mem = getelementptr inbounds %struct.string, %struct.string* %1, i32 0, i32 0
br label %for.body br label %for.body
for.body: ; preds = %for.body, %entry for.body: ; preds = %for.body, %entry
%iter.02 = phi i32 [ 0, %entry ], [ %inc, %for.body ] %iter.02 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
call void @llvm.lifetime.start(i64 4, i8* %0), !dbg !26 call void @llvm.lifetime.start.p0i8(i64 4, i8* %0), !dbg !26
call void @llvm.dbg.value(metadata %struct.string* %str2.i, i64 0, metadata !16, metadata !DIExpression()) #3, !dbg !26 call void @llvm.dbg.value(metadata %struct.string* %str2.i, i64 0, metadata !16, metadata !DIExpression()) #3, !dbg !26
call void @llvm.dbg.value(metadata %struct.string* %str2.i, i64 0, metadata !27, metadata !DIExpression()) #3, !dbg !29 call void @llvm.dbg.value(metadata %struct.string* %str2.i, i64 0, metadata !27, metadata !DIExpression()) #3, !dbg !29
call void @_Z4sinkPKv(i8* undef) #3, !dbg !29 call void @_Z4sinkPKv(i8* undef) #3, !dbg !29
call void @_Z4sinkPKv(i8* %0) #3, !dbg !30 call void @_Z4sinkPKv(i8* %0) #3, !dbg !30
call void @llvm.lifetime.end(i64 4, i8* %0), !dbg !31 call void @llvm.lifetime.end.p0i8(i64 4, i8* %0), !dbg !31
%2 = load i32*, i32** %mem, align 4, !tbaa !32 %2 = load i32*, i32** %mem, align 4, !tbaa !32
%3 = bitcast i32* %2 to i8* %3 = bitcast i32* %2 to i8*
call void @_Z4sinkPKv(i8* %3) #3 call void @_Z4sinkPKv(i8* %3) #3
%4 = load i8, i8* @b, align 1, !tbaa !37, !range !39 %4 = load i8, i8* @b, align 1, !tbaa !37, !range !39
%tobool = icmp ne i8 %4, 0 %tobool = icmp ne i8 %4, 0
%inc = add nsw i32 %iter.02, 1 %inc = add nsw i32 %iter.02, 1
%cmp = icmp eq i32 %inc, 2 %cmp = icmp eq i32 %inc, 2
%or.cond = or i1 %tobool, %cmp %or.cond = or i1 %tobool, %cmp
br i1 %or.cond, label %for.end, label %for.body br i1 %or.cond, label %for.end, label %for.body
for.end: ; preds = %for.body for.end: ; preds = %for.body
ret void ret void
} }
declare void @_Z4sinkPKv(i8*) #1 declare void @_Z4sinkPKv(i8*) #1
; Function Attrs: nounwind readnone ; Function Attrs: nounwind readnone
declare void @llvm.dbg.value(metadata, i64, metadata, metadata) #2 declare void @llvm.dbg.value(metadata, i64, metadata, metadata) #2
; 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
attributes #0 = { nounwind "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-realign-stack" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #0 = { nounwind "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-realign-stack" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-realign-stack" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #1 = { "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-realign-stack" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #2 = { nounwind readnone } attributes #2 = { nounwind readnone }
attributes #3 = { nounwind } attributes #3 = { nounwind }
!llvm.dbg.cu = !{!0} !llvm.dbg.cu = !{!0}
!llvm.module.flags = !{!23, !24} !llvm.module.flags = !{!23, !24}
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

test/DebugInfo/cross-cu-inlining.ll

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines
; Function Attrs: uwtable ; Function Attrs: uwtable
define i32 @main() #0 { define i32 @main() #0 {
entry: entry:
%x.addr.i = alloca i32, align 4 %x.addr.i = alloca i32, align 4
%retval = alloca i32, align 4 %retval = alloca i32, align 4
store i32 0, i32* %retval store i32 0, i32* %retval
%0 = load i32, i32* @i, align 4, !dbg !19 %0 = load i32, i32* @i, align 4, !dbg !19
%1 = bitcast i32* %x.addr.i to i8* %1 = bitcast i32* %x.addr.i to i8*
call void @llvm.lifetime.start(i64 4, i8* %1) call void @llvm.lifetime.start.p0i8(i64 4, i8* %1)
store i32 %0, i32* %x.addr.i, align 4 store i32 %0, i32* %x.addr.i, align 4
call void @llvm.dbg.declare(metadata i32* %x.addr.i, metadata !120, metadata !DIExpression()), !dbg !21 call void @llvm.dbg.declare(metadata i32* %x.addr.i, metadata !120, metadata !DIExpression()), !dbg !21
%2 = load i32, i32* %x.addr.i, align 4, !dbg !22 %2 = load i32, i32* %x.addr.i, align 4, !dbg !22
%mul.i = mul nsw i32 %2, 2, !dbg !22 %mul.i = mul nsw i32 %2, 2, !dbg !22
%3 = bitcast i32* %x.addr.i to i8*, !dbg !22 %3 = bitcast i32* %x.addr.i to i8*, !dbg !22
call void @llvm.lifetime.end(i64 4, i8* %3), !dbg !22 call void @llvm.lifetime.end.p0i8(i64 4, i8* %3), !dbg !22
ret i32 %mul.i, !dbg !19 ret i32 %mul.i, !dbg !19
} }
; Function Attrs: alwaysinline nounwind uwtable ; Function Attrs: alwaysinline nounwind uwtable
define i32 @_Z4funci(i32 %x) #1 { define i32 @_Z4funci(i32 %x) #1 {
entry: entry:
%x.addr = alloca i32, align 4 %x.addr = alloca i32, align 4
store i32 %x, i32* %x.addr, align 4 store i32 %x, i32* %x.addr, align 4
call void @llvm.dbg.declare(metadata i32* %x.addr, metadata !20, metadata !DIExpression()), !dbg !23 call void @llvm.dbg.declare(metadata i32* %x.addr, metadata !20, metadata !DIExpression()), !dbg !23
%0 = load i32, i32* %x.addr, align 4, !dbg !24 %0 = load i32, i32* %x.addr, align 4, !dbg !24
%mul = mul nsw i32 %0, 2, !dbg !24 %mul = mul nsw i32 %0, 2, !dbg !24
ret i32 %mul, !dbg !24 ret i32 %mul, !dbg !24
} }
; 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 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
attributes #0 = { 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 = { 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 = { alwaysinline nounwind 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 = { alwaysinline nounwind 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 #2 = { nounwind readnone } attributes #2 = { nounwind readnone }
attributes #3 = { nounwind } attributes #3 = { nounwind }
!llvm.dbg.cu = !{!0, !9} !llvm.dbg.cu = !{!0, !9}
!llvm.module.flags = !{!16, !17} !llvm.module.flags = !{!16, !17}
Show All 31 Lines

test/Feature/memorymarkers.ll

; RUN: llvm-as -disable-output < %s ; RUN: llvm-as -disable-output < %s
%"struct.std::pair<int,int>" = type { i32, i32 } %"struct.std::pair<int,int>" = type { i32, i32 }
declare void @_Z3barRKi(i32*) declare void @_Z3barRKi(i32*)
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 {}* @llvm.invariant.start(i64, i8* nocapture) readonly nounwind declare {}* @llvm.invariant.start.p0i8(i64, i8* nocapture) readonly nounwind
declare void @llvm.invariant.end({}*, i64, i8* nocapture) nounwind declare void @llvm.invariant.end.p0i8({}*, i64, i8* nocapture) nounwind
define i32 @_Z4foo2v() nounwind { define i32 @_Z4foo2v() nounwind {
entry: entry:
%x = alloca %"struct.std::pair<int,int>" %x = alloca %"struct.std::pair<int,int>"
%y = bitcast %"struct.std::pair<int,int>"* %x to i8* %y = bitcast %"struct.std::pair<int,int>"* %x to i8*
;; Constructor starts here (this isn't needed since it is immediately ;; Constructor starts here (this isn't needed since it is immediately
;; preceded by an alloca, but shown for completeness). ;; preceded by an alloca, but shown for completeness).
call void @llvm.lifetime.start(i64 8, i8* %y) call void @llvm.lifetime.start.p0i8(i64 8, i8* %y)
%0 = getelementptr %"struct.std::pair<int,int>", %"struct.std::pair<int,int>"* %x, i32 0, i32 0 %0 = getelementptr %"struct.std::pair<int,int>", %"struct.std::pair<int,int>"* %x, i32 0, i32 0
store i32 4, i32* %0, align 8 store i32 4, i32* %0, align 8
%1 = getelementptr %"struct.std::pair<int,int>", %"struct.std::pair<int,int>"* %x, i32 0, i32 1 %1 = getelementptr %"struct.std::pair<int,int>", %"struct.std::pair<int,int>"* %x, i32 0, i32 1
store i32 5, i32* %1, align 4 store i32 5, i32* %1, align 4
;; Constructor has finished here. ;; Constructor has finished here.
%inv = call {}* @llvm.invariant.start(i64 8, i8* %y) %inv = call {}* @llvm.invariant.start.p0i8(i64 8, i8* %y)
call void @_Z3barRKi(i32* %0) nounwind call void @_Z3barRKi(i32* %0) nounwind
%2 = load i32, i32* %0, align 8 %2 = load i32, i32* %0, align 8
;; Destructor is run here. ;; Destructor is run here.
call void @llvm.invariant.end({}* %inv, i64 8, i8* %y) call void @llvm.invariant.end.p0i8({}* %inv, i64 8, i8* %y)
;; Destructor is done here. ;; Destructor is done here.
call void @llvm.lifetime.end(i64 8, i8* %y) call void @llvm.lifetime.end.p0i8(i64 8, i8* %y)
ret i32 %2 ret i32 %2
} }

test/Feature/memorymarkers_addrspace.ll

  • This file was added.
; RUN: llvm-as -disable-output < %s
%"struct.std::pair<int,int>" = type { i32, i32 }
declare void @_Z3barRKi(i32 addrspace(5)*)
declare void @llvm.lifetime.start.p5i8(i64, i8 addrspace(5)* nocapture) nounwind
declare void @llvm.lifetime.end.p5i8(i64, i8 addrspace(5)* nocapture) nounwind
declare {}* @llvm.invariant.start.p5i8(i64, i8 addrspace(5)* nocapture) readonly nounwind
declare void @llvm.invariant.end.p5i8({}*, i64, i8 addrspace(5)* nocapture) nounwind
declare %"struct.std::pair<int,int>" addrspace(5)* @allocpair5() nounwind
define i32 @_Z4foo2v() nounwind {
entry:
%x = call %"struct.std::pair<int,int>" addrspace(5)* @allocpair5()
%y = bitcast %"struct.std::pair<int,int>" addrspace(5)* %x to i8 addrspace(5)*
;; Constructor starts here (this isn't needed since it is immediately
;; preceded by an alloca, but shown for completeness).
call void @llvm.lifetime.start.p5i8(i64 8, i8 addrspace(5)* %y)
%0 = getelementptr %"struct.std::pair<int,int>", %"struct.std::pair<int,int>" addrspace(5)* %x, i32 0, i32 0
store i32 4, i32 addrspace(5)* %0, align 8
%1 = getelementptr %"struct.std::pair<int,int>", %"struct.std::pair<int,int>" addrspace(5)* %x, i32 0, i32 1
store i32 5, i32 addrspace(5)* %1, align 4
;; Constructor has finished here.
%inv = call {}* @llvm.invariant.start.p5i8(i64 8, i8 addrspace(5)* %y)
call void @_Z3barRKi(i32 addrspace(5)* %0) nounwind
%2 = load i32, i32 addrspace(5)* %0, align 8
;; Destructor is run here.
call void @llvm.invariant.end.p5i8({}* %inv, i64 8, i8 addrspace(5)* %y)
;; Destructor is done here.
call void @llvm.lifetime.end.p5i8(i64 8, i8 addrspace(5)* %y)
ret i32 %2
}

test/Instrumentation/AddressSanitizer/lifetime-uar.ll

; Test handling of llvm.lifetime intrinsics in UAR mode. ; Test handling of llvm.lifetime intrinsics in UAR mode.
; RUN: opt < %s -asan -asan-module -asan-use-after-return -asan-check-lifetime -S | FileCheck %s ; RUN: opt < %s -asan -asan-module -asan-use-after-return -asan-check-lifetime -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* 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
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 ; Memory is unpoisoned at llvm.lifetime.start.p0i8
; CHECK: call void @__asan_unpoison_stack_memory(i64 %{{[^ ]+}}, i64 1) ; CHECK: call void @__asan_unpoison_stack_memory(i64 %{{[^ ]+}}, i64 1)
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 ; Memory is poisoned at llvm.lifetime.end.p0i8
; CHECK: call void @__asan_poison_stack_memory(i64 %{{[^ ]+}}, i64 1) ; CHECK: call void @__asan_poison_stack_memory(i64 %{{[^ ]+}}, i64 1)
; No need to unpoison memory at function exit in UAR mode. ; No need to unpoison memory at function exit in UAR mode.
; CHECK-NOT: @__asan_unpoison_stack_memory ; CHECK-NOT: @__asan_unpoison_stack_memory
; CHECK: ret void ; CHECK: ret void
ret i32 0 ret i32 0
} }

test/Instrumentation/AddressSanitizer/lifetime.ll

; Test hanlding of llvm.lifetime intrinsics. ; Test hanlding of llvm.lifetime intrinsics.
; RUN: opt < %s -asan -asan-module -asan-check-lifetime -asan-use-after-return=0 -S | FileCheck %s ; RUN: opt < %s -asan -asan-module -asan-check-lifetime -asan-use-after-return=0 -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"
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 {
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*
call void @llvm.lifetime.start(i64 -1, i8* %i.ptr) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %i.ptr)
store volatile i8 0, i8* %i.ptr store volatile i8 0, i8* %i.ptr
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-LABEL: define void @lifetime_no_size() ; CHECK-LABEL: define void @lifetime_no_size()
; CHECK-NOT: @__asan_poison_stack_memory ; CHECK-NOT: @__asan_poison_stack_memory
; CHECK-NOT: @__asan_unpoison_stack_memory ; CHECK-NOT: @__asan_unpoison_stack_memory
; 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*
call void @llvm.lifetime.start(i64 3, i8* %i.ptr) call void @llvm.lifetime.start.p0i8(i64 3, i8* %i.ptr)
store volatile i8 0, i8* %i.ptr store volatile i8 0, i8* %i.ptr
; Memory is unpoisoned at llvm.lifetime.start ; Memory is unpoisoned at llvm.lifetime.start.p0i8
; CHECK: %[[VAR:[^ ]*]] = ptrtoint i32* %{{[^ ]+}} to i64 ; CHECK: %[[VAR:[^ ]*]] = ptrtoint i32* %{{[^ ]+}} to i64
; CHECK-NEXT: call void @__asan_unpoison_stack_memory(i64 %[[VAR]], i64 3) ; CHECK-NEXT: call void @__asan_unpoison_stack_memory(i64 %[[VAR]], i64 3)
call void @llvm.lifetime.end(i64 4, i8* %i.ptr) call void @llvm.lifetime.end.p0i8(i64 4, i8* %i.ptr)
call void @llvm.lifetime.end(i64 2, i8* %i.ptr) call void @llvm.lifetime.end.p0i8(i64 2, i8* %i.ptr)
; Memory is poisoned at every call to llvm.lifetime.end ; Memory is poisoned at every call to llvm.lifetime.end.p0i8
; CHECK: call void @__asan_poison_stack_memory(i64 %{{[^ ]+}}, i64 4) ; CHECK: call void @__asan_poison_stack_memory(i64 %{{[^ ]+}}, i64 4)
; CHECK: call void @__asan_poison_stack_memory(i64 %{{[^ ]+}}, i64 2) ; CHECK: call void @__asan_poison_stack_memory(i64 %{{[^ ]+}}, i64 2)
; 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)
store volatile i8 0, i8* %arr.ptr store volatile i8 0, i8* %arr.ptr
; CHECK: call void @__asan_unpoison_stack_memory(i64 %{{[^ ]+}}, i64 40) ; CHECK: call void @__asan_unpoison_stack_memory(i64 %{{[^ ]+}}, i64 40)
call void @llvm.lifetime.end(i64 40, i8* %arr.ptr) call void @llvm.lifetime.end.p0i8(i64 40, i8* %arr.ptr)
; CHECK: call void @__asan_poison_stack_memory(i64 %{{[^ ]+}}, i64 40) ; CHECK: 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 4, i8* %i.ptr) call void @llvm.lifetime.start.p0i8(i64 4, i8* %i.ptr)
store volatile i8 0, i8* %i.ptr store volatile i8 0, i8* %i.ptr
; CHECK: call void @__asan_unpoison_stack_memory(i64 %{{[^ ]+}}, i64 4) ; CHECK: call void @__asan_unpoison_stack_memory(i64 %{{[^ ]+}}, i64 4)
call void @llvm.lifetime.end(i64 4, i8* %i.ptr) call void @llvm.lifetime.end.p0i8(i64 4, i8* %i.ptr)
; CHECK: call void @__asan_poison_stack_memory(i64 %{{[^ ]+}}, i64 4) ; CHECK: call void @__asan_poison_stack_memory(i64 %{{[^ ]+}}, i64 4)
; Memory is unpoisoned at function exit (only once). ; Memory is unpoisoned at function exit (only once).
; CHECK: call void @__asan_unpoison_stack_memory(i64 %{{[^ ]+}}, i64 {{.*}}) ; CHECK: call void @__asan_unpoison_stack_memory(i64 %{{[^ ]+}}, i64 {{.*}})
; CHECK-NOT: @__asan_unpoison_stack_memory ; CHECK-NOT: @__asan_unpoison_stack_memory
; CHECK: ret void ; CHECK: 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*
call void @llvm.lifetime.start(i64 8, i8* %i.ptr) call void @llvm.lifetime.start.p0i8(i64 8, i8* %i.ptr)
store volatile i8 0, i8* %i.ptr store volatile i8 0, i8* %i.ptr
; CHECK: __asan_unpoison_stack_memory ; CHECK: __asan_unpoison_stack_memory
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: __asan_poison_stack_memory ; CHECK: __asan_poison_stack_memory
; CHECK: ret void ; CHECK: ret void
ret void ret void
} }

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

; RUN: opt -mtriple=x86_64-unknown-linux-gnu -mcpu=corei7-avx -bb-vectorize -S < %s | FileCheck %s ; RUN: opt -mtriple=x86_64-unknown-linux-gnu -mcpu=corei7-avx -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.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
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 All 18 Linesarrayctor.cont: ; preds = %newFuncRoot
%ref.tmp.sroa.6.0.idx5 = getelementptr inbounds [10 x %class.QBezier.15], [10 x %class.QBezier.15]* %beziers, i64 0, i64 0, i32 5 %ref.tmp.sroa.6.0.idx5 = getelementptr inbounds [10 x %class.QBezier.15], [10 x %class.QBezier.15]* %beziers, i64 0, i64 0, i32 5
store double 6.000000e+01, double* %ref.tmp.sroa.6.0.idx5, align 8 store double 6.000000e+01, double* %ref.tmp.sroa.6.0.idx5, align 8
%ref.tmp.sroa.7.0.idx6 = getelementptr inbounds [10 x %class.QBezier.15], [10 x %class.QBezier.15]* %beziers, i64 0, i64 0, i32 6 %ref.tmp.sroa.7.0.idx6 = getelementptr inbounds [10 x %class.QBezier.15], [10 x %class.QBezier.15]* %beziers, i64 0, i64 0, i32 6
store double 7.000000e+01, double* %ref.tmp.sroa.7.0.idx6, align 16 store double 7.000000e+01, double* %ref.tmp.sroa.7.0.idx6, align 16
%ref.tmp.sroa.8.0.idx7 = getelementptr inbounds [10 x %class.QBezier.15], [10 x %class.QBezier.15]* %beziers, i64 0, i64 0, i32 7 %ref.tmp.sroa.8.0.idx7 = getelementptr inbounds [10 x %class.QBezier.15], [10 x %class.QBezier.15]* %beziers, i64 0, i64 0, i32 7
store double 8.000000e+01, double* %ref.tmp.sroa.8.0.idx7, align 8 store double 8.000000e+01, double* %ref.tmp.sroa.8.0.idx7, align 8
%add.ptr = getelementptr inbounds [10 x %class.QBezier.15], [10 x %class.QBezier.15]* %beziers, i64 0, i64 1 %add.ptr = getelementptr inbounds [10 x %class.QBezier.15], [10 x %class.QBezier.15]* %beziers, i64 0, i64 1
%v0 = bitcast %class.QBezier.15* %agg.tmp.i to i8* %v0 = bitcast %class.QBezier.15* %agg.tmp.i to i8*
call void @llvm.lifetime.start(i64 64, i8* %v0) call void @llvm.lifetime.start.p0i8(i64 64, i8* %v0)
%v1 = bitcast %class.QBezier.15* %agg.tmp55.i to i8* %v1 = bitcast %class.QBezier.15* %agg.tmp55.i to i8*
call void @llvm.lifetime.start(i64 64, i8* %v1) call void @llvm.lifetime.start.p0i8(i64 64, i8* %v1)
%v2 = bitcast %class.QBezier.15* %agg.tmp56.i to i8* %v2 = bitcast %class.QBezier.15* %agg.tmp56.i to i8*
call void @llvm.lifetime.start(i64 64, i8* %v2) call void @llvm.lifetime.start.p0i8(i64 64, i8* %v2)
%v3 = bitcast [10 x %class.QBezier.15]* %beziers to i8* %v3 = bitcast [10 x %class.QBezier.15]* %beziers to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %v0, i8* %v3, i64 64, i32 8, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %v0, i8* %v3, i64 64, i32 8, i1 false)
call fastcc void @_ZL12printQBezier7QBezier(%class.QBezier.15* byval align 8 %agg.tmp.i) call fastcc void @_ZL12printQBezier7QBezier(%class.QBezier.15* byval align 8 %agg.tmp.i)
%x2.i = getelementptr inbounds [10 x %class.QBezier.15], [10 x %class.QBezier.15]* %beziers, i64 0, i64 0, i32 2 %x2.i = getelementptr inbounds [10 x %class.QBezier.15], [10 x %class.QBezier.15]* %beziers, i64 0, i64 0, i32 2
%v4 = load double, double* %x2.i, align 16 %v4 = load double, double* %x2.i, align 16
%x3.i = getelementptr inbounds [10 x %class.QBezier.15], [10 x %class.QBezier.15]* %beziers, i64 0, i64 0, i32 4 %x3.i = getelementptr inbounds [10 x %class.QBezier.15], [10 x %class.QBezier.15]* %beziers, i64 0, i64 0, i32 4
%v5 = load double, double* %x3.i, align 16 %v5 = load double, double* %x3.i, align 16
%add.i = fadd double %v4, %v5 %add.i = fadd double %v4, %v5
▲ Show 20 Lines • Show All 64 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/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 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) %12 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
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/GlobalOpt/invariant-nodatalayout.ll

; RUN: opt -globalopt -S -o - < %s | FileCheck %s ; RUN: opt -globalopt -S -o - < %s | FileCheck %s
; The check here is that it doesn't crash. ; The check here is that it doesn't crash.
declare {}* @llvm.invariant.start(i64 %size, i8* nocapture %ptr) declare {}* @llvm.invariant.start.p0i8(i64 %size, i8* nocapture %ptr)
@object1 = global { i32, i32 } zeroinitializer @object1 = global { i32, i32 } zeroinitializer
; CHECK: @object1 = global { i32, i32 } zeroinitializer ; CHECK: @object1 = global { i32, i32 } zeroinitializer
define void @ctor1() { define void @ctor1() {
%ptr = bitcast {i32, i32}* @object1 to i8* %ptr = bitcast {i32, i32}* @object1 to i8*
call {}* @llvm.invariant.start(i64 4, i8* %ptr) call {}* @llvm.invariant.start.p0i8(i64 4, i8* %ptr)
ret void ret void
} }
@llvm.global_ctors = appending constant @llvm.global_ctors = appending constant
[1 x { i32, void ()* }] [1 x { i32, void ()* }]
[ { i32, void ()* } { i32 65535, void ()* @ctor1 } ] [ { i32, void ()* } { i32 65535, void ()* @ctor1 } ]

test/Transforms/GlobalOpt/invariant.ll

; RUN: opt -globalopt -S -o - < %s | FileCheck %s ; RUN: opt -globalopt -S -o - < %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"
declare {}* @llvm.invariant.start(i64 %size, i8* nocapture %ptr) declare {}* @llvm.invariant.start.p0i8(i64 %size, i8* nocapture %ptr)
define void @test1(i8* %ptr) { define void @test1(i8* %ptr) {
call {}* @llvm.invariant.start(i64 4, i8* %ptr) call {}* @llvm.invariant.start.p0i8(i64 4, i8* %ptr)
ret void ret void
} }
@object1 = global i32 0 @object1 = global i32 0
; CHECK: @object1 = constant i32 -1 ; CHECK: @object1 = constant i32 -1
define void @ctor1() { define void @ctor1() {
store i32 -1, i32* @object1 store i32 -1, i32* @object1
%A = bitcast i32* @object1 to i8* %A = bitcast i32* @object1 to i8*
call void @test1(i8* %A) call void @test1(i8* %A)
ret void ret void
} }
@object2 = global i32 0 @object2 = global i32 0
; CHECK: @object2 = global i32 0 ; CHECK: @object2 = global i32 0
define void @ctor2() { define void @ctor2() {
store i32 -1, i32* @object2 store i32 -1, i32* @object2
%A = bitcast i32* @object2 to i8* %A = bitcast i32* @object2 to i8*
%B = call {}* @llvm.invariant.start(i64 4, i8* %A) %B = call {}* @llvm.invariant.start.p0i8(i64 4, i8* %A)
%C = bitcast {}* %B to i8* %C = bitcast {}* %B to i8*
ret void ret void
} }
@object3 = global i32 0 @object3 = global i32 0
; CHECK: @object3 = global i32 -1 ; CHECK: @object3 = global i32 -1
define void @ctor3() { define void @ctor3() {
store i32 -1, i32* @object3 store i32 -1, i32* @object3
%A = bitcast i32* @object3 to i8* %A = bitcast i32* @object3 to i8*
call {}* @llvm.invariant.start(i64 3, i8* %A) call {}* @llvm.invariant.start.p0i8(i64 3, i8* %A)
ret void ret void
} }
@object4 = global i32 0 @object4 = global i32 0
; CHECK: @object4 = global i32 -1 ; CHECK: @object4 = global i32 -1
define void @ctor4() { define void @ctor4() {
store i32 -1, i32* @object4 store i32 -1, i32* @object4
%A = bitcast i32* @object4 to i8* %A = bitcast i32* @object4 to i8*
call {}* @llvm.invariant.start(i64 -1, i8* %A) call {}* @llvm.invariant.start.p0i8(i64 -1, i8* %A)
ret void ret void
} }
@llvm.global_ctors = appending constant @llvm.global_ctors = appending constant
[4 x { i32, void ()* }] [4 x { i32, void ()* }]
[ { i32, void ()* } { i32 65535, void ()* @ctor1 }, [ { i32, void ()* } { i32 65535, void ()* @ctor1 },
{ i32, void ()* } { i32 65535, void ()* @ctor2 }, { i32, void ()* } { i32 65535, void ()* @ctor2 },
{ i32, void ()* } { i32 65535, void ()* @ctor3 }, { i32, void ()* } { i32 65535, void ()* @ctor3 },
{ i32, void ()* } { i32 65535, void ()* @ctor4 } ] { i32, void ()* } { i32 65535, void ()* @ctor4 } ]

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
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)
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)
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
call void @inner3(i32* %ptr, i1 undef) call void @inner3(i32* %ptr, i1 undef)
▲ Show 20 Lines • Show All 88 Lines • ▼ Show 20 Linesdefine void @inner5(i1 %flag, 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
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
} }

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

Show All 10 Lines
define void @bar(i32* byval %x) { define void @bar(i32* byval %x) {
call void @ext(i32* %x) call void @ext(i32* %x)
ret void ret void
} }
define void @foo(i32* %x) { define void @foo(i32* %x) {
; CHECK-LABEL: define void @foo( ; CHECK-LABEL: define void @foo(
; CHECK: llvm.lifetime.start ; CHECK: llvm.lifetime.start.p0i8
; CHECK: store i32 %2, i32* %x ; CHECK: store i32 %2, i32* %x
call void @bar(i32* byval %x) call void @bar(i32* byval %x)
ret void ret void
} }
define internal void @qux(i32* byval %x) { define internal void @qux(i32* byval %x) {
call void @ext(i32* %x) call void @ext(i32* %x)
tail call void @ext(i32* null) tail call void @ext(i32* null)
Show All 14 Lines

test/Transforms/Inline/byval_lifetime.ll

Show All 12 Linesentry:
%a1 = getelementptr inbounds %struct.foo, %struct.foo* %f, i32 0, i32 1 %a1 = getelementptr inbounds %struct.foo, %struct.foo* %f, i32 0, i32 1
%arrayidx = getelementptr inbounds [16 x i32], [16 x i32]* %a1, i32 0, i32 %a %arrayidx = getelementptr inbounds [16 x i32], [16 x i32]* %a1, i32 0, i32 %a
%tmp2 = load i32, i32* %arrayidx, align 1 %tmp2 = load i32, i32* %arrayidx, align 1
ret i32 %tmp2 ret i32 %tmp2
} }
define i32 @main(i32 %argc, i8** %argv) { define i32 @main(i32 %argc, i8** %argv) {
; CHECK-LABEL: @main ; CHECK-LABEL: @main
; CHECK: llvm.lifetime.start ; CHECK: llvm.lifetime.start.p0i8
; CHECK: memcpy ; CHECK: memcpy
entry: entry:
%call = call i32 @foo(%struct.foo* byval align 8 @gFoo, i32 %argc) %call = call i32 @foo(%struct.foo* byval align 8 @gFoo, i32 %argc)
ret i32 %call ret i32 %call
} }

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

; RUN: opt < %s -inline -S | FileCheck %s ; RUN: opt < %s -inline -S | FileCheck %s
; InlineFunction would assert inside the loop that leaves lifetime markers if ; InlineFunction would assert inside the loop that leaves lifetime markers if
; there was an zero-sized AllocaInst. Check that it doesn't assert and doesn't ; there was an zero-sized AllocaInst. Check that it doesn't assert and doesn't
; leave lifetime markers in that case. ; leave lifetime markers in that case.
declare i32 @callee2(i8*) declare i32 @callee2(i8*)
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
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
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.p0i8 / llvm.lifetime.end.p0i8 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
} }

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/invariant.ll

; Test to make sure unused llvm.invariant.start calls are not trivially eliminated ; Test to make sure unused llvm.invariant.start.p0i8 calls are not trivially eliminated
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -instcombine -S | FileCheck %s
declare void @g(i8*) declare void @g(i8*)
declare {}* @llvm.invariant.start(i64, i8* nocapture) nounwind readonly declare {}* @llvm.invariant.start.p0i8(i64, i8* nocapture) nounwind readonly
define i8 @f() { define i8 @f() {
%a = alloca i8 ; <i8*> [#uses=4] %a = alloca i8 ; <i8*> [#uses=4]
store i8 0, i8* %a store i8 0, i8* %a
%i = call {}* @llvm.invariant.start(i64 1, i8* %a) ; <{}*> [#uses=0] %i = call {}* @llvm.invariant.start.p0i8(i64 1, i8* %a) ; <{}*> [#uses=0]
; CHECK: call {}* @llvm.invariant.start ; CHECK: call {}* @llvm.invariant.start.p0i8
call void @g(i8* %a) call void @g(i8* %a)
%r = load i8, i8* %a ; <i8> [#uses=1] %r = load i8, i8* %a ; <i8> [#uses=1]
ret i8 %r ret i8 %r
} }

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 141 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/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.p0i8
; CHECK: store <2 x i32> ; CHECK: store <2 x i32>
; CHECK: call void @llvm.lifetime.start ; CHECK: call void @llvm.lifetime.start.p0i8
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.p0i8
; CHECK: store <2 x i32> ; CHECK: store <2 x i32>
; CHECK: call void @llvm.lifetime.start ; CHECK: call void @llvm.lifetime.start.p0i8
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.p0i8
; CHECK: store <2 x i32> ; CHECK: store <2 x i32>
; CHECK: call void @llvm.lifetime.start ; CHECK: call void @llvm.lifetime.start.p0i8
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/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.memcpy.p0i8.p0i8.i64(i8* %[[sret_cast]], i8* %[[a_cast]], i64 64 ; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* %[[sret_cast]], i8* %[[a_cast]], 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/SROA/basictest.ll

; RUN: opt < %s -sroa -S | FileCheck %s ; RUN: opt < %s -sroa -S | FileCheck %s
; RUN: opt < %s -sroa -force-ssa-updater -S | FileCheck %s ; RUN: opt < %s -sroa -force-ssa-updater -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 502 Lines • Show Last 20 Lines

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/ScalarRepl/lifetime.ll

; RUN: opt -scalarrepl -S < %s | FileCheck %s ; RUN: opt -scalarrepl -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" 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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
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*)
%t1 = type {i32, i32, i32} %t1 = type {i32, i32, i32}
define void @test1() { define void @test1() {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
%A = alloca %t1 %A = alloca %t1
%A1 = getelementptr %t1, %t1* %A, i32 0, i32 0 %A1 = getelementptr %t1, %t1* %A, i32 0, i32 0
%A2 = getelementptr %t1, %t1* %A, i32 0, i32 1 %A2 = getelementptr %t1, %t1* %A, i32 0, i32 1
%A3 = getelementptr %t1, %t1* %A, i32 0, i32 2 %A3 = getelementptr %t1, %t1* %A, i32 0, i32 2
%B = bitcast i32* %A1 to i8* %B = bitcast i32* %A1 to i8*
store i32 0, i32* %A1 store i32 0, i32* %A1
call void @llvm.lifetime.start(i64 -1, i8* %B) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %B)
ret void ret void
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
} }
define void @test2() { define void @test2() {
; CHECK-LABEL: @test2( ; CHECK-LABEL: @test2(
%A = alloca %t1 %A = alloca %t1
%A1 = getelementptr %t1, %t1* %A, i32 0, i32 0 %A1 = getelementptr %t1, %t1* %A, i32 0, i32 0
%A2 = getelementptr %t1, %t1* %A, i32 0, i32 1 %A2 = getelementptr %t1, %t1* %A, i32 0, i32 1
%A3 = getelementptr %t1, %t1* %A, i32 0, i32 2 %A3 = getelementptr %t1, %t1* %A, i32 0, i32 2
%B = bitcast i32* %A2 to i8* %B = bitcast i32* %A2 to i8*
store i32 0, i32* %A2 store i32 0, i32* %A2
call void @llvm.lifetime.start(i64 -1, i8* %B) call void @llvm.lifetime.start.p0i8(i64 -1, i8* %B)
%C = load i32, i32* %A2 %C = load i32, i32* %A2
ret void ret void
; CHECK: ret void ; CHECK: ret void
} }
define void @test3() { define void @test3() {
; CHECK-LABEL: @test3( ; CHECK-LABEL: @test3(
%A = alloca %t1 %A = alloca %t1
%A1 = getelementptr %t1, %t1* %A, i32 0, i32 0 %A1 = getelementptr %t1, %t1* %A, i32 0, i32 0
%A2 = getelementptr %t1, %t1* %A, i32 0, i32 1 %A2 = getelementptr %t1, %t1* %A, i32 0, i32 1
%A3 = getelementptr %t1, %t1* %A, i32 0, i32 2 %A3 = getelementptr %t1, %t1* %A, i32 0, i32 2
%B = bitcast i32* %A2 to i8* %B = bitcast i32* %A2 to i8*
store i32 0, i32* %A2 store i32 0, i32* %A2
call void @llvm.lifetime.start(i64 6, i8* %B) call void @llvm.lifetime.start.p0i8(i64 6, i8* %B)
%C = load i32, i32* %A2 %C = load i32, i32* %A2
ret void ret void
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
} }
define void @test4() { define void @test4() {
; CHECK-LABEL: @test4( ; CHECK-LABEL: @test4(
%A = alloca %t1 %A = alloca %t1
%A1 = getelementptr %t1, %t1* %A, i32 0, i32 0 %A1 = getelementptr %t1, %t1* %A, i32 0, i32 0
%A2 = getelementptr %t1, %t1* %A, i32 0, i32 1 %A2 = getelementptr %t1, %t1* %A, i32 0, i32 1
%A3 = getelementptr %t1, %t1* %A, i32 0, i32 2 %A3 = getelementptr %t1, %t1* %A, i32 0, i32 2
%B = bitcast i32* %A2 to i8* %B = bitcast i32* %A2 to i8*
store i32 0, i32* %A2 store i32 0, i32* %A2
call void @llvm.lifetime.start(i64 1, i8* %B) call void @llvm.lifetime.start.p0i8(i64 1, i8* %B)
%C = load i32, i32* %A2 %C = load i32, i32* %A2
ret void ret void
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
} }
%t2 = type {i32, [4 x i8], i32} %t2 = type {i32, [4 x i8], i32}
define void @test5() { define void @test5() {
Show All 12 Lines; CHECK-NOT: store i8 1
store i8 2, i8* %A22 store i8 2, i8* %A22
store i8 3, i8* %A23 store i8 3, i8* %A23
store i8 4, i8* %A24 store i8 4, i8* %A24
%A1 = getelementptr %t2, %t2* %A, i32 0, i32 0 %A1 = getelementptr %t2, %t2* %A, i32 0, i32 0
%A2 = getelementptr %t2, %t2* %A, i32 0, i32 1, i32 1 %A2 = getelementptr %t2, %t2* %A, i32 0, i32 1, i32 1
%A3 = getelementptr %t2, %t2* %A, i32 0, i32 2 %A3 = getelementptr %t2, %t2* %A, i32 0, i32 2
store i8 0, i8* %A2 store i8 0, i8* %A2
call void @llvm.lifetime.start(i64 5, i8* %A2) call void @llvm.lifetime.start.p0i8(i64 5, i8* %A2)
; CHECK: llvm.lifetime{{.*}}i64 1 ; CHECK: llvm.lifetime{{.*}}i64 1
; CHECK: llvm.lifetime{{.*}}i64 1 ; CHECK: llvm.lifetime{{.*}}i64 1
; CHECK: llvm.lifetime{{.*}}i64 1 ; CHECK: llvm.lifetime{{.*}}i64 1
%C = load i8, i8* %A2 %C = load i8, i8* %A2
ret void ret void
} }
%t3 = type {[4 x i16], [4 x i8]} %t3 = type {[4 x i16], [4 x i8]}
Show All 27 Lines; CHECK-NOT: store i16 14
store i8 23, i8* %A23 store i8 23, i8* %A23
store i8 24, i8* %A24 store i8 24, i8* %A24
; CHECK: store i8 21 ; CHECK: store i8 21
; CHECK: store i8 22 ; CHECK: store i8 22
; CHECK: store i8 23 ; CHECK: store i8 23
; CHECK-NOT: store i8 24 ; CHECK-NOT: store i8 24
%B = bitcast i16* %A13 to i8* %B = bitcast i16* %A13 to i8*
call void @llvm.lifetime.start(i64 7, i8* %B) call void @llvm.lifetime.start.p0i8(i64 7, i8* %B)
; CHECK: lifetime.start{{.*}}i64 1 ; CHECK: lifetime.start{{.*}}i64 1
; CHECK: lifetime.start{{.*}}i64 1 ; CHECK: lifetime.start{{.*}}i64 1
; CHECK: lifetime.start{{.*}}i64 1 ; CHECK: lifetime.start{{.*}}i64 1
ret void ret void
} }

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