This is an archive of the discontinued LLVM Phabricator instance.

Differential D9481

Change in symbol renaming to help demanglers and debuggers
ClosedPublic

Authored by Sunil_Srivastava on May 4 2015, 11:26 AM.

Details

Reviewers
rnk
Summary

Renaming of local symbols, to make unique names, used to just append a number. That creates trouble for demanglers by making these names un-demangle-able. So, for example, '_ZL3ByePi' becomes '_ZL3ByePi1', which is not acceptable to the demangler.

In similar situations Gcc prepends a dot before the number, and existing demanglers already know to stop at a dot. This change in ValueSymbolTable.cpp does the same for llvm.

The code change should not cause any difference in generated code, because these are all local symbols.

However, there are several cases (60) in the regression test that fail with the extra dot because the IR dumps are being checked for the old style renaming. That requires tweaks to these tests, about half in llvm and the rest in tools/clang. I will be submitting a separate review request for clang.

Diff Detail

Event Timeline

Sunil_Srivastava updated this revision to Diff 24896.May 4 2015, 11:26 AM
Sunil_Srivastava retitled this revision from to Change in symbol renaming to help demanglers and debuggers.
Sunil_Srivastava updated this object.
Sunil_Srivastava edited the test plan for this revision. (Show Details)
Sunil_Srivastava added a subscriber: Unknown Object (MLST).May 4 2015, 12:05 PM
rnk mentioned this in D9483: Change in symbol renaming to help demanglers and debugger. clang part..May 4 2015, 12:55 PM
emaste added a subscriber: emaste.May 5 2015, 7:00 AM
rnk accepted this revision.May 6 2015, 11:42 AM
rnk added a reviewer: rnk.
rnk added a subscriber: rnk.

lgtm

This is a big change, so I bugged David Majnemer and Eric Christopher, and we agreed this is the way to go.

This revision is now accepted and ready to land.May 6 2015, 11:42 AM
Sunil_Srivastava added a comment.May 12 2015, 11:22 AM

Thanks. Submitted in r237150

Sunil_Srivastava closed this revision.Jul 14 2015, 1:30 PM

Revision Contents

PathSize
lib/
IR/
2 lines
test/
CodeGen/
AArch64/
2 lines
4 lines
ARM/
2 lines
6 lines
WinEH/
4 lines
12 lines
6 lines
10 lines
10 lines
Instrumentation/
AddressSanitizer/
6 lines
Linker/
2 lines
2 lines
2 lines
Transforms/
BBVectorize/
16 lines
Inline/
12 lines
4 lines
InstCombine/
4 lines
4 lines
8 lines
LoopIdiom/
2 lines
LoopUnswitch/
2 lines
2 lines
LowerBitSets/
10 lines
LowerSwitch/
68 lines
PlaceSafepoints/
2 lines
SimplifyCFG/
X86/
24 lines
Util/
6 lines

Diff 24896

lib/IR/ValueSymbolTable.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Linesvoid ValueSymbolTable::reinsertValue(Value* V) {
// The name is too already used, just free it so we can allocate a new name. // The name is too already used, just free it so we can allocate a new name.
V->getValueName()->Destroy(); V->getValueName()->Destroy();
unsigned BaseSize = UniqueName.size(); unsigned BaseSize = UniqueName.size();
while (1) { while (1) {
// Trim any suffix off and append the next number. // Trim any suffix off and append the next number.
UniqueName.resize(BaseSize); UniqueName.resize(BaseSize);
raw_svector_ostream(UniqueName) << ++LastUnique; raw_svector_ostream(UniqueName) << "." << ++LastUnique;
// Try insert the vmap entry with this suffix. // Try insert the vmap entry with this suffix.
auto IterBool = vmap.insert(std::make_pair(UniqueName, V)); auto IterBool = vmap.insert(std::make_pair(UniqueName, V));
if (IterBool.second) { if (IterBool.second) {
// Newly inserted name. Success! // Newly inserted name. Success!
V->setValueName(&*IterBool.first); V->setValueName(&*IterBool.first);
//DEBUG(dbgs() << " Inserted value: " << UniqueName << ": " << *V << "\n"); //DEBUG(dbgs() << " Inserted value: " << UniqueName << ": " << *V << "\n");
return; return;
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

test/CodeGen/AArch64/arm64-promote-const.ll

Show All 34 Linesentry:
ret %struct.uint8x16x4_t { [4 x <16 x i8>] [<16 x i8> <i8 -40, i8 -93, i8 -118, i8 -99, i8 -75, i8 -105, i8 74, i8 -110, i8 62, i8 -115, i8 -119, i8 -120, i8 34, i8 -124, i8 0, i8 -128>, <16 x i8> <i8 32, i8 124, i8 121, i8 120, i8 8, i8 117, i8 -56, i8 113, i8 -76, i8 110, i8 -53, i8 107, i8 7, i8 105, i8 103, i8 102>, <16 x i8> <i8 -24, i8 99, i8 -121, i8 97, i8 66, i8 95, i8 24, i8 93, i8 6, i8 91, i8 12, i8 89, i8 39, i8 87, i8 86, i8 85>, <16 x i8> <i8 -104, i8 83, i8 -20, i8 81, i8 81, i8 80, i8 -59, i8 78, i8 73, i8 77, i8 -37, i8 75, i8 122, i8 74, i8 37, i8 73>] } ret %struct.uint8x16x4_t { [4 x <16 x i8>] [<16 x i8> <i8 -40, i8 -93, i8 -118, i8 -99, i8 -75, i8 -105, i8 74, i8 -110, i8 62, i8 -115, i8 -119, i8 -120, i8 34, i8 -124, i8 0, i8 -128>, <16 x i8> <i8 32, i8 124, i8 121, i8 120, i8 8, i8 117, i8 -56, i8 113, i8 -76, i8 110, i8 -53, i8 107, i8 7, i8 105, i8 103, i8 102>, <16 x i8> <i8 -24, i8 99, i8 -121, i8 97, i8 66, i8 95, i8 24, i8 93, i8 6, i8 91, i8 12, i8 89, i8 39, i8 87, i8 86, i8 85>, <16 x i8> <i8 -104, i8 83, i8 -20, i8 81, i8 81, i8 80, i8 -59, i8 78, i8 73, i8 77, i8 -37, i8 75, i8 122, i8 74, i8 37, i8 73>] }
} }
; Two different uses of the same constant in the same basic block ; Two different uses of the same constant in the same basic block
define <16 x i8> @test2(<16 x i8> %arg) { define <16 x i8> @test2(<16 x i8> %arg) {
entry: entry:
; PROMOTED-LABEL: test2: ; PROMOTED-LABEL: test2:
; In stress mode, constant vector are promoted ; In stress mode, constant vector are promoted
; PROMOTED: adrp [[PAGEADDR:x[0-9]+]], [[CSTV1:__PromotedConst[0-9]+]]@PAGE ; PROMOTED: adrp [[PAGEADDR:x[0-9]+]], [[CSTV1:__PromotedConst.[0-9]+]]@PAGE
; PROMOTED: ldr q[[REGNUM:[0-9]+]], {{\[}}[[PAGEADDR]], [[CSTV1]]@PAGEOFF] ; PROMOTED: ldr q[[REGNUM:[0-9]+]], {{\[}}[[PAGEADDR]], [[CSTV1]]@PAGEOFF]
; Destination register is defined by ABI ; Destination register is defined by ABI
; PROMOTED-NEXT: add.16b v0, v0, v[[REGNUM]] ; PROMOTED-NEXT: add.16b v0, v0, v[[REGNUM]]
; PROMOTED-NEXT: mla.16b v0, v0, v[[REGNUM]] ; PROMOTED-NEXT: mla.16b v0, v0, v[[REGNUM]]
; PROMOTED-NEXT: ret ; PROMOTED-NEXT: ret
; REGULAR-LABEL: test2: ; REGULAR-LABEL: test2:
; Regular access is strickly the same as promoted access. ; Regular access is strickly the same as promoted access.
▲ Show 20 Lines • Show All 128 Lines • Show Last 20 Lines

test/CodeGen/AArch64/global-merge-group-by-use.ll

; RUN: llc -mtriple=aarch64-apple-ios -asm-verbose=false -aarch64-collect-loh=false \ ; RUN: llc -mtriple=aarch64-apple-ios -asm-verbose=false -aarch64-collect-loh=false \
; RUN: -aarch64-global-merge -global-merge-group-by-use -global-merge-ignore-single-use=false \ ; RUN: -aarch64-global-merge -global-merge-group-by-use -global-merge-ignore-single-use=false \
; RUN: %s -o - | FileCheck %s ; RUN: %s -o - | FileCheck %s
; We assume that globals of the same size aren't reordered inside a set. ; We assume that globals of the same size aren't reordered inside a set.
; Check that we create two MergedGlobal instances for two functions using ; Check that we create two MergedGlobal instances for two functions using
; disjoint sets of globals ; disjoint sets of globals
@m1 = internal global i32 0, align 4 @m1 = internal global i32 0, align 4
@n1 = internal global i32 0, align 4 @n1 = internal global i32 0, align 4
; CHECK-LABEL: f1: ; CHECK-LABEL: f1:
define void @f1(i32 %a1, i32 %a2) #0 { define void @f1(i32 %a1, i32 %a2) #0 {
; CHECK-NEXT: adrp x8, [[SET1:__MergedGlobals[0-9]*]]@PAGE ; CHECK-NEXT: adrp x8, [[SET1:__MergedGlobals.[0-9]*]]@PAGE
; CHECK-NEXT: add x8, x8, [[SET1]]@PAGEOFF ; CHECK-NEXT: add x8, x8, [[SET1]]@PAGEOFF
; CHECK-NEXT: stp w0, w1, [x8] ; CHECK-NEXT: stp w0, w1, [x8]
; CHECK-NEXT: ret ; CHECK-NEXT: ret
store i32 %a1, i32* @m1, align 4 store i32 %a1, i32* @m1, align 4
store i32 %a2, i32* @n1, align 4 store i32 %a2, i32* @n1, align 4
ret void ret void
} }
@m2 = internal global i32 0, align 4 @m2 = internal global i32 0, align 4
@n2 = internal global i32 0, align 4 @n2 = internal global i32 0, align 4
@o2 = internal global i32 0, align 4 @o2 = internal global i32 0, align 4
; CHECK-LABEL: f2: ; CHECK-LABEL: f2:
define void @f2(i32 %a1, i32 %a2, i32 %a3) #0 { define void @f2(i32 %a1, i32 %a2, i32 %a3) #0 {
; CHECK-NEXT: adrp x8, [[SET2:__MergedGlobals[0-9]*]]@PAGE ; CHECK-NEXT: adrp x8, [[SET2:__MergedGlobals.[0-9]*]]@PAGE
; CHECK-NEXT: add x8, x8, [[SET2]]@PAGEOFF ; CHECK-NEXT: add x8, x8, [[SET2]]@PAGEOFF
; CHECK-NEXT: stp w0, w1, [x8] ; CHECK-NEXT: stp w0, w1, [x8]
; CHECK-NEXT: str w2, [x8, #8] ; CHECK-NEXT: str w2, [x8, #8]
; CHECK-NEXT: ret ; CHECK-NEXT: ret
store i32 %a1, i32* @m2, align 4 store i32 %a1, i32* @m2, align 4
store i32 %a2, i32* @n2, align 4 store i32 %a2, i32* @n2, align 4
store i32 %a3, i32* @o2, align 4 store i32 %a3, i32* @o2, align 4
ret void ret void
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

test/CodeGen/ARM/global-merge-addrspace.ll

; RUN: llc < %s -mtriple=thumb-apple-darwin -arm-global-merge -global-merge-group-by-use=false | FileCheck %s ; RUN: llc < %s -mtriple=thumb-apple-darwin -arm-global-merge -global-merge-group-by-use=false | FileCheck %s
; Test the GlobalMerge pass. Check that the pass does not crash when using ; Test the GlobalMerge pass. Check that the pass does not crash when using
; multiple address spaces. ; multiple address spaces.
; CHECK: _MergedGlobals: ; CHECK: _MergedGlobals:
@g1 = internal addrspace(1) global i32 1 @g1 = internal addrspace(1) global i32 1
@g2 = internal addrspace(1) global i32 2 @g2 = internal addrspace(1) global i32 2
; CHECK: _MergedGlobals1: ; CHECK: _MergedGlobals.1:
@g3 = internal addrspace(2) global i32 3 @g3 = internal addrspace(2) global i32 3
@g4 = internal addrspace(2) global i32 4 @g4 = internal addrspace(2) global i32 4

test/CodeGen/ARM/global-merge.ll

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
; CHECK: _MergedGlobals: ; CHECK: _MergedGlobals:
@g1 = internal global i32 1 @g1 = internal global i32 1
@g2 = internal global i32 2 @g2 = internal global i32 2
; Make sure that the complete variable fits within the range of the maximum ; Make sure that the complete variable fits within the range of the maximum
; offset. Having the starting offset in range is not sufficient. ; offset. Having the starting offset in range is not sufficient.
; When this works properly, @g3 is placed in a separate chunk of merged globals. ; When this works properly, @g3 is placed in a separate chunk of merged globals.
; CHECK: _MergedGlobals1: ; CHECK: _MergedGlobals.1:
@g3 = internal global [30 x i32] [ i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10 ], align 4 @g3 = internal global [30 x i32] [ i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10 ], align 4
; Global variables that can be placed in BSS should be kept together in a ; Global variables that can be placed in BSS should be kept together in a
; separate pool of merged globals. ; separate pool of merged globals.
; CHECK: _MergedGlobals2 ; CHECK: _MergedGlobals.2
@g4 = internal global i32 0 @g4 = internal global i32 0
@g5 = internal global i32 0 @g5 = internal global i32 0
; Global variables that are constant can be merged together ; Global variables that are constant can be merged together
; CHECK: _MergedGlobals3 ; CHECK: _MergedGlobals.3
@g6 = internal constant [12 x i32] zeroinitializer, align 4 @g6 = internal constant [12 x i32] zeroinitializer, align 4
@g7 = internal constant [12 x i32] zeroinitializer, align 4 @g7 = internal constant [12 x i32] zeroinitializer, align 4

test/CodeGen/WinEH/cppeh-catch-unwind.ll

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lineslpad1: ; preds = %invoke.cont
%6 = extractvalue { i8*, i32 } %5, 0 %6 = extractvalue { i8*, i32 } %5, 0
%7 = extractvalue { i8*, i32 } %5, 1 %7 = extractvalue { i8*, i32 } %5, 1
br label %ehcleanup br label %ehcleanup
; CHECK: [[LPAD3_LABEL]]:{{[ ]+}}; preds = %invoke.cont2 ; CHECK: [[LPAD3_LABEL]]:{{[ ]+}}; preds = %invoke.cont2
; CHECK: [[LPAD3_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) ; CHECK: [[LPAD3_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
; CHECK-NEXT: cleanup ; CHECK-NEXT: cleanup
; CHECK-NEXT: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*) ; CHECK-NEXT: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
; CHECK-NEXT: [[RECOVER3:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32 2, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch1", i32 0, void (i8*, i8*)* @"\01?test@@YAXXZ.cleanup") ; CHECK-NEXT: [[RECOVER3:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32 2, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch.1", i32 0, void (i8*, i8*)* @"\01?test@@YAXXZ.cleanup")
; CHECK-NEXT: indirectbr i8* [[RECOVER3]], [label %try.cont] ; CHECK-NEXT: indirectbr i8* [[RECOVER3]], [label %try.cont]
lpad3: ; preds = %invoke.cont2 lpad3: ; preds = %invoke.cont2
%8 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) %8 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
cleanup cleanup
catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*) catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
%9 = extractvalue { i8*, i32 } %8, 0 %9 = extractvalue { i8*, i32 } %8, 0
%10 = extractvalue { i8*, i32 } %8, 1 %10 = extractvalue { i8*, i32 } %8, 1
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines
; CHECK-LABEL: define internal void @"\01?test@@YAXXZ.cleanup"(i8*, i8*) ; CHECK-LABEL: define internal void @"\01?test@@YAXXZ.cleanup"(i8*, i8*)
; CHECK: entry: ; CHECK: entry:
; CHECK: [[RECOVER_OBJ:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 1) ; CHECK: [[RECOVER_OBJ:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 1)
; CHECK: [[OBJ_PTR:\%.+]] = bitcast i8* %obj.i8 to %class.SomeClass* ; CHECK: [[OBJ_PTR:\%.+]] = bitcast i8* %obj.i8 to %class.SomeClass*
; CHECK: call void @"\01??1SomeClass@@QEAA@XZ"(%class.SomeClass* [[OBJ_PTR]]) ; CHECK: call void @"\01??1SomeClass@@QEAA@XZ"(%class.SomeClass* [[OBJ_PTR]])
; CHECK: ret void ; CHECK: ret void
; CHECK: } ; CHECK: }
; CHECK-LABEL: define internal i8* @"\01?test@@YAXXZ.catch1"(i8*, i8*) ; CHECK-LABEL: define internal i8* @"\01?test@@YAXXZ.catch.1"(i8*, i8*)
; CHECK: entry: ; CHECK: entry:
; CHECK: [[RECOVER_TMP0:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 2) ; CHECK: [[RECOVER_TMP0:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 2)
; CHECK: [[TMP0_PTR:\%.+]] = bitcast i8* [[RECOVER_TMP0]] to i32* ; CHECK: [[TMP0_PTR:\%.+]] = bitcast i8* [[RECOVER_TMP0]] to i32*
; CHECK: invoke void @"\01?handle_exception@@YAXXZ"() ; CHECK: invoke void @"\01?handle_exception@@YAXXZ"()
; CHECK: to label %invoke.cont6 unwind label %[[LPAD5_LABEL:lpad[0-9]+]] ; CHECK: to label %invoke.cont6 unwind label %[[LPAD5_LABEL:lpad[0-9]+]]
; ;
; CHECK: invoke.cont6: ; preds = %entry ; CHECK: invoke.cont6: ; preds = %entry
; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont) ; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont)
Show All 38 Lines

test/CodeGen/WinEH/cppeh-multi-catch.ll

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
; CHECK: [[LPAD_LABEL]]:{{[ ]+}}; preds = %entry ; CHECK: [[LPAD_LABEL]]:{{[ ]+}}; preds = %entry
; CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) ; CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
; CHECK-NEXT: catch %eh.HandlerMapEntry* @llvm.eh.handlermapentry.H ; CHECK-NEXT: catch %eh.HandlerMapEntry* @llvm.eh.handlermapentry.H
; CHECK-NEXT: catch %eh.HandlerMapEntry* @llvm.eh.handlermapentry._J ; CHECK-NEXT: catch %eh.HandlerMapEntry* @llvm.eh.handlermapentry._J
; CHECK-NEXT: catch %eh.HandlerMapEntry* @"llvm.eh.handlermapentry.reference.?AVSomeClass@@" ; CHECK-NEXT: catch %eh.HandlerMapEntry* @"llvm.eh.handlermapentry.reference.?AVSomeClass@@"
; CHECK-NEXT: catch i8* null ; CHECK-NEXT: catch i8* null
; CHECK-NEXT: [[RECOVER:\%.+]] = call i8* (...) @llvm.eh.actions( ; CHECK-NEXT: [[RECOVER:\%.+]] = call i8* (...) @llvm.eh.actions(
; CHECK-SAME: i32 1, i8* bitcast (%eh.HandlerMapEntry* @llvm.eh.handlermapentry.H to i8*), i32 0, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch", ; CHECK-SAME: i32 1, i8* bitcast (%eh.HandlerMapEntry* @llvm.eh.handlermapentry.H to i8*), i32 0, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch",
; CHECK-SAME: i32 1, i8* bitcast (%eh.HandlerMapEntry* @llvm.eh.handlermapentry._J to i8*), i32 1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch1", ; CHECK-SAME: i32 1, i8* bitcast (%eh.HandlerMapEntry* @llvm.eh.handlermapentry._J to i8*), i32 1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch.1",
; CHECK-SAME: i32 1, i8* bitcast (%eh.HandlerMapEntry* @"llvm.eh.handlermapentry.reference.?AVSomeClass@@" to i8*), i32 2, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch2", ; CHECK-SAME: i32 1, i8* bitcast (%eh.HandlerMapEntry* @"llvm.eh.handlermapentry.reference.?AVSomeClass@@" to i8*), i32 2, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch.2",
; CHECK-SAME: i32 1, i8* null, i32 -1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch3") ; CHECK-SAME: i32 1, i8* null, i32 -1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch.3")
; CHECK-NEXT: indirectbr i8* [[RECOVER]], [label %ret] ; CHECK-NEXT: indirectbr i8* [[RECOVER]], [label %ret]
lpad: ; preds = %entry lpad: ; preds = %entry
%0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
catch %eh.HandlerMapEntry* @llvm.eh.handlermapentry.H catch %eh.HandlerMapEntry* @llvm.eh.handlermapentry.H
catch %eh.HandlerMapEntry* @llvm.eh.handlermapentry._J catch %eh.HandlerMapEntry* @llvm.eh.handlermapentry._J
catch %eh.HandlerMapEntry* @"llvm.eh.handlermapentry.reference.?AVSomeClass@@" catch %eh.HandlerMapEntry* @"llvm.eh.handlermapentry.reference.?AVSomeClass@@"
catch i8* null catch i8* null
▲ Show 20 Lines • Show All 73 Lines • ▼ Show 20 Lines
; CHECK: entry: ; CHECK: entry:
; CHECK: [[RECOVER_I:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 0) ; CHECK: [[RECOVER_I:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 0)
; CHECK: [[I_PTR:\%.+]] = bitcast i8* [[RECOVER_I]] to i32* ; CHECK: [[I_PTR:\%.+]] = bitcast i8* [[RECOVER_I]] to i32*
; CHECK: [[TMP1:\%.+]] = load i32, i32* [[I_PTR]], align 4 ; CHECK: [[TMP1:\%.+]] = load i32, i32* [[I_PTR]], align 4
; CHECK: call void @"\01?handle_int@@YAXH@Z"(i32 [[TMP1]]) ; CHECK: call void @"\01?handle_int@@YAXH@Z"(i32 [[TMP1]])
; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ", %ret) ; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ", %ret)
; CHECK: } ; CHECK: }
; CHECK-LABEL: define internal i8* @"\01?test@@YAXXZ.catch1"(i8*, i8*) ; CHECK-LABEL: define internal i8* @"\01?test@@YAXXZ.catch.1"(i8*, i8*)
; CHECK: entry: ; CHECK: entry:
; CHECK: [[RECOVER_LL:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 1) ; CHECK: [[RECOVER_LL:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 1)
; CHECK: [[LL_PTR:\%.+]] = bitcast i8* [[RECOVER_LL]] to i64* ; CHECK: [[LL_PTR:\%.+]] = bitcast i8* [[RECOVER_LL]] to i64*
; CHECK: [[TMP2:\%.+]] = load i64, i64* [[LL_PTR]], align 8 ; CHECK: [[TMP2:\%.+]] = load i64, i64* [[LL_PTR]], align 8
; CHECK: call void @"\01?handle_long_long@@YAX_J@Z"(i64 [[TMP2]]) ; CHECK: call void @"\01?handle_long_long@@YAX_J@Z"(i64 [[TMP2]])
; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ", %ret) ; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ", %ret)
; CHECK: } ; CHECK: }
; CHECK-LABEL: define internal i8* @"\01?test@@YAXXZ.catch2"(i8*, i8*) ; CHECK-LABEL: define internal i8* @"\01?test@@YAXXZ.catch.2"(i8*, i8*)
; CHECK: entry: ; CHECK: entry:
; CHECK: [[RECOVER_OBJ:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 2) ; CHECK: [[RECOVER_OBJ:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 2)
; CHECK: [[OBJ_PTR:\%.+]] = bitcast i8* [[RECOVER_OBJ]] to %class.SomeClass** ; CHECK: [[OBJ_PTR:\%.+]] = bitcast i8* [[RECOVER_OBJ]] to %class.SomeClass**
; CHECK: [[TMP3:\%.+]] = load %class.SomeClass*, %class.SomeClass** [[OBJ_PTR]], align 8 ; CHECK: [[TMP3:\%.+]] = load %class.SomeClass*, %class.SomeClass** [[OBJ_PTR]], align 8
; CHECK: call void @"\01?handle_obj@@YAXPEAVSomeClass@@@Z"(%class.SomeClass* [[TMP3]]) ; CHECK: call void @"\01?handle_obj@@YAXPEAVSomeClass@@@Z"(%class.SomeClass* [[TMP3]])
; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ", %ret) ; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ", %ret)
; CHECK: } ; CHECK: }
; CHECK-LABEL: define internal i8* @"\01?test@@YAXXZ.catch3"(i8*, i8*) ; CHECK-LABEL: define internal i8* @"\01?test@@YAXXZ.catch.3"(i8*, i8*)
; CHECK: entry: ; CHECK: entry:
; CHECK: call void @"\01?handle_exception@@YAXXZ"() ; CHECK: call void @"\01?handle_exception@@YAXXZ"()
; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ", %ret) ; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ", %ret)
; CHECK: } ; CHECK: }
declare void @"\01?may_throw@@YAXXZ"() #1 declare void @"\01?may_throw@@YAXXZ"() #1
Show All 29 Lines

test/CodeGen/WinEH/cppeh-nested-1.ll

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
invoke.cont: ; preds = %entry invoke.cont: ; preds = %entry
br label %try.cont br label %try.cont
; CHECK: [[LPAD_LABEL]]: ; CHECK: [[LPAD_LABEL]]:
; CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) ; CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*) ; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*) ; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
; CHECK: [[RECOVER:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32 0, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch", i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), i32 1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch1") ; CHECK: [[RECOVER:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32 0, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch", i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), i32 1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch.1")
; CHECK: indirectbr i8* [[RECOVER]], [label %try.cont, label %try.cont10] ; CHECK: indirectbr i8* [[RECOVER]], [label %try.cont, label %try.cont10]
lpad: ; preds = %entry lpad: ; preds = %entry
%0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*) catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*) catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
%1 = extractvalue { i8*, i32 } %0, 0 %1 = extractvalue { i8*, i32 } %0, 0
store i8* %1, i8** %exn.slot store i8* %1, i8** %exn.slot
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Lines
; CHECK: to label %invoke.cont2 unwind label %[[LPAD1_LABEL:lpad[0-9]*]] ; CHECK: to label %invoke.cont2 unwind label %[[LPAD1_LABEL:lpad[0-9]*]]
; ;
; CHECK: invoke.cont2: ; CHECK: invoke.cont2:
; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont) ; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont)
; ;
; CHECK: [[LPAD1_LABEL]]:{{[ ]+}}; preds = %entry ; CHECK: [[LPAD1_LABEL]]:{{[ ]+}}; preds = %entry
; CHECK: [[LPAD1_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) ; CHECK: [[LPAD1_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*) ; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
; CHECK: [[RECOVER1:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), i32 1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch1") ; CHECK: [[RECOVER1:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), i32 1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch.1")
; CHECK: indirectbr i8* [[RECOVER1]], [] ; CHECK: indirectbr i8* [[RECOVER1]], []
; ;
; CHECK: } ; CHECK: }
; CHECK: define internal i8* @"\01?test@@YAXXZ.catch1"(i8*, i8*) ; CHECK: define internal i8* @"\01?test@@YAXXZ.catch.1"(i8*, i8*)
; CHECK: entry: ; CHECK: entry:
; CHECK: [[RECOVER_F1:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 1) ; CHECK: [[RECOVER_F1:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 1)
; CHECK: [[F_PTR1:\%.+]] = bitcast i8* [[RECOVER_F1]] to float* ; CHECK: [[F_PTR1:\%.+]] = bitcast i8* [[RECOVER_F1]] to float*
; CHECK: [[TMP2:\%.+]] = load float, float* [[F_PTR1]], align 4 ; CHECK: [[TMP2:\%.+]] = load float, float* [[F_PTR1]], align 4
; CHECK: call void @"\01?handle_float@@YAXM@Z"(float [[TMP2]]) ; CHECK: call void @"\01?handle_float@@YAXM@Z"(float [[TMP2]])
; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont10) ; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont10)
; CHECK: } ; CHECK: }
Show All 30 Lines

test/CodeGen/WinEH/cppeh-nested-2.ll

Show First 20 Lines • Show All 105 Lines • ▼ Show 20 Lineslpad: ; preds = %try.cont, %entry
br label %catch.dispatch11 br label %catch.dispatch11
; CHECK: [[LPAD1_LABEL]]: ; CHECK: [[LPAD1_LABEL]]:
; CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) ; CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
; CHECK-NEXT: cleanup ; CHECK-NEXT: cleanup
; CHECK-NEXT: catch i8* bitcast (i8** @_ZTIi to i8*) ; CHECK-NEXT: catch i8* bitcast (i8** @_ZTIi to i8*)
; CHECK-NEXT: catch i8* bitcast (i8** @_ZTIf to i8*) ; CHECK-NEXT: catch i8* bitcast (i8** @_ZTIf to i8*)
; CHECK-NEXT: [[RECOVER1:\%.+]] = call i8* (...) @llvm.eh.actions( ; CHECK-NEXT: [[RECOVER1:\%.+]] = call i8* (...) @llvm.eh.actions(
; CHECK-SAME: i32 1, i8* bitcast (i8** @_ZTIi to i8*), i32 1, i8* (i8*, i8*)* @_Z4testv.catch1, ; CHECK-SAME: i32 1, i8* bitcast (i8** @_ZTIi to i8*), i32 1, i8* (i8*, i8*)* @_Z4testv.catch.1,
; CHECK-SAME: i32 0, void (i8*, i8*)* @_Z4testv.cleanup, ; CHECK-SAME: i32 0, void (i8*, i8*)* @_Z4testv.cleanup,
; CHECK-SAME: i32 1, i8* bitcast (i8** @_ZTIf to i8*), i32 0, i8* (i8*, i8*)* @_Z4testv.catch) ; CHECK-SAME: i32 1, i8* bitcast (i8** @_ZTIf to i8*), i32 0, i8* (i8*, i8*)* @_Z4testv.catch)
; CHECK-NEXT: indirectbr i8* [[RECOVER1]], [label %try.cont, label %try.cont19] ; CHECK-NEXT: indirectbr i8* [[RECOVER1]], [label %try.cont, label %try.cont19]
lpad1: ; preds = %invoke.cont4, %invoke.cont lpad1: ; preds = %invoke.cont4, %invoke.cont
%tmp3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) %tmp3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
cleanup cleanup
catch i8* bitcast (i8** @_ZTIi to i8*) catch i8* bitcast (i8** @_ZTIi to i8*)
catch i8* bitcast (i8** @_ZTIf to i8*) catch i8* bitcast (i8** @_ZTIf to i8*)
%tmp4 = extractvalue { i8*, i32 } %tmp3, 0 %tmp4 = extractvalue { i8*, i32 } %tmp3, 0
store i8* %tmp4, i8** %exn.slot store i8* %tmp4, i8** %exn.slot
%tmp5 = extractvalue { i8*, i32 } %tmp3, 1 %tmp5 = extractvalue { i8*, i32 } %tmp3, 1
store i32 %tmp5, i32* %ehselector.slot store i32 %tmp5, i32* %ehselector.slot
br label %catch.dispatch br label %catch.dispatch
; CHECK: [[LPAD3_LABEL]]: ; CHECK: [[LPAD3_LABEL]]:
; CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) ; CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
; CHECK-NEXT: cleanup ; CHECK-NEXT: cleanup
; CHECK-NEXT: catch i8* bitcast (i8** @_ZTIi to i8*) ; CHECK-NEXT: catch i8* bitcast (i8** @_ZTIi to i8*)
; CHECK-NEXT: catch i8* bitcast (i8** @_ZTIf to i8*) ; CHECK-NEXT: catch i8* bitcast (i8** @_ZTIf to i8*)
; CHECK-NEXT: [[RECOVER3:\%.+]] = call i8* (...) @llvm.eh.actions( ; CHECK-NEXT: [[RECOVER3:\%.+]] = call i8* (...) @llvm.eh.actions(
; CHECK-SAME: i32 0, void (i8*, i8*)* @_Z4testv.cleanup2, ; CHECK-SAME: i32 0, void (i8*, i8*)* @_Z4testv.cleanup.2,
; CHECK-SAME: i32 1, i8* bitcast (i8** @_ZTIi to i8*), i32 1, i8* (i8*, i8*)* @_Z4testv.catch1, ; CHECK-SAME: i32 1, i8* bitcast (i8** @_ZTIi to i8*), i32 1, i8* (i8*, i8*)* @_Z4testv.catch.1,
; CHECK-SAME: i32 0, void (i8*, i8*)* @_Z4testv.cleanup, ; CHECK-SAME: i32 0, void (i8*, i8*)* @_Z4testv.cleanup,
; CHECK-SAME: i32 1, i8* bitcast (i8** @_ZTIf to i8*), i32 0, i8* (i8*, i8*)* @_Z4testv.catch) ; CHECK-SAME: i32 1, i8* bitcast (i8** @_ZTIf to i8*), i32 0, i8* (i8*, i8*)* @_Z4testv.catch)
; CHECK-NEXT: indirectbr i8* [[RECOVER3]], [label %try.cont, label %try.cont19] ; CHECK-NEXT: indirectbr i8* [[RECOVER3]], [label %try.cont, label %try.cont19]
lpad3: ; preds = %invoke.cont2 lpad3: ; preds = %invoke.cont2
%tmp6 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) %tmp6 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
cleanup cleanup
catch i8* bitcast (i8** @_ZTIi to i8*) catch i8* bitcast (i8** @_ZTIi to i8*)
▲ Show 20 Lines • Show All 100 Lines • ▼ Show 20 Lines
; CHECK: [[RECOVER_F:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @_Z4testv to i8*), i8* %1, i32 0) ; CHECK: [[RECOVER_F:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @_Z4testv to i8*), i8* %1, i32 0)
; CHECK: [[F_PTR:\%.+]] = bitcast i8* [[RECOVER_F]] to float* ; CHECK: [[F_PTR:\%.+]] = bitcast i8* [[RECOVER_F]] to float*
; CHECK: [[TMP:\%.+]] = load float, float* [[F_PTR]], align 4 ; CHECK: [[TMP:\%.+]] = load float, float* [[F_PTR]], align 4
; CHECK: call void @_Z12handle_floatf(float [[TMP]]) ; CHECK: call void @_Z12handle_floatf(float [[TMP]])
; CHECK: ret i8* blockaddress(@_Z4testv, %try.cont19) ; CHECK: ret i8* blockaddress(@_Z4testv, %try.cont19)
; CHECK: } ; CHECK: }
; This catch handler should be outlined. ; This catch handler should be outlined.
; CHECK: define internal i8* @_Z4testv.catch1(i8*, i8*) ; CHECK: define internal i8* @_Z4testv.catch.1(i8*, i8*)
; CHECK: entry: ; CHECK: entry:
; CHECK: [[RECOVER_I:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @_Z4testv to i8*), i8* %1, i32 1) ; CHECK: [[RECOVER_I:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @_Z4testv to i8*), i8* %1, i32 1)
; CHECK: [[I_PTR:\%.+]] = bitcast i8* [[RECOVER_I]] to i32* ; CHECK: [[I_PTR:\%.+]] = bitcast i8* [[RECOVER_I]] to i32*
; CHECK: [[TMP1:\%.+]] = load i32, i32* [[I_PTR]], align 4 ; CHECK: [[TMP1:\%.+]] = load i32, i32* [[I_PTR]], align 4
; CHECK: invoke void @_Z10handle_inti(i32 [[TMP1]]) ; CHECK: invoke void @_Z10handle_inti(i32 [[TMP1]])
; CHECK: to label %invoke.cont8 unwind label %[[LPAD7_LABEL:lpad[0-9]*]] ; CHECK: to label %invoke.cont8 unwind label %[[LPAD7_LABEL:lpad[0-9]*]]
; ;
; CHECK: invoke.cont8: ; preds = %entry ; CHECK: invoke.cont8: ; preds = %entry
Show All 9 Lines
; CHECK: entry: ; CHECK: entry:
; CHECK: [[RECOVER_OUTER:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @_Z4testv to i8*), i8* %1, i32 2) ; CHECK: [[RECOVER_OUTER:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @_Z4testv to i8*), i8* %1, i32 2)
; CHECK: [[OUTER_PTR:\%.+]] = bitcast i8* [[RECOVER_OUTER]] to %class.Outer* ; CHECK: [[OUTER_PTR:\%.+]] = bitcast i8* [[RECOVER_OUTER]] to %class.Outer*
; CHECK: call void @_ZN5OuterD1Ev(%class.Outer* [[OUTER_PTR]]) ; CHECK: call void @_ZN5OuterD1Ev(%class.Outer* [[OUTER_PTR]])
; CHECK: ret void ; CHECK: ret void
; CHECK: } ; CHECK: }
; This cleanup handler should be outlined. ; This cleanup handler should be outlined.
; CHECK: define internal void @_Z4testv.cleanup2(i8*, i8*) ; CHECK: define internal void @_Z4testv.cleanup.2(i8*, i8*)
; CHECK: entry: ; CHECK: entry:
; CHECK: [[RECOVER_INNER:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @_Z4testv to i8*), i8* %1, i32 3) ; CHECK: [[RECOVER_INNER:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @_Z4testv to i8*), i8* %1, i32 3)
; CHECK: [[INNER_PTR:\%.+]] = bitcast i8* [[RECOVER_INNER]] to %class.Inner* ; CHECK: [[INNER_PTR:\%.+]] = bitcast i8* [[RECOVER_INNER]] to %class.Inner*
; CHECK: call void @_ZN5InnerD1Ev(%class.Inner* [[INNER_PTR]]) ; CHECK: call void @_ZN5InnerD1Ev(%class.Inner* [[INNER_PTR]])
; CHECK: ret void ; CHECK: ret void
; CHECK: } ; CHECK: }
Show All 36 Lines

test/CodeGen/WinEH/cppeh-nested-3.ll

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
invoke.cont: ; preds = %entry invoke.cont: ; preds = %entry
br label %try.cont10 br label %try.cont10
; CHECK: [[LPAD_LABEL]]: ; CHECK: [[LPAD_LABEL]]:
; CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) ; CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*) ; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*) ; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
; CHECK: [[RECOVER:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32 0, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch", i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), i32 1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch1") ; CHECK: [[RECOVER:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32 0, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch", i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), i32 1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch.1")
; CHECK: indirectbr i8* [[RECOVER]], [label %try.cont10, label %try.cont19] ; CHECK: indirectbr i8* [[RECOVER]], [label %try.cont10, label %try.cont19]
lpad: ; preds = %entry lpad: ; preds = %entry
%0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*) catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*) catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
%1 = extractvalue { i8*, i32 } %0, 0 %1 = extractvalue { i8*, i32 } %0, 0
store i8* %1, i8** %exn.slot store i8* %1, i8** %exn.slot
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Lines
; CHECK: [[TMP1:\%.+]] = load i32, i32* [[I_PTR]], align 4 ; CHECK: [[TMP1:\%.+]] = load i32, i32* [[I_PTR]], align 4
; CHECK: invoke void @"\01?handle_int@@YAXH@Z"(i32 [[TMP1]]) ; CHECK: invoke void @"\01?handle_int@@YAXH@Z"(i32 [[TMP1]])
; CHECK: to label %invoke.cont9 unwind label %[[LPAD8_LABEL:lpad[0-9]*]] ; CHECK: to label %invoke.cont9 unwind label %[[LPAD8_LABEL:lpad[0-9]*]]
; ;
; CHECK: [[LPAD1_LABEL]]:{{[ ]+}}; preds = %entry ; CHECK: [[LPAD1_LABEL]]:{{[ ]+}}; preds = %entry
; CHECK: [[LPAD1_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) ; CHECK: [[LPAD1_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*) ; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*) ; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
; CHECK: [[RECOVER1:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32 2, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch2", i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), i32 1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch1") ; CHECK: [[RECOVER1:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32 2, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch.2", i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), i32 1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch.1")
; CHECK: indirectbr i8* [[RECOVER1]], [label %invoke.cont2] ; CHECK: indirectbr i8* [[RECOVER1]], [label %invoke.cont2]
; ;
; CHECK: invoke.cont9: ; CHECK: invoke.cont9:
; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont10) ; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont10)
; ;
; CHECK: [[LPAD8_LABEL]]:{{[ ]+}}; preds = %invoke.cont2 ; CHECK: [[LPAD8_LABEL]]:{{[ ]+}}; preds = %invoke.cont2
; CHECK: [[LPAD8_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) ; CHECK: [[LPAD8_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*) ; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
; CHECK: [[RECOVER2:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), i32 1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch1") ; CHECK: [[RECOVER2:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), i32 1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch.1")
; CHECK: indirectbr i8* [[RECOVER2]], [] ; CHECK: indirectbr i8* [[RECOVER2]], []
; ;
; CHECK: } ; CHECK: }
; CHECK: define internal i8* @"\01?test@@YAXXZ.catch1"(i8*, i8*) ; CHECK: define internal i8* @"\01?test@@YAXXZ.catch.1"(i8*, i8*)
; CHECK: entry: ; CHECK: entry:
; CHECK: [[RECOVER_F:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 1) ; CHECK: [[RECOVER_F:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 1)
; CHECK: [[F_PTR:\%.+]] = bitcast i8* [[RECOVER_F]] to float* ; CHECK: [[F_PTR:\%.+]] = bitcast i8* [[RECOVER_F]] to float*
; CHECK: [[TMP2:\%.+]] = load float, float* [[F_PTR]], align 4 ; CHECK: [[TMP2:\%.+]] = load float, float* [[F_PTR]], align 4
; CHECK: call void @"\01?handle_float@@YAXM@Z"(float [[TMP2]]) ; CHECK: call void @"\01?handle_float@@YAXM@Z"(float [[TMP2]])
; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont19) ; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont19)
; CHECK: } ; CHECK: }
; CHECK: define internal i8* @"\01?test@@YAXXZ.catch2"(i8*, i8*) ; CHECK: define internal i8* @"\01?test@@YAXXZ.catch.2"(i8*, i8*)
; CHECK: entry: ; CHECK: entry:
; CHECK: [[RECOVER_J:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 2) ; CHECK: [[RECOVER_J:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 2)
; CHECK: [[J_PTR:\%.+]] = bitcast i8* [[RECOVER_J]] to i32* ; CHECK: [[J_PTR:\%.+]] = bitcast i8* [[RECOVER_J]] to i32*
; CHECK: [[RECOVER_I1:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 0) ; CHECK: [[RECOVER_I1:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 0)
; CHECK: [[I_PTR1:\%.+]] = bitcast i8* [[RECOVER_I1]] to i32* ; CHECK: [[I_PTR1:\%.+]] = bitcast i8* [[RECOVER_I1]] to i32*
; CHECK: [[TMP3:\%.+]] = load i32, i32* [[J_PTR]], align 4 ; CHECK: [[TMP3:\%.+]] = load i32, i32* [[J_PTR]], align 4
; CHECK: store i32 [[TMP3]], i32* [[I_PTR1]] ; CHECK: store i32 [[TMP3]], i32* [[I_PTR1]]
; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ.catch", %invoke.cont2) ; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ.catch", %invoke.cont2)
Show All 32 Lines

test/Instrumentation/AddressSanitizer/global_metadata.ll

Show All 10 Lines
@.str = private unnamed_addr constant [14 x i8] c"Hello, world!\00", align 1 @.str = private unnamed_addr constant [14 x i8] c"Hello, world!\00", align 1
@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @_GLOBAL__sub_I_asan_globals.cpp, i8* null }] @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @_GLOBAL__sub_I_asan_globals.cpp, i8* null }]
; Check that globals were instrumented: ; Check that globals were instrumented:
; CHECK: @global = global { i32, [60 x i8] } zeroinitializer, align 32 ; CHECK: @global = global { i32, [60 x i8] } zeroinitializer, align 32
; CHECK: @.str = internal unnamed_addr constant { [14 x i8], [50 x i8] } { [14 x i8] c"Hello, world!\00", [50 x i8] zeroinitializer }, align 32 ; CHECK: @.str = internal unnamed_addr constant { [14 x i8], [50 x i8] } { [14 x i8] c"Hello, world!\00", [50 x i8] zeroinitializer }, align 32
; Check emitted location descriptions: ; Check emitted location descriptions:
; CHECK: [[VARNAME:@__asan_gen_[0-9]+]] = private unnamed_addr constant [7 x i8] c"global\00", align 1 ; CHECK: [[VARNAME:@__asan_gen_.[0-9]+]] = private unnamed_addr constant [7 x i8] c"global\00", align 1
; CHECK: [[FILENAME:@__asan_gen_[0-9]+]] = private unnamed_addr constant [22 x i8] c"/tmp/asan-globals.cpp\00", align 1 ; CHECK: [[FILENAME:@__asan_gen_.[0-9]+]] = private unnamed_addr constant [22 x i8] c"/tmp/asan-globals.cpp\00", align 1
; CHECK: [[LOCDESCR:@__asan_gen_[0-9]+]] = private unnamed_addr constant { [22 x i8]*, i32, i32 } { [22 x i8]* [[FILENAME]], i32 5, i32 5 } ; CHECK: [[LOCDESCR:@__asan_gen_.[0-9]+]] = private unnamed_addr constant { [22 x i8]*, i32, i32 } { [22 x i8]* [[FILENAME]], i32 5, i32 5 }
; Check that location decriptors and global names were passed into __asan_register_globals: ; Check that location decriptors and global names were passed into __asan_register_globals:
; CHECK: i64 ptrtoint ([7 x i8]* [[VARNAME]] to i64) ; CHECK: i64 ptrtoint ([7 x i8]* [[VARNAME]] to i64)
; CHECK: i64 ptrtoint ({ [22 x i8]*, i32, i32 }* [[LOCDESCR]] to i64) ; CHECK: i64 ptrtoint ({ [22 x i8]*, i32, i32 }* [[LOCDESCR]] to i64)
; Function Attrs: nounwind sanitize_address ; Function Attrs: nounwind sanitize_address
define internal void @__cxx_global_var_init() #0 section ".text.startup" { define internal void @__cxx_global_var_init() #0 section ".text.startup" {
entry: entry:
Show All 38 Lines

test/Linker/2011-08-04-Metadata.ll

; RUN: llvm-link %s %p/2011-08-04-Metadata2.ll -o %t.bc ; RUN: llvm-link %s %p/2011-08-04-Metadata2.ll -o %t.bc
; RUN: llvm-dis < %t.bc | FileCheck %s ; RUN: llvm-dis < %t.bc | FileCheck %s
; Test if internal global variable's debug info is merged appropriately or not. ; Test if internal global variable's debug info is merged appropriately or not.
; CHECK: !DIGlobalVariable(name: "x", ; CHECK: !DIGlobalVariable(name: "x",
; CHECK-NOT: linkageName: ; CHECK-NOT: linkageName:
; CHECK-SAME: variable: i32* @x{{[,)]}} ; CHECK-SAME: variable: i32* @x{{[,)]}}
; CHECK: !DIGlobalVariable(name: "x", ; CHECK: !DIGlobalVariable(name: "x",
; CHECK-NOT: linkageName: ; CHECK-NOT: linkageName:
; CHECK-SAME: variable: i32* @x1{{[,)]}} ; CHECK-SAME: variable: i32* @x.1{{[,)]}}
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-apple-macosx10.7.0" target triple = "x86_64-apple-macosx10.7.0"
@x = internal global i32 0, align 4 @x = internal global i32 0, align 4
define void @foo() nounwind uwtable ssp { define void @foo() nounwind uwtable ssp {
entry: entry:
store i32 1, i32* @x, align 4, !dbg !7 store i32 1, i32* @x, align 4, !dbg !7
Show All 20 Lines

test/Linker/override-with-internal-linkage-2.ll

; RUN: llvm-link %s -override %S/Inputs/override-with-internal-linkage-2.ll -S | FileCheck %s ; RUN: llvm-link %s -override %S/Inputs/override-with-internal-linkage-2.ll -S | FileCheck %s
; RUN: llvm-link -override %S/Inputs/override-with-internal-linkage-2.ll %s -S | FileCheck %s ; RUN: llvm-link -override %S/Inputs/override-with-internal-linkage-2.ll %s -S | FileCheck %s
; CHECK-LABEL: define i32 @foo ; CHECK-LABEL: define i32 @foo
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: %add = add nsw i32 %i, %i ; CHECK-NEXT: %add = add nsw i32 %i, %i
; CHECK-NEXT: ret i32 %add ; CHECK-NEXT: ret i32 %add
define i32 @foo(i32 %i) { define i32 @foo(i32 %i) {
entry: entry:
%add = add nsw i32 %i, %i %add = add nsw i32 %i, %i
ret i32 %add ret i32 %add
} }
; CHECK-LABEL: define internal i32 @foo1 ; CHECK-LABEL: define internal i32 @foo.1
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret i32 4 ; CHECK-NEXT: ret i32 4
; Function Attrs: nounwind ssp uwtable ; Function Attrs: nounwind ssp uwtable
define i32 @main(i32 %argc, i8** %argv) { define i32 @main(i32 %argc, i8** %argv) {
entry: entry:
%a = call i32 @foo(i32 2) %a = call i32 @foo(i32 2)
ret i32 %a ret i32 %a
} }

test/Linker/testlink.ll

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
; CHECK-DAG: @MyVar = global i32 4 ; CHECK-DAG: @MyVar = global i32 4
@MyVar = external global i32 @MyVar = external global i32
; Take value from other module. ; Take value from other module.
; CHECK-DAG: AConst = constant i32 1234 ; CHECK-DAG: AConst = constant i32 1234
@AConst = linkonce constant i32 123 @AConst = linkonce constant i32 123
; Renamed version of Intern1. ; Renamed version of Intern1.
; CHECK-DAG: @Intern1{{[0-9]+}} = internal constant i32 52 ; CHECK-DAG: @Intern1.{{[0-9]+}} = internal constant i32 52
; Globals linked from testlink2. ; Globals linked from testlink2.
; CHECK-DAG: @Intern2 = constant i32 12345 ; CHECK-DAG: @Intern2 = constant i32 12345
; CHECK-DAG: @MyIntListPtr = constant ; CHECK-DAG: @MyIntListPtr = constant
; CHECK-DAG: @1 = constant i32 412 ; CHECK-DAG: @1 = constant i32 412
Show All 32 Lines

test/Transforms/BBVectorize/simple3.ll

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" 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"
; RUN: opt < %s -bb-vectorize -bb-vectorize-req-chain-depth=3 -bb-vectorize-vector-bits=192 -bb-vectorize-ignore-target-info -instcombine -gvn -S | FileCheck %s ; RUN: opt < %s -bb-vectorize -bb-vectorize-req-chain-depth=3 -bb-vectorize-vector-bits=192 -bb-vectorize-ignore-target-info -instcombine -gvn -S | FileCheck %s
; Basic depth-3 chain ; Basic depth-3 chain
define double @test1(double %A1, double %A2, double %A3, double %B1, double %B2, double %B3) { define double @test1(double %A1, double %A2, double %A3, double %B1, double %B2, double %B3) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK: %X1.v.i1.11 = insertelement <3 x double> undef, double %B1, i32 0 ; CHECK: %X1.v.i1.1.1 = insertelement <3 x double> undef, double %B1, i32 0
; CHECK: %X1.v.i1.22 = insertelement <3 x double> %X1.v.i1.11, double %B2, i32 1 ; CHECK: %X1.v.i1.2.2 = insertelement <3 x double> %X1.v.i1.1.1, double %B2, i32 1
; CHECK: %X1.v.i1 = insertelement <3 x double> %X1.v.i1.22, double %B3, i32 2 ; CHECK: %X1.v.i1 = insertelement <3 x double> %X1.v.i1.2.2, double %B3, i32 2
; CHECK: %X1.v.i0.13 = insertelement <3 x double> undef, double %A1, i32 0 ; CHECK: %X1.v.i0.1.3 = insertelement <3 x double> undef, double %A1, i32 0
; CHECK: %X1.v.i0.24 = insertelement <3 x double> %X1.v.i0.13, double %A2, i32 1 ; CHECK: %X1.v.i0.2.4 = insertelement <3 x double> %X1.v.i0.1.3, double %A2, i32 1
; CHECK: %X1.v.i0 = insertelement <3 x double> %X1.v.i0.24, double %A3, i32 2 ; CHECK: %X1.v.i0 = insertelement <3 x double> %X1.v.i0.2.4, double %A3, i32 2
%X1 = fsub double %A1, %B1 %X1 = fsub double %A1, %B1
%X2 = fsub double %A2, %B2 %X2 = fsub double %A2, %B2
%X3 = fsub double %A3, %B3 %X3 = fsub double %A3, %B3
; CHECK: %X1 = fsub <3 x double> %X1.v.i0, %X1.v.i1 ; CHECK: %X1 = fsub <3 x double> %X1.v.i0, %X1.v.i1
%Y1 = fmul double %X1, %A1 %Y1 = fmul double %X1, %A1
%Y2 = fmul double %X2, %A2 %Y2 = fmul double %X2, %A2
%Y3 = fmul double %X3, %A3 %Y3 = fmul double %X3, %A3
; CHECK: %Y1 = fmul <3 x double> %X1, %X1.v.i0 ; CHECK: %Y1 = fmul <3 x double> %X1, %X1.v.i0
%Z1 = fadd double %Y1, %B1 %Z1 = fadd double %Y1, %B1
%Z2 = fadd double %Y2, %B2 %Z2 = fadd double %Y2, %B2
%Z3 = fadd double %Y3, %B3 %Z3 = fadd double %Y3, %B3
; CHECK: %Z1 = fadd <3 x double> %Y1, %X1.v.i1 ; CHECK: %Z1 = fadd <3 x double> %Y1, %X1.v.i1
%R1 = fmul double %Z1, %Z2 %R1 = fmul double %Z1, %Z2
%R = fmul double %R1, %Z3 %R = fmul double %R1, %Z3
; CHECK: %Z1.v.r210 = extractelement <3 x double> %Z1, i32 2 ; CHECK: %Z1.v.r2.10 = extractelement <3 x double> %Z1, i32 2
; CHECK: %Z1.v.r1 = extractelement <3 x double> %Z1, i32 0 ; CHECK: %Z1.v.r1 = extractelement <3 x double> %Z1, i32 0
; CHECK: %Z1.v.r2 = extractelement <3 x double> %Z1, i32 1 ; CHECK: %Z1.v.r2 = extractelement <3 x double> %Z1, i32 1
; CHECK: %R1 = fmul double %Z1.v.r1, %Z1.v.r2 ; CHECK: %R1 = fmul double %Z1.v.r1, %Z1.v.r2
; CHECK: %R = fmul double %R1, %Z1.v.r210 ; CHECK: %R = fmul double %R1, %Z1.v.r2.10
ret double %R ret double %R
; CHECK: ret double %R ; CHECK: ret double %R
} }

test/Transforms/Inline/noalias-cs.ll

Show All 28 Lines
; CHECK: %arrayidx.i.i = getelementptr inbounds float, float* %a, i64 5 ; CHECK: %arrayidx.i.i = getelementptr inbounds float, float* %a, i64 5
; CHECK: store float %0, float* %arrayidx.i.i, align 4, !alias.scope !12, !noalias !13 ; CHECK: store float %0, float* %arrayidx.i.i, align 4, !alias.scope !12, !noalias !13
; CHECK: %arrayidx1.i.i = getelementptr inbounds float, float* %b, i64 8 ; CHECK: %arrayidx1.i.i = getelementptr inbounds float, float* %b, i64 8
; CHECK: store float %0, float* %arrayidx1.i.i, align 4, !alias.scope !14, !noalias !15 ; CHECK: store float %0, float* %arrayidx1.i.i, align 4, !alias.scope !14, !noalias !15
; CHECK: %1 = load float, float* %c, align 4, !noalias !16 ; CHECK: %1 = load float, float* %c, align 4, !noalias !16
; CHECK: %arrayidx.i = getelementptr inbounds float, float* %a, i64 7 ; CHECK: %arrayidx.i = getelementptr inbounds float, float* %a, i64 7
; CHECK: store float %1, float* %arrayidx.i, align 4, !noalias !16 ; CHECK: store float %1, float* %arrayidx.i, align 4, !noalias !16
; CHECK: %2 = load float, float* %a, align 4, !alias.scope !16, !noalias !17 ; CHECK: %2 = load float, float* %a, align 4, !alias.scope !16, !noalias !17
; CHECK: %arrayidx.i.i1 = getelementptr inbounds float, float* %b, i64 5 ; CHECK: %arrayidx.i.i.1 = getelementptr inbounds float, float* %b, i64 5
; CHECK: store float %2, float* %arrayidx.i.i1, align 4, !alias.scope !21, !noalias !22 ; CHECK: store float %2, float* %arrayidx.i.i.1, align 4, !alias.scope !21, !noalias !22
; CHECK: %arrayidx1.i.i2 = getelementptr inbounds float, float* %b, i64 8 ; CHECK: %arrayidx1.i.i.2 = getelementptr inbounds float, float* %b, i64 8
; CHECK: store float %2, float* %arrayidx1.i.i2, align 4, !alias.scope !23, !noalias !24 ; CHECK: store float %2, float* %arrayidx1.i.i.2, align 4, !alias.scope !23, !noalias !24
; CHECK: %3 = load float, float* %a, align 4, !alias.scope !16 ; CHECK: %3 = load float, float* %a, align 4, !alias.scope !16
; CHECK: %arrayidx.i3 = getelementptr inbounds float, float* %b, i64 7 ; CHECK: %arrayidx.i.3 = getelementptr inbounds float, float* %b, i64 7
; CHECK: store float %3, float* %arrayidx.i3, align 4, !alias.scope !16 ; CHECK: store float %3, float* %arrayidx.i.3, align 4, !alias.scope !16
; CHECK: ret void ; CHECK: ret void
; CHECK: } ; CHECK: }
attributes #0 = { nounwind uwtable } attributes #0 = { nounwind uwtable }
!0 = !{!1} !0 = !{!1}
!1 = distinct !{!1, !2, !"hello: %a"} !1 = distinct !{!1, !2, !"hello: %a"}
!2 = distinct !{!2, !"hello"} !2 = distinct !{!2, !"hello"}
Show All 33 Lines

test/Transforms/Inline/noalias2.ll

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
; CHECK: entry: ; CHECK: entry:
; CHECK: %0 = load float, float* %c, align 4, !alias.scope !5, !noalias !10 ; CHECK: %0 = load float, float* %c, align 4, !alias.scope !5, !noalias !10
; CHECK: %arrayidx.i.i = getelementptr inbounds float, float* %a, i64 5 ; CHECK: %arrayidx.i.i = getelementptr inbounds float, float* %a, i64 5
; CHECK: store float %0, float* %arrayidx.i.i, align 4, !alias.scope !10, !noalias !5 ; CHECK: store float %0, float* %arrayidx.i.i, align 4, !alias.scope !10, !noalias !5
; CHECK: %1 = load float, float* %c, align 4, !alias.scope !13, !noalias !14 ; CHECK: %1 = load float, float* %c, align 4, !alias.scope !13, !noalias !14
; CHECK: %arrayidx.i = getelementptr inbounds float, float* %a, i64 7 ; CHECK: %arrayidx.i = getelementptr inbounds float, float* %a, i64 7
; CHECK: store float %1, float* %arrayidx.i, align 4, !alias.scope !14, !noalias !13 ; CHECK: store float %1, float* %arrayidx.i, align 4, !alias.scope !14, !noalias !13
; CHECK: %2 = load float, float* %c, align 4, !noalias !15 ; CHECK: %2 = load float, float* %c, align 4, !noalias !15
; CHECK: %arrayidx.i1 = getelementptr inbounds float, float* %a, i64 6 ; CHECK: %arrayidx.i.1 = getelementptr inbounds float, float* %a, i64 6
; CHECK: store float %2, float* %arrayidx.i1, align 4, !alias.scope !19, !noalias !20 ; CHECK: store float %2, float* %arrayidx.i.1, align 4, !alias.scope !19, !noalias !20
; CHECK: %arrayidx1.i = getelementptr inbounds float, float* %b, i64 8 ; CHECK: %arrayidx1.i = getelementptr inbounds float, float* %b, i64 8
; CHECK: store float %2, float* %arrayidx1.i, align 4, !alias.scope !20, !noalias !19 ; CHECK: store float %2, float* %arrayidx1.i, align 4, !alias.scope !20, !noalias !19
; CHECK: %3 = load float, float* %c, align 4 ; CHECK: %3 = load float, float* %c, align 4
; CHECK: %arrayidx = getelementptr inbounds float, float* %a, i64 7 ; CHECK: %arrayidx = getelementptr inbounds float, float* %a, i64 7
; CHECK: store float %3, float* %arrayidx, align 4 ; CHECK: store float %3, float* %arrayidx, align 4
; CHECK: ret void ; CHECK: ret void
; CHECK: } ; CHECK: }
Show All 24 Lines

test/Transforms/InstCombine/cast.ll

Show First 20 Lines • Show All 181 Lines • ▼ Show 20 Lines
} }
define i32 @test21(i32 %X) { define i32 @test21(i32 %X) {
%c1 = trunc i32 %X to i8 ; <i8> [#uses=1] %c1 = trunc i32 %X to i8 ; <i8> [#uses=1]
;; sext -> zext -> and -> nop ;; sext -> zext -> and -> nop
%c2 = sext i8 %c1 to i32 ; <i32> [#uses=1] %c2 = sext i8 %c1 to i32 ; <i32> [#uses=1]
%RV = and i32 %c2, 255 ; <i32> [#uses=1] %RV = and i32 %c2, 255 ; <i32> [#uses=1]
ret i32 %RV ret i32 %RV
; CHECK: %c21 = and i32 %X, 255 ; CHECK: %c2.1 = and i32 %X, 255
; CHECK: ret i32 %c21 ; CHECK: ret i32 %c2.1
} }
define i32 @test22(i32 %X) { define i32 @test22(i32 %X) {
%c1 = trunc i32 %X to i8 ; <i8> [#uses=1] %c1 = trunc i32 %X to i8 ; <i8> [#uses=1]
;; sext -> zext -> and -> nop ;; sext -> zext -> and -> nop
%c2 = sext i8 %c1 to i32 ; <i32> [#uses=1] %c2 = sext i8 %c1 to i32 ; <i32> [#uses=1]
%RV = shl i32 %c2, 24 ; <i32> [#uses=1] %RV = shl i32 %c2, 24 ; <i32> [#uses=1]
ret i32 %RV ret i32 %RV
▲ Show 20 Lines • Show All 940 Lines • Show Last 20 Lines

test/Transforms/InstCombine/shift.ll

Show First 20 Lines • Show All 569 Lines • ▼ Show 20 Lines; CHECK: and i8 %tmp49, 64
%tmp50 = mul i8 %tmp49, 64 %tmp50 = mul i8 %tmp49, 64
%tmp51 = xor i8 %tmp50, %tmp5 %tmp51 = xor i8 %tmp50, %tmp5
%tmp52 = and i8 %tmp51, -128 %tmp52 = and i8 %tmp51, -128
%tmp53 = lshr i8 %tmp52, 7 %tmp53 = lshr i8 %tmp52, 7
%tmp54 = mul i8 %tmp53, 16 %tmp54 = mul i8 %tmp53, 16
; CHECK: %0 = shl i8 %tmp4, 2 ; CHECK: %0 = shl i8 %tmp4, 2
; CHECK: %tmp54 = and i8 %0, 16 ; CHECK: %tmp54 = and i8 %0, 16
%tmp55 = xor i8 %tmp54, %tmp51 %tmp55 = xor i8 %tmp54, %tmp51
; CHECK: ret i8 %tmp551 ; CHECK: ret i8 %tmp55.1
ret i8 %tmp55 ret i8 %tmp55
} }
; PR9809 ; PR9809
define i32 @test40(i32 %a, i32 %b) nounwind { define i32 @test40(i32 %a, i32 %b) nounwind {
%shl1 = shl i32 1, %b %shl1 = shl i32 1, %b
%shl2 = shl i32 %shl1, 2 %shl2 = shl i32 %shl1, 2
%div = udiv i32 %a, %shl2 %div = udiv i32 %a, %shl2
▲ Show 20 Lines • Show All 151 Lines • ▼ Show 20 Lines
define i32 @test57(i32 %x) { define i32 @test57(i32 %x) {
%shr = ashr i32 %x, 1 %shr = ashr i32 %x, 1
%shl = shl i32 %shr, 4 %shl = shl i32 %shr, 4
%or = or i32 %shl, 7 %or = or i32 %shl, 7
ret i32 %or ret i32 %or
; CHECK-LABEL: @test57( ; CHECK-LABEL: @test57(
; CHECK: %shl = shl i32 %shr1, 4 ; CHECK: %shl = shl i32 %shr.1, 4
} }
define i32 @test58(i32 %x) { define i32 @test58(i32 %x) {
%shr = ashr i32 %x, 4 %shr = ashr i32 %x, 4
%shl = shl i32 %shr, 1 %shl = shl i32 %shr, 1
%or = or i32 %shl, 1 %or = or i32 %shl, 1
ret i32 %or ret i32 %or
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

test/Transforms/InstCombine/xor.ll

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines; CHECK-NEXT: ret i8 %A
%C = xor i8 %B, 17 ; <i8> [#uses=1] %C = xor i8 %B, 17 ; <i8> [#uses=1]
ret i8 %C ret i8 %C
} }
define i32 @test7(i32 %A, i32 %B) { define i32 @test7(i32 %A, i32 %B) {
; CHECK-LABEL: @test7( ; CHECK-LABEL: @test7(
; CHECK-NEXT: %A1 = and i32 %A, 7 ; CHECK-NEXT: %A1 = and i32 %A, 7
; CHECK-NEXT: %B1 = and i32 %B, 128 ; CHECK-NEXT: %B1 = and i32 %B, 128
; CHECK-NEXT: %C11 = or i32 %A1, %B1 ; CHECK-NEXT: %C1.1 = or i32 %A1, %B1
; CHECK-NEXT: ret i32 %C11 ; CHECK-NEXT: ret i32 %C1.1
%A1 = and i32 %A, 7 ; <i32> [#uses=1] %A1 = and i32 %A, 7 ; <i32> [#uses=1]
%B1 = and i32 %B, 128 ; <i32> [#uses=1] %B1 = and i32 %B, 128 ; <i32> [#uses=1]
%C1 = xor i32 %A1, %B1 ; <i32> [#uses=1] %C1 = xor i32 %A1, %B1 ; <i32> [#uses=1]
ret i32 %C1 ret i32 %C1
} }
define i8 @test8(i1 %c) { define i8 @test8(i1 %c) {
; CHECK-LABEL: @test8( ; CHECK-LABEL: @test8(
Show All 15 Lines; CHECK-NEXT: ret i1 %C
%B = xor i8 %A, 123 ; <i8> [#uses=1] %B = xor i8 %A, 123 ; <i8> [#uses=1]
%C = icmp eq i8 %B, 34 ; <i1> [#uses=1] %C = icmp eq i8 %B, 34 ; <i1> [#uses=1]
ret i1 %C ret i1 %C
} }
define i8 @test10(i8 %A) { define i8 @test10(i8 %A) {
; CHECK-LABEL: @test10( ; CHECK-LABEL: @test10(
; CHECK-NEXT: %B = and i8 %A, 3 ; CHECK-NEXT: %B = and i8 %A, 3
; CHECK-NEXT: %C1 = or i8 %B, 4 ; CHECK-NEXT: %C.1 = or i8 %B, 4
; CHECK-NEXT: ret i8 %C1 ; CHECK-NEXT: ret i8 %C.1
%B = and i8 %A, 3 ; <i8> [#uses=1] %B = and i8 %A, 3 ; <i8> [#uses=1]
%C = xor i8 %B, 4 ; <i8> [#uses=1] %C = xor i8 %B, 4 ; <i8> [#uses=1]
ret i8 %C ret i8 %C
} }
define i8 @test11(i8 %A) { define i8 @test11(i8 %A) {
; CHECK-LABEL: @test11( ; CHECK-LABEL: @test11(
; CHECK-NEXT: %B = and i8 %A, -13 ; CHECK-NEXT: %B = and i8 %A, -13
▲ Show 20 Lines • Show All 169 Lines • Show Last 20 Lines

test/Transforms/LoopIdiom/basic.ll

; RUN: opt -basicaa -loop-idiom < %s -S | FileCheck %s ; RUN: opt -basicaa -loop-idiom < %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"
; For @test11_pattern ; For @test11_pattern
; CHECK: @.memset_pattern = private unnamed_addr constant [4 x i32] [i32 1, i32 1, i32 1, i32 1] ; CHECK: @.memset_pattern = private unnamed_addr constant [4 x i32] [i32 1, i32 1, i32 1, i32 1]
; For @test13_pattern ; For @test13_pattern
; CHECK: @.memset_pattern1 = private unnamed_addr constant [2 x i32*] [i32* @G, i32* @G] ; CHECK: @.memset_pattern.1 = private unnamed_addr constant [2 x i32*] [i32* @G, i32* @G]
target triple = "x86_64-apple-darwin10.0.0" target triple = "x86_64-apple-darwin10.0.0"
define void @test1(i8* %Base, i64 %Size) nounwind ssp { define void @test1(i8* %Base, i64 %Size) nounwind ssp {
bb.nph: ; preds = %entry bb.nph: ; preds = %entry
br label %for.body br label %for.body
for.body: ; preds = %bb.nph, %for.body for.body: ; preds = %bb.nph, %for.body
▲ Show 20 Lines • Show All 410 Lines • Show Last 20 Lines

test/Transforms/LoopUnswitch/2011-11-18-SimpleSwitch.ll

Show All 28 Lines
; CHECK: .split..split.split_crit_edge: ; preds = %.split ; CHECK: .split..split.split_crit_edge: ; preds = %.split
; CHECK-NEXT: br label %.split.split ; CHECK-NEXT: br label %.split.split
; CHECK: .split.split.us: ; preds = %.split ; CHECK: .split.split.us: ; preds = %.split
; CHECK-NEXT: br label %loop_begin.us1 ; CHECK-NEXT: br label %loop_begin.us1
; CHECK: loop_begin.us1: ; preds = %loop_begin.backedge.us5, %.split.split.us ; CHECK: loop_begin.us1: ; preds = %loop_begin.backedge.us5, %.split.split.us
; CHECK-NEXT: %var_val.us2 = load i32, i32* %var ; CHECK-NEXT: %var_val.us.2 = load i32, i32* %var
; CHECK-NEXT: switch i32 2, label %default.us-lcssa.us-lcssa.us [ ; CHECK-NEXT: switch i32 2, label %default.us-lcssa.us-lcssa.us [
; CHECK-NEXT: i32 1, label %inc.us4 ; CHECK-NEXT: i32 1, label %inc.us4
; CHECK-NEXT: i32 2, label %dec.us3 ; CHECK-NEXT: i32 2, label %dec.us3
; CHECK-NEXT: ] ; CHECK-NEXT: ]
; CHECK: dec.us3: ; preds = %loop_begin.us1 ; CHECK: dec.us3: ; preds = %loop_begin.us1
; CHECK-NEXT: call void @decf() [[NOR_NUW]] ; CHECK-NEXT: call void @decf() [[NOR_NUW]]
; CHECK-NEXT: br label %loop_begin.backedge.us5 ; CHECK-NEXT: br label %loop_begin.backedge.us5
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

test/Transforms/LoopUnswitch/2011-11-18-TwoSwitches.ll

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 Lines
; CHECK: .split..split.split_crit_edge: ; preds = %.split ; CHECK: .split..split.split_crit_edge: ; preds = %.split
; CHECK-NEXT: br label %.split.split ; CHECK-NEXT: br label %.split.split
; CHECK: .split.split.us: ; preds = %.split ; CHECK: .split.split.us: ; preds = %.split
; CHECK-NEXT: br label %loop_begin.us1 ; CHECK-NEXT: br label %loop_begin.us1
; CHECK: loop_begin.us1: ; preds = %loop_begin.backedge.us6, %.split.split.us ; CHECK: loop_begin.us1: ; preds = %loop_begin.backedge.us6, %.split.split.us
; CHECK-NEXT: %var_val.us2 = load i32, i32* %var ; CHECK-NEXT: %var_val.us.2 = load i32, i32* %var
; CHECK-NEXT: switch i32 %c, label %second_switch.us3 [ ; CHECK-NEXT: switch i32 %c, label %second_switch.us3 [
; CHECK-NEXT: i32 1, label %loop_begin.inc_crit_edge.us ; CHECK-NEXT: i32 1, label %loop_begin.inc_crit_edge.us
; CHECK-NEXT: ] ; CHECK-NEXT: ]
; CHECK: second_switch.us3: ; preds = %loop_begin.us1 ; CHECK: second_switch.us3: ; preds = %loop_begin.us1
; CHECK-NEXT: switch i32 1, label %default.us5 [ ; CHECK-NEXT: switch i32 1, label %default.us5 [
; CHECK-NEXT: i32 1, label %inc.us4 ; CHECK-NEXT: i32 1, label %inc.us4
; CHECK-NEXT: ] ; CHECK-NEXT: ]
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

test/Transforms/LowerBitSets/simple.ll

Show All 33 Lines
; Entries whose second operand is null (the result of a global being DCE'd) ; Entries whose second operand is null (the result of a global being DCE'd)
; should be ignored. ; should be ignored.
!7 = !{!"bitset2", null, i32 0} !7 = !{!"bitset2", null, i32 0}
!llvm.bitsets = !{ !0, !1, !2, !3, !4, !5, !6, !7 } !llvm.bitsets = !{ !0, !1, !2, !3, !4, !5, !6, !7 }
; CHECK: @bits_use{{[0-9]*}} = private alias i8* @bits{{[0-9]*}} ; CHECK: @bits_use{{[0-9]*}} = private alias i8* @bits{{[0-9]*}}
; CHECK: @bits_use{{[0-9]*}} = private alias i8* @bits{{[0-9]*}} ; CHECK: @bits_use.{{[0-9]*}} = private alias i8* @bits{{[0-9]*}}
; CHECK: @bits_use{{[0-9]*}} = private alias i8* @bits{{[0-9]*}} ; CHECK: @bits_use.{{[0-9]*}} = private alias i8* @bits{{[0-9]*}}
; CHECK: @a = alias getelementptr inbounds ({ i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }, { i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }* [[G]], i32 0, i32 0) ; CHECK: @a = alias getelementptr inbounds ({ i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }, { i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }* [[G]], i32 0, i32 0)
; CHECK: @b = alias getelementptr inbounds ({ i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }, { i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }* [[G]], i32 0, i32 2) ; CHECK: @b = alias getelementptr inbounds ({ i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }, { i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }* [[G]], i32 0, i32 2)
; CHECK: @c = alias getelementptr inbounds ({ i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }, { i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }* [[G]], i32 0, i32 4) ; CHECK: @c = alias getelementptr inbounds ({ i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }, { i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }* [[G]], i32 0, i32 4)
; CHECK: @d = alias getelementptr inbounds ({ i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }, { i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }* [[G]], i32 0, i32 6) ; CHECK: @d = alias getelementptr inbounds ({ i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }, { i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }* [[G]], i32 0, i32 6)
; CHECK-DARWIN: @aptr = constant i32* getelementptr inbounds ({ i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }, { i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }* [[G:@[^ ]*]], i32 0, i32 0) ; CHECK-DARWIN: @aptr = constant i32* getelementptr inbounds ({ i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }, { i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }* [[G:@[^ ]*]], i32 0, i32 0)
@aptr = constant i32* @a @aptr = constant i32* @a
; CHECK-DARWIN: @bptr = constant [63 x i32]* getelementptr inbounds ({ i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }, { i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }* [[G]], i32 0, i32 2) ; CHECK-DARWIN: @bptr = constant [63 x i32]* getelementptr inbounds ({ i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }, { i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }* [[G]], i32 0, i32 2)
@bptr = constant [63 x i32]* @b @bptr = constant [63 x i32]* @b
; CHECK-DARWIN: @cptr = constant i32* getelementptr inbounds ({ i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }, { i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }* [[G]], i32 0, i32 4) ; CHECK-DARWIN: @cptr = constant i32* getelementptr inbounds ({ i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }, { i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }* [[G]], i32 0, i32 4)
@cptr = constant i32* @c @cptr = constant i32* @c
; CHECK-DARWIN: @dptr = constant [2 x i32]* getelementptr inbounds ({ i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }, { i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }* [[G]], i32 0, i32 6) ; CHECK-DARWIN: @dptr = constant [2 x i32]* getelementptr inbounds ({ i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }, { i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }* [[G]], i32 0, i32 6)
@dptr = constant [2 x i32]* @d @dptr = constant [2 x i32]* @d
; CHECK-DARWIN: [[G]] = private constant ; CHECK-DARWIN: [[G]] = private constant
; CHECK: @bits{{[0-9]*}} = private alias getelementptr inbounds ([68 x i8], [68 x i8]* [[BA]], i32 0, i32 0) ; CHECK: @bits{{[0-9]*}} = private alias getelementptr inbounds ([68 x i8], [68 x i8]* [[BA]], i32 0, i32 0)
; CHECK: @bits{{[0-9]*}} = private alias getelementptr inbounds ([68 x i8], [68 x i8]* [[BA]], i32 0, i32 0) ; CHECK: @bits.{{[0-9]*}} = private alias getelementptr inbounds ([68 x i8], [68 x i8]* [[BA]], i32 0, i32 0)
declare i1 @llvm.bitset.test(i8* %ptr, metadata %bitset) nounwind readnone declare i1 @llvm.bitset.test(i8* %ptr, metadata %bitset) nounwind readnone
; CHECK: @foo(i32* [[A0:%[^ ]*]]) ; CHECK: @foo(i32* [[A0:%[^ ]*]])
define i1 @foo(i32* %p) { define i1 @foo(i32* %p) {
; CHECK-NOT: llvm.bitset.test ; CHECK-NOT: llvm.bitset.test
; CHECK: [[R0:%[^ ]*]] = bitcast i32* [[A0]] to i8* ; CHECK: [[R0:%[^ ]*]] = bitcast i32* [[A0]] to i8*
%pi8 = bitcast i32* %p to i8* %pi8 = bitcast i32* %p to i8*
; CHECK: [[R1:%[^ ]*]] = ptrtoint i8* [[R0]] to i32 ; CHECK: [[R1:%[^ ]*]] = ptrtoint i8* [[R0]] to i32
; CHECK: [[R2:%[^ ]*]] = sub i32 [[R1]], ptrtoint ({ i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }* [[G]] to i32) ; CHECK: [[R2:%[^ ]*]] = sub i32 [[R1]], ptrtoint ({ i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }* [[G]] to i32)
; CHECK: [[R3:%[^ ]*]] = lshr i32 [[R2]], 2 ; CHECK: [[R3:%[^ ]*]] = lshr i32 [[R2]], 2
; CHECK: [[R4:%[^ ]*]] = shl i32 [[R2]], 30 ; CHECK: [[R4:%[^ ]*]] = shl i32 [[R2]], 30
; CHECK: [[R5:%[^ ]*]] = or i32 [[R3]], [[R4]] ; CHECK: [[R5:%[^ ]*]] = or i32 [[R3]], [[R4]]
; CHECK: [[R6:%[^ ]*]] = icmp ult i32 [[R5]], 68 ; CHECK: [[R6:%[^ ]*]] = icmp ult i32 [[R5]], 68
; CHECK: br i1 [[R6]] ; CHECK: br i1 [[R6]]
; CHECK: [[R8:%[^ ]*]] = getelementptr i8, i8* @bits_use{{[0-9]*}}, i32 [[R5]] ; CHECK: [[R8:%[^ ]*]] = getelementptr i8, i8* @bits_use.{{[0-9]*}}, i32 [[R5]]
; CHECK: [[R9:%[^ ]*]] = load i8, i8* [[R8]] ; CHECK: [[R9:%[^ ]*]] = load i8, i8* [[R8]]
; CHECK: [[R10:%[^ ]*]] = and i8 [[R9]], 1 ; CHECK: [[R10:%[^ ]*]] = and i8 [[R9]], 1
; CHECK: [[R11:%[^ ]*]] = icmp ne i8 [[R10]], 0 ; CHECK: [[R11:%[^ ]*]] = icmp ne i8 [[R10]], 0
; CHECK: [[R16:%[^ ]*]] = phi i1 [ false, {{%[^ ]*}} ], [ [[R11]], {{%[^ ]*}} ] ; CHECK: [[R16:%[^ ]*]] = phi i1 [ false, {{%[^ ]*}} ], [ [[R11]], {{%[^ ]*}} ]
%x = call i1 @llvm.bitset.test(i8* %pi8, metadata !"bitset1") %x = call i1 @llvm.bitset.test(i8* %pi8, metadata !"bitset1")
; CHECK-NOT: llvm.bitset.test ; CHECK-NOT: llvm.bitset.test
Show All 26 Linesdefine i1 @baz(i32* %p) {
; CHECK: [[T1:%[^ ]*]] = ptrtoint i8* [[T0]] to i32 ; CHECK: [[T1:%[^ ]*]] = ptrtoint i8* [[T0]] to i32
; CHECK: [[T2:%[^ ]*]] = sub i32 [[T1]], ptrtoint ({ i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }* [[G]] to i32) ; CHECK: [[T2:%[^ ]*]] = sub i32 [[T1]], ptrtoint ({ i32, [0 x i8], [63 x i32], [4 x i8], i32, [0 x i8], [2 x i32] }* [[G]] to i32)
; CHECK: [[T3:%[^ ]*]] = lshr i32 [[T2]], 2 ; CHECK: [[T3:%[^ ]*]] = lshr i32 [[T2]], 2
; CHECK: [[T4:%[^ ]*]] = shl i32 [[T2]], 30 ; CHECK: [[T4:%[^ ]*]] = shl i32 [[T2]], 30
; CHECK: [[T5:%[^ ]*]] = or i32 [[T3]], [[T4]] ; CHECK: [[T5:%[^ ]*]] = or i32 [[T3]], [[T4]]
; CHECK: [[T6:%[^ ]*]] = icmp ult i32 [[T5]], 66 ; CHECK: [[T6:%[^ ]*]] = icmp ult i32 [[T5]], 66
; CHECK: br i1 [[T6]] ; CHECK: br i1 [[T6]]
; CHECK: [[T8:%[^ ]*]] = getelementptr i8, i8* @bits_use{{[0-9]*}}, i32 [[T5]] ; CHECK: [[T8:%[^ ]*]] = getelementptr i8, i8* @bits_use.{{[0-9]*}}, i32 [[T5]]
; CHECK: [[T9:%[^ ]*]] = load i8, i8* [[T8]] ; CHECK: [[T9:%[^ ]*]] = load i8, i8* [[T8]]
; CHECK: [[T10:%[^ ]*]] = and i8 [[T9]], 2 ; CHECK: [[T10:%[^ ]*]] = and i8 [[T9]], 2
; CHECK: [[T11:%[^ ]*]] = icmp ne i8 [[T10]], 0 ; CHECK: [[T11:%[^ ]*]] = icmp ne i8 [[T10]], 0
; CHECK: [[T16:%[^ ]*]] = phi i1 [ false, {{%[^ ]*}} ], [ [[T11]], {{%[^ ]*}} ] ; CHECK: [[T16:%[^ ]*]] = phi i1 [ false, {{%[^ ]*}} ], [ [[T11]], {{%[^ ]*}} ]
%x = call i1 @llvm.bitset.test(i8* %pi8, metadata !"bitset3") %x = call i1 @llvm.bitset.test(i8* %pi8, metadata !"bitset3")
; CHECK: ret i1 [[T16]] ; CHECK: ret i1 [[T16]]
ret i1 %x ret i1 %x
} }
; CHECK-NOT: !llvm.bitsets ; CHECK-NOT: !llvm.bitsets

test/Transforms/LowerSwitch/feature.ll

; RUN: opt < %s -lowerswitch -S | FileCheck %s ; RUN: opt < %s -lowerswitch -S | FileCheck %s
; We have switch on input. ; We have switch on input.
; On output we should got binary comparison tree. Check that all is fine. ; On output we should got binary comparison tree. Check that all is fine.
;CHECK: entry: ;CHECK: entry:
;CHECK-NEXT: br label %NodeBlock19 ;CHECK-NEXT: br label %NodeBlock.19
;CHECK: NodeBlock19: ; preds = %entry ;CHECK: NodeBlock.19: ; preds = %entry
;CHECK-NEXT: %Pivot20 = icmp slt i32 %tmp158, 10 ;CHECK-NEXT: %Pivot.20 = icmp slt i32 %tmp158, 10
;CHECK-NEXT: br i1 %Pivot20, label %NodeBlock5, label %NodeBlock17 ;CHECK-NEXT: br i1 %Pivot.20, label %NodeBlock.5, label %NodeBlock.17
;CHECK: NodeBlock17: ; preds = %NodeBlock19 ;CHECK: NodeBlock.17: ; preds = %NodeBlock.19
;CHECK-NEXT: %Pivot18 = icmp slt i32 %tmp158, 13 ;CHECK-NEXT: %Pivot.18 = icmp slt i32 %tmp158, 13
;CHECK-NEXT: br i1 %Pivot18, label %NodeBlock9, label %NodeBlock15 ;CHECK-NEXT: br i1 %Pivot.18, label %NodeBlock.9, label %NodeBlock.15
;CHECK: NodeBlock15: ; preds = %NodeBlock17 ;CHECK: NodeBlock.15: ; preds = %NodeBlock.17
;CHECK-NEXT: %Pivot16 = icmp slt i32 %tmp158, 14 ;CHECK-NEXT: %Pivot.16 = icmp slt i32 %tmp158, 14
;CHECK-NEXT: br i1 %Pivot16, label %bb330, label %NodeBlock13 ;CHECK-NEXT: br i1 %Pivot.16, label %bb330, label %NodeBlock.13
;CHECK: NodeBlock13: ; preds = %NodeBlock15 ;CHECK: NodeBlock.13: ; preds = %NodeBlock.15
;CHECK-NEXT: %Pivot14 = icmp slt i32 %tmp158, 15 ;CHECK-NEXT: %Pivot.14 = icmp slt i32 %tmp158, 15
;CHECK-NEXT: br i1 %Pivot14, label %bb332, label %LeafBlock11 ;CHECK-NEXT: br i1 %Pivot.14, label %bb332, label %LeafBlock.11
;CHECK: LeafBlock11: ; preds = %NodeBlock13 ;CHECK: LeafBlock.11: ; preds = %NodeBlock.13
;CHECK-NEXT: %SwitchLeaf12 = icmp eq i32 %tmp158, 15 ;CHECK-NEXT: %SwitchLeaf12 = icmp eq i32 %tmp158, 15
;CHECK-NEXT: br i1 %SwitchLeaf12, label %bb334, label %NewDefault ;CHECK-NEXT: br i1 %SwitchLeaf12, label %bb334, label %NewDefault
;CHECK: NodeBlock9: ; preds = %NodeBlock17 ;CHECK: NodeBlock.9: ; preds = %NodeBlock.17
;CHECK-NEXT: %Pivot10 = icmp slt i32 %tmp158, 11 ;CHECK-NEXT: %Pivot.10 = icmp slt i32 %tmp158, 11
;CHECK-NEXT: br i1 %Pivot10, label %bb324, label %NodeBlock7 ;CHECK-NEXT: br i1 %Pivot.10, label %bb324, label %NodeBlock.7
;CHECK: NodeBlock7: ; preds = %NodeBlock9 ;CHECK: NodeBlock.7: ; preds = %NodeBlock.9
;CHECK-NEXT: %Pivot8 = icmp slt i32 %tmp158, 12 ;CHECK-NEXT: %Pivot.8 = icmp slt i32 %tmp158, 12
;CHECK-NEXT: br i1 %Pivot8, label %bb326, label %bb328 ;CHECK-NEXT: br i1 %Pivot.8, label %bb326, label %bb328
;CHECK: NodeBlock5: ; preds = %NodeBlock19 ;CHECK: NodeBlock.5: ; preds = %NodeBlock.19
;CHECK-NEXT: %Pivot6 = icmp slt i32 %tmp158, 7 ;CHECK-NEXT: %Pivot.6 = icmp slt i32 %tmp158, 7
;CHECK-NEXT: br i1 %Pivot6, label %NodeBlock, label %NodeBlock3 ;CHECK-NEXT: br i1 %Pivot.6, label %NodeBlock, label %NodeBlock.3
;CHECK: NodeBlock3: ; preds = %NodeBlock5 ;CHECK: NodeBlock.3: ; preds = %NodeBlock.5
;CHECK-NEXT: %Pivot4 = icmp slt i32 %tmp158, 8 ;CHECK-NEXT: %Pivot.4 = icmp slt i32 %tmp158, 8
;CHECK-NEXT: br i1 %Pivot4, label %bb, label %NodeBlock1 ;CHECK-NEXT: br i1 %Pivot.4, label %bb, label %NodeBlock.1
;CHECK: NodeBlock1: ; preds = %NodeBlock3 ;CHECK: NodeBlock.1: ; preds = %NodeBlock.3
;CHECK-NEXT: %Pivot2 = icmp slt i32 %tmp158, 9 ;CHECK-NEXT: %Pivot.2 = icmp slt i32 %tmp158, 9
;CHECK-NEXT: br i1 %Pivot2, label %bb338, label %bb322 ;CHECK-NEXT: br i1 %Pivot.2, label %bb338, label %bb322
;CHECK: NodeBlock: ; preds = %NodeBlock5 ;CHECK: NodeBlock: ; preds = %NodeBlock.5
;CHECK-NEXT: %Pivot = icmp slt i32 %tmp158, 0 ;CHECK-NEXT: %Pivot = icmp slt i32 %tmp158, 0
;CHECK-NEXT: br i1 %Pivot, label %LeafBlock, label %bb338 ;CHECK-NEXT: br i1 %Pivot, label %LeafBlock, label %bb338
;CHECK: LeafBlock: ; preds = %NodeBlock ;CHECK: LeafBlock: ; preds = %NodeBlock
;CHECK-NEXT: %tmp158.off = add i32 %tmp158, 6 ;CHECK-NEXT: %tmp158.off = add i32 %tmp158, 6
;CHECK-NEXT: %SwitchLeaf = icmp ule i32 %tmp158.off, 4 ;CHECK-NEXT: %SwitchLeaf = icmp ule i32 %tmp158.off, 4
;CHECK-NEXT: br i1 %SwitchLeaf, label %bb338, label %NewDefault ;CHECK-NEXT: br i1 %SwitchLeaf, label %bb338, label %NewDefault
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

test/Transforms/PlaceSafepoints/basic.ll

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
define i1 @test_call_with_result() gc "statepoint-example" { define i1 @test_call_with_result() gc "statepoint-example" {
; CHECK-LABEL: test_call_with_result ; CHECK-LABEL: test_call_with_result
; This is checking that a statepoint_poll + statepoint + result is ; This is checking that a statepoint_poll + statepoint + result is
; inserted for a function that takes 1 argument. ; inserted for a function that takes 1 argument.
; CHECK: gc.statepoint.p0f_isVoidf ; CHECK: gc.statepoint.p0f_isVoidf
; CHECK: gc.statepoint.p0f_i1i1f ; CHECK: gc.statepoint.p0f_i1i1f
; CHECK: (i1 (i1)* @i1_return_i1, i32 1, i32 0, i1 false, i32 0) ; CHECK: (i1 (i1)* @i1_return_i1, i32 1, i32 0, i1 false, i32 0)
; CHECK: %call12 = call i1 @llvm.experimental.gc.result.i1 ; CHECK: %call1.2 = call i1 @llvm.experimental.gc.result.i1
entry: entry:
%call1 = tail call i1 (i1) @i1_return_i1(i1 false) %call1 = tail call i1 (i1) @i1_return_i1(i1 false)
ret i1 %call1 ret i1 %call1
} }
; This function is inlined when inserting a poll. To avoid recursive ; This function is inlined when inserting a poll. To avoid recursive
; issues, make sure we don't place safepoints in it. ; issues, make sure we don't place safepoints in it.
declare void @do_safepoint() declare void @do_safepoint()
Show All 9 Lines

test/Transforms/SimplifyCFG/X86/switch_to_lookup_table.ll

; RUN: opt < %s -simplifycfg -S -mtriple=x86_64-unknown-linux-gnu | FileCheck %s ; RUN: opt < %s -simplifycfg -S -mtriple=x86_64-unknown-linux-gnu | 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"
; The table for @f ; The table for @f
; CHECK: @switch.table = private unnamed_addr constant [7 x i32] [i32 55, i32 123, i32 0, i32 -1, i32 27, i32 62, i32 1] ; CHECK: @switch.table = private unnamed_addr constant [7 x i32] [i32 55, i32 123, i32 0, i32 -1, i32 27, i32 62, i32 1]
; The float table for @h ; The float table for @h
; CHECK: @switch.table1 = private unnamed_addr constant [4 x float] [float 0x40091EB860000000, float 0x3FF3BE76C0000000, float 0x4012449BA0000000, float 0x4001AE1480000000] ; CHECK: @switch.table.1 = private unnamed_addr constant [4 x float] [float 0x40091EB860000000, float 0x3FF3BE76C0000000, float 0x4012449BA0000000, float 0x4001AE1480000000]
; The table for @foostring ; The table for @foostring
; CHECK: @switch.table2 = private unnamed_addr constant [4 x i8*] [i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str1, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str2, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str3, i64 0, i64 0)] ; CHECK: @switch.table.2 = private unnamed_addr constant [4 x i8*] [i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str1, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str2, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str3, i64 0, i64 0)]
; The table for @earlyreturncrash ; The table for @earlyreturncrash
; CHECK: @switch.table3 = private unnamed_addr constant [4 x i32] [i32 42, i32 9, i32 88, i32 5] ; CHECK: @switch.table.3 = private unnamed_addr constant [4 x i32] [i32 42, i32 9, i32 88, i32 5]
; The table for @large. ; The table for @large.
; CHECK: @switch.table4 = private unnamed_addr constant [199 x i32] [i32 1, i32 4, i32 9, ; CHECK: @switch.table.4 = private unnamed_addr constant [199 x i32] [i32 1, i32 4, i32 9,
; The table for @cprop ; The table for @cprop
; CHECK: @switch.table5 = private unnamed_addr constant [7 x i32] [i32 5, i32 42, i32 126, i32 -452, i32 128, i32 6, i32 7] ; CHECK: @switch.table.5 = private unnamed_addr constant [7 x i32] [i32 5, i32 42, i32 126, i32 -452, i32 128, i32 6, i32 7]
; The table for @unreachable_case ; The table for @unreachable_case
; CHECK: @switch.table6 = private unnamed_addr constant [9 x i32] [i32 0, i32 0, i32 0, i32 2, i32 -1, i32 1, i32 1, i32 1, i32 1] ; CHECK: @switch.table.6 = private unnamed_addr constant [9 x i32] [i32 0, i32 0, i32 0, i32 2, i32 -1, i32 1, i32 1, i32 1, i32 1]
; A simple int-to-int selection switch. ; A simple int-to-int selection switch.
; It is dense enough to be replaced by table lookup. ; It is dense enough to be replaced by table lookup.
; The result is directly by a ret from an otherwise empty bb, ; The result is directly by a ret from an otherwise empty bb,
; so we return early, directly from the lookup bb. ; so we return early, directly from the lookup bb.
define i32 @f(i32 %c) { define i32 @f(i32 %c) {
entry: entry:
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines
; CHECK: entry: ; CHECK: entry:
; CHECK-NEXT: %switch.tableidx = sub i32 %x, 0 ; CHECK-NEXT: %switch.tableidx = sub i32 %x, 0
; CHECK-NEXT: %0 = icmp ult i32 %switch.tableidx, 4 ; CHECK-NEXT: %0 = icmp ult i32 %switch.tableidx, 4
; CHECK-NEXT: br i1 %0, label %switch.lookup, label %sw.epilog ; CHECK-NEXT: br i1 %0, label %switch.lookup, label %sw.epilog
; CHECK: switch.lookup: ; CHECK: switch.lookup:
; CHECK-NEXT: %switch.shiftamt = mul i32 %switch.tableidx, 8 ; CHECK-NEXT: %switch.shiftamt = mul i32 %switch.tableidx, 8
; CHECK-NEXT: %switch.downshift = lshr i32 89655594, %switch.shiftamt ; CHECK-NEXT: %switch.downshift = lshr i32 89655594, %switch.shiftamt
; CHECK-NEXT: %switch.masked = trunc i32 %switch.downshift to i8 ; CHECK-NEXT: %switch.masked = trunc i32 %switch.downshift to i8
; CHECK-NEXT: %switch.gep = getelementptr inbounds [4 x float], [4 x float]* @switch.table1, i32 0, i32 %switch.tableidx ; CHECK-NEXT: %switch.gep = getelementptr inbounds [4 x float], [4 x float]* @switch.table.1, i32 0, i32 %switch.tableidx
; CHECK-NEXT: %switch.load = load float, float* %switch.gep ; CHECK-NEXT: %switch.load = load float, float* %switch.gep
; CHECK-NEXT: br label %sw.epilog ; CHECK-NEXT: br label %sw.epilog
; CHECK: sw.epilog: ; CHECK: sw.epilog:
; CHECK-NEXT: %a.0 = phi i8 [ %switch.masked, %switch.lookup ], [ 7, %entry ] ; CHECK-NEXT: %a.0 = phi i8 [ %switch.masked, %switch.lookup ], [ 7, %entry ]
; CHECK-NEXT: %b.0 = phi float [ %switch.load, %switch.lookup ], [ 0x4023FAE140000000, %entry ] ; CHECK-NEXT: %b.0 = phi float [ %switch.load, %switch.lookup ], [ 0x4023FAE140000000, %entry ]
; CHECK-NEXT: call void @dummy(i8 signext %a.0, float %b.0) ; CHECK-NEXT: call void @dummy(i8 signext %a.0, float %b.0)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
} }
Show All 30 Linesreturn:
ret i8* %retval.0 ret i8* %retval.0
; CHECK-LABEL: @foostring( ; CHECK-LABEL: @foostring(
; CHECK: entry: ; CHECK: entry:
; CHECK-NEXT: %switch.tableidx = sub i32 %x, 0 ; CHECK-NEXT: %switch.tableidx = sub i32 %x, 0
; CHECK-NEXT: %0 = icmp ult i32 %switch.tableidx, 4 ; CHECK-NEXT: %0 = icmp ult i32 %switch.tableidx, 4
; CHECK-NEXT: br i1 %0, label %switch.lookup, label %return ; CHECK-NEXT: br i1 %0, label %switch.lookup, label %return
; CHECK: switch.lookup: ; CHECK: switch.lookup:
; CHECK-NEXT: %switch.gep = getelementptr inbounds [4 x i8*], [4 x i8*]* @switch.table2, i32 0, i32 %switch.tableidx ; CHECK-NEXT: %switch.gep = getelementptr inbounds [4 x i8*], [4 x i8*]* @switch.table.2, i32 0, i32 %switch.tableidx
; CHECK-NEXT: %switch.load = load i8*, i8** %switch.gep ; CHECK-NEXT: %switch.load = load i8*, i8** %switch.gep
; CHECK-NEXT: ret i8* %switch.load ; CHECK-NEXT: ret i8* %switch.load
} }
; Switch used to initialize two values. The first value is returned, the second ; Switch used to initialize two values. The first value is returned, the second
; value is not used. This used to make the transformation generate illegal code. ; value is not used. This used to make the transformation generate illegal code.
define i32 @earlyreturncrash(i32 %x) { define i32 @earlyreturncrash(i32 %x) {
Show All 12 Lines
sw.epilog: sw.epilog:
%a.0 = phi i32 [ 7, %sw.default ], [ 5, %sw.bb3 ], [ 88, %sw.bb2 ], [ 9, %sw.bb1 ], [ 42, %entry ] %a.0 = phi i32 [ 7, %sw.default ], [ 5, %sw.bb3 ], [ 88, %sw.bb2 ], [ 9, %sw.bb1 ], [ 42, %entry ]
%b.0 = phi i32 [ 10, %sw.default ], [ 5, %sw.bb3 ], [ 1, %sw.bb2 ], [ 4, %sw.bb1 ], [ 3, %entry ] %b.0 = phi i32 [ 10, %sw.default ], [ 5, %sw.bb3 ], [ 1, %sw.bb2 ], [ 4, %sw.bb1 ], [ 3, %entry ]
ret i32 %a.0 ret i32 %a.0
; CHECK-LABEL: @earlyreturncrash( ; CHECK-LABEL: @earlyreturncrash(
; CHECK: switch.lookup: ; CHECK: switch.lookup:
; CHECK-NEXT: %switch.gep = getelementptr inbounds [4 x i32], [4 x i32]* @switch.table3, i32 0, i32 %switch.tableidx ; CHECK-NEXT: %switch.gep = getelementptr inbounds [4 x i32], [4 x i32]* @switch.table.3, i32 0, i32 %switch.tableidx
; CHECK-NEXT: %switch.load = load i32, i32* %switch.gep ; CHECK-NEXT: %switch.load = load i32, i32* %switch.gep
; CHECK-NEXT: ret i32 %switch.load ; CHECK-NEXT: ret i32 %switch.load
; CHECK: sw.epilog: ; CHECK: sw.epilog:
; CHECK-NEXT: ret i32 7 ; CHECK-NEXT: ret i32 7
} }
; Example 7 from http://blog.regehr.org/archives/320 ; Example 7 from http://blog.regehr.org/archives/320
▲ Show 20 Lines • Show All 559 Lines • ▼ Show 20 Linessw.default:
br label %return br label %return
return: return:
%retval.0 = phi i32 [ 123, %sw.default ], [ %select, %sw.bb3 ], [ %sub, %sw.bb2 ], [ 42, %sw.bb1 ], [ 5, %entry ] %retval.0 = phi i32 [ 123, %sw.default ], [ %select, %sw.bb3 ], [ %sub, %sw.bb2 ], [ 42, %sw.bb1 ], [ 5, %entry ]
ret i32 %retval.0 ret i32 %retval.0
; CHECK-LABEL: @cprop( ; CHECK-LABEL: @cprop(
; CHECK: switch.lookup: ; CHECK: switch.lookup:
; CHECK: %switch.gep = getelementptr inbounds [7 x i32], [7 x i32]* @switch.table5, i32 0, i32 %switch.tableidx ; CHECK: %switch.gep = getelementptr inbounds [7 x i32], [7 x i32]* @switch.table.5, i32 0, i32 %switch.tableidx
} }
define i32 @unreachable_case(i32 %x) { define i32 @unreachable_case(i32 %x) {
entry: entry:
switch i32 %x, label %sw.default [ switch i32 %x, label %sw.default [
i32 0, label %sw.bb i32 0, label %sw.bb
i32 1, label %sw.bb i32 1, label %sw.bb
i32 2, label %sw.bb i32 2, label %sw.bb
Show All 12 Lines
sw.default: br label %return sw.default: br label %return
return: return:
%retval.0 = phi i32 [ 1, %sw.bb3 ], [ -1, %sw.bb2 ], [ 0, %sw.bb ], [ 2, %sw.default ] %retval.0 = phi i32 [ 1, %sw.bb3 ], [ -1, %sw.bb2 ], [ 0, %sw.bb ], [ 2, %sw.default ]
ret i32 %retval.0 ret i32 %retval.0
; CHECK-LABEL: @unreachable_case( ; CHECK-LABEL: @unreachable_case(
; CHECK: switch.lookup: ; CHECK: switch.lookup:
; CHECK: getelementptr inbounds [9 x i32], [9 x i32]* @switch.table6, i32 0, i32 %switch.tableidx ; CHECK: getelementptr inbounds [9 x i32], [9 x i32]* @switch.table.6, i32 0, i32 %switch.tableidx
} }
define i32 @unreachable_default(i32 %x) { define i32 @unreachable_default(i32 %x) {
entry: entry:
switch i32 %x, label %default [ switch i32 %x, label %default [
i32 0, label %bb0 i32 0, label %bb0
i32 1, label %bb1 i32 1, label %bb1
i32 2, label %bb2 i32 2, label %bb2
Show All 10 Linesreturn:
%retval = phi i32 [ 42, %bb0 ], [ 52, %bb1 ], [ 1, %bb2 ], [ 2, %bb3 ] %retval = phi i32 [ 42, %bb0 ], [ 52, %bb1 ], [ 1, %bb2 ], [ 2, %bb3 ]
ret i32 %retval ret i32 %retval
; CHECK-LABEL: @unreachable_default( ; CHECK-LABEL: @unreachable_default(
; CHECK: entry: ; CHECK: entry:
; CHECK-NEXT: %switch.tableidx = sub i32 %x, 0 ; CHECK-NEXT: %switch.tableidx = sub i32 %x, 0
; CHECK-NOT: icmp ; CHECK-NOT: icmp
; CHECK-NOT: br 1i ; CHECK-NOT: br 1i
; CHECK-NEXT: %switch.gep = getelementptr inbounds [4 x i32], [4 x i32]* @switch.table7, i32 0, i32 %switch.tableidx ; CHECK-NEXT: %switch.gep = getelementptr inbounds [4 x i32], [4 x i32]* @switch.table.7, i32 0, i32 %switch.tableidx
; CHECK-NEXT: %switch.load = load i32, i32* %switch.gep ; CHECK-NEXT: %switch.load = load i32, i32* %switch.gep
; CHECK-NEXT: ret i32 %switch.load ; CHECK-NEXT: ret i32 %switch.load
} }
; Don't create a table with illegal type ; Don't create a table with illegal type
define i96 @illegaltype(i32 %c) { define i96 @illegaltype(i32 %c) {
entry: entry:
switch i32 %c, label %sw.default [ switch i32 %c, label %sw.default [
▲ Show 20 Lines • Show All 488 Lines • Show Last 20 Lines

test/Transforms/Util/lowerswitch.ll

; RUN: opt -lowerswitch -S < %s | FileCheck %s ; RUN: opt -lowerswitch -S < %s | FileCheck %s
; Test that we don't crash and have a different basic block for each incoming edge. ; Test that we don't crash and have a different basic block for each incoming edge.
define void @test0() { define void @test0() {
; CHECK-LABEL: @test0 ; CHECK-LABEL: @test0
; CHECK: %merge = phi i64 [ 1, %BB3 ], [ 0, %NewDefault ], [ 0, %NodeBlock5 ], [ 0, %LeafBlock1 ] ; CHECK: %merge = phi i64 [ 1, %BB3 ], [ 0, %NewDefault ], [ 0, %NodeBlock.5 ], [ 0, %LeafBlock.1 ]
BB1: BB1:
switch i32 undef, label %BB2 [ switch i32 undef, label %BB2 [
i32 3, label %BB2 i32 3, label %BB2
i32 5, label %BB2 i32 5, label %BB2
i32 0, label %BB3 i32 0, label %BB3
i32 2, label %BB3 i32 2, label %BB3
i32 4, label %BB3 i32 4, label %BB3
] ]
Show All 23 Lines switch i32 undef, label %bb1 [
i32 99, label %bb3 i32 99, label %bb3
] ]
bb2: bb2:
br label %bb3 br label %bb3
bb3: bb3:
; CHECK-LABEL: bb3 ; CHECK-LABEL: bb3
; CHECK: %tmp = phi i32 [ 1, %NodeBlock ], [ 0, %bb2 ], [ 1, %LeafBlock3 ] ; CHECK: %tmp = phi i32 [ 1, %NodeBlock ], [ 0, %bb2 ], [ 1, %LeafBlock.3 ]
%tmp = phi i32 [ 1, %bb1 ], [ 0, %bb2 ], [ 1, %bb1 ], [ 1, %bb1 ] %tmp = phi i32 [ 1, %bb1 ], [ 0, %bb2 ], [ 1, %bb1 ], [ 1, %bb1 ]
; CHECK-NEXT: %tmp2 = phi i32 [ 2, %NodeBlock ], [ 5, %bb2 ], [ 2, %LeafBlock3 ] ; CHECK-NEXT: %tmp2 = phi i32 [ 2, %NodeBlock ], [ 5, %bb2 ], [ 2, %LeafBlock.3 ]
%tmp2 = phi i32 [ 2, %bb1 ], [ 2, %bb1 ], [ 5, %bb2 ], [ 2, %bb1 ] %tmp2 = phi i32 [ 2, %bb1 ], [ 2, %bb1 ], [ 5, %bb2 ], [ 2, %bb1 ]
br label %exit br label %exit
exit: exit:
ret void ret void
} }
; Test that we don't crash. ; Test that we don't crash.
▲ Show 20 Lines • Show All 132 Lines • Show Last 20 Lines