Skip to content

Commit 45efcf0

Browse files
rnkrnk
committedMay 8, 2017
Use the frame index side table for byval and inalloca arguments
Summary: For inalloca functions, this is a very common code pattern: %argpack = type <{ i32, i32, i32 }> define void @f(%argpack* inalloca %args) { entry: %a = getelementptr inbounds %argpack, %argpack* %args, i32 0, i32 0 %b = getelementptr inbounds %argpack, %argpack* %args, i32 0, i32 1 %c = getelementptr inbounds %argpack, %argpack* %args, i32 0, i32 2 tail call void @llvm.dbg.declare(metadata i32* %a, ... "a") tail call void @llvm.dbg.declare(metadata i32* %c, ... "b") tail call void @llvm.dbg.declare(metadata i32* %b, ... "c") Even though these GEPs can be simplified to a constant offset from EBP or RSP, we don't do that at -O0, and each GEP is computed into a register. Registers used to compute argument addresses are typically spilled and clobbered very quickly after the initial computation, so live debug variable tracking loses information very quickly if we use DBG_VALUE instructions. This change moves processing of dbg.declare between argument lowering and basic block isel, so that we can ask if an argument has a frame index or not. If the argument lives in a register as is the case for byval arguments on some targets, then we don't put it in the side table and during ISel we emit DBG_VALUE instructions. Reviewers: aprantl Subscribers: llvm-commits Differential Revision: https://reviews.llvm.org/D32980 llvm-svn: 302483
1 parent 9c52c76 commit 45efcf0

File tree

8 files changed

+284
-108
lines changed

8 files changed

+284
-108
lines changed
 

‎llvm/lib/CodeGen/SelectionDAG/FastISel.cpp

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1150,16 +1150,16 @@ bool FastISel::selectIntrinsicCall(const IntrinsicInst *II) {
11501150
return true;
11511151
}
11521152

1153-
unsigned Offset = 0;
1153+
// Byval arguments with frame indices were already handled after argument
1154+
// lowering and before isel.
1155+
const auto *Arg =
1156+
dyn_cast<Argument>(Address->stripInBoundsConstantOffsets());
1157+
if (Arg && FuncInfo.getArgumentFrameIndex(Arg) != INT_MAX)
1158+
return true;
1159+
11541160
Optional<MachineOperand> Op;
1155-
if (const auto *Arg = dyn_cast<Argument>(Address))
1156-
// Some arguments' frame index is recorded during argument lowering.
1157-
Offset = FuncInfo.getArgumentFrameIndex(Arg);
1158-
if (Offset)
1159-
Op = MachineOperand::CreateFI(Offset);
1160-
if (!Op)
1161-
if (unsigned Reg = lookUpRegForValue(Address))
1162-
Op = MachineOperand::CreateReg(Reg, false);
1161+
if (unsigned Reg = lookUpRegForValue(Address))
1162+
Op = MachineOperand::CreateReg(Reg, false);
11631163

11641164
// If we have a VLA that has a "use" in a metadata node that's then used
11651165
// here but it has no other uses, then we have a problem. E.g.,

‎llvm/lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp

Lines changed: 2 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -85,7 +85,6 @@ void FunctionLoweringInfo::set(const Function &fn, MachineFunction &mf,
8585
MF = &mf;
8686
TLI = MF->getSubtarget().getTargetLowering();
8787
RegInfo = &MF->getRegInfo();
88-
MachineModuleInfo &MMI = MF->getMMI();
8988
const TargetFrameLowering *TFI = MF->getSubtarget().getFrameLowering();
9089
unsigned StackAlign = TFI->getStackAlignment();
9190

@@ -214,33 +213,6 @@ void FunctionLoweringInfo::set(const Function &fn, MachineFunction &mf,
214213
if (!isa<AllocaInst>(I) || !StaticAllocaMap.count(cast<AllocaInst>(&I)))
215214
InitializeRegForValue(&I);
216215

217-
// Collect llvm.dbg.declare information. This is done now instead of
218-
// during the initial isel pass through the IR so that it is done
219-
// in a predictable order.
220-
if (const DbgDeclareInst *DI = dyn_cast<DbgDeclareInst>(&I)) {
221-
assert(DI->getVariable() && "Missing variable");
222-
assert(DI->getDebugLoc() && "Missing location");
223-
if (MMI.hasDebugInfo()) {
224-
// Don't handle byval struct arguments or VLAs, for example.
225-
// Non-byval arguments are handled here (they refer to the stack
226-
// temporary alloca at this point).
227-
const Value *Address = DI->getAddress();
228-
if (Address) {
229-
if (const BitCastInst *BCI = dyn_cast<BitCastInst>(Address))
230-
Address = BCI->getOperand(0);
231-
if (const AllocaInst *AI = dyn_cast<AllocaInst>(Address)) {
232-
DenseMap<const AllocaInst *, int>::iterator SI =
233-
StaticAllocaMap.find(AI);
234-
if (SI != StaticAllocaMap.end()) { // Check for VLAs.
235-
int FI = SI->second;
236-
MF->setVariableDbgInfo(DI->getVariable(), DI->getExpression(),
237-
FI, DI->getDebugLoc());
238-
}
239-
}
240-
}
241-
}
242-
}
243-
244216
// Decide the preferred extend type for a value.
245217
PreferredExtendType[&I] = getPreferredExtendForValue(&I);
246218
}
@@ -510,12 +482,11 @@ void FunctionLoweringInfo::setArgumentFrameIndex(const Argument *A,
510482
/// If the argument does not have any assigned frame index then 0 is
511483
/// returned.
512484
int FunctionLoweringInfo::getArgumentFrameIndex(const Argument *A) {
513-
DenseMap<const Argument *, int>::iterator I =
514-
ByValArgFrameIndexMap.find(A);
485+
auto I = ByValArgFrameIndexMap.find(A);
515486
if (I != ByValArgFrameIndexMap.end())
516487
return I->second;
517488
DEBUG(dbgs() << "Argument does not have assigned frame index!\n");
518-
return 0;
489+
return INT_MAX;
519490
}
520491

521492
unsigned FunctionLoweringInfo::getCatchPadExceptionPointerVReg(

‎llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

Lines changed: 9 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4676,7 +4676,8 @@ bool SelectionDAGBuilder::EmitFuncArgumentDbgValue(
46764676
bool IsIndirect = false;
46774677
Optional<MachineOperand> Op;
46784678
// Some arguments' frame index is recorded during argument lowering.
4679-
if (int FI = FuncInfo.getArgumentFrameIndex(Arg))
4679+
int FI = FuncInfo.getArgumentFrameIndex(Arg);
4680+
if (FI != INT_MAX)
46804681
Op = MachineOperand::CreateFI(FI);
46814682

46824683
if (!Op && N.getNode()) {
@@ -4927,6 +4928,13 @@ SelectionDAGBuilder::visitIntrinsicCall(const CallInst &I, unsigned Intrinsic) {
49274928
return nullptr;
49284929
}
49294930

4931+
// Byval arguments with frame indices were already handled after argument
4932+
// lowering and before isel.
4933+
const auto *Arg =
4934+
dyn_cast<Argument>(Address->stripInBoundsConstantOffsets());
4935+
if (Arg && FuncInfo.getArgumentFrameIndex(Arg) != INT_MAX)
4936+
return nullptr;
4937+
49304938
SDValue &N = NodeMap[Address];
49314939
if (!N.getNode() && isa<Argument>(Address))
49324940
// Check unused arguments map.

‎llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

Lines changed: 48 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -38,6 +38,7 @@
3838
#include "llvm/CodeGen/MachineInstr.h"
3939
#include "llvm/CodeGen/MachineInstrBuilder.h"
4040
#include "llvm/CodeGen/MachineMemOperand.h"
41+
#include "llvm/CodeGen/MachineModuleInfo.h"
4142
#include "llvm/CodeGen/MachineOperand.h"
4243
#include "llvm/CodeGen/MachinePassRegistry.h"
4344
#include "llvm/CodeGen/MachineRegisterInfo.h"
@@ -1145,6 +1146,51 @@ static void createSwiftErrorEntriesInEntryBlock(FunctionLoweringInfo *FuncInfo,
11451146
}
11461147
}
11471148

1149+
/// Collect llvm.dbg.declare information. This is done after argument lowering
1150+
/// in case the declarations refer to arguments.
1151+
static void processDbgDeclares(FunctionLoweringInfo *FuncInfo) {
1152+
MachineFunction *MF = FuncInfo->MF;
1153+
const DataLayout &DL = MF->getDataLayout();
1154+
for (const BasicBlock &BB : *FuncInfo->Fn) {
1155+
for (const Instruction &I : BB) {
1156+
const DbgDeclareInst *DI = dyn_cast<DbgDeclareInst>(&I);
1157+
if (!DI)
1158+
continue;
1159+
1160+
assert(DI->getVariable() && "Missing variable");
1161+
assert(DI->getDebugLoc() && "Missing location");
1162+
const Value *Address = DI->getAddress();
1163+
if (!Address)
1164+
continue;
1165+
1166+
// Look through casts and constant offset GEPs. These mostly come from
1167+
// inalloca.
1168+
APInt Offset(DL.getPointerSizeInBits(0), 0);
1169+
Address = Address->stripAndAccumulateInBoundsConstantOffsets(DL, Offset);
1170+
1171+
// Check if the variable is a static alloca or a byval or inalloca
1172+
// argument passed in memory. If it is not, then we will ignore this
1173+
// intrinsic and handle this during isel like dbg.value.
1174+
int FI = INT_MAX;
1175+
if (const auto *AI = dyn_cast<AllocaInst>(Address)) {
1176+
auto SI = FuncInfo->StaticAllocaMap.find(AI);
1177+
if (SI != FuncInfo->StaticAllocaMap.end())
1178+
FI = SI->second;
1179+
} else if (const auto *Arg = dyn_cast<Argument>(Address))
1180+
FI = FuncInfo->getArgumentFrameIndex(Arg);
1181+
1182+
if (FI == INT_MAX)
1183+
continue;
1184+
1185+
DIExpression *Expr = DI->getExpression();
1186+
if (Offset.getBoolValue())
1187+
Expr = DIExpression::prepend(Expr, DIExpression::NoDeref,
1188+
Offset.getZExtValue());
1189+
MF->setVariableDbgInfo(DI->getVariable(), Expr, FI, DI->getDebugLoc());
1190+
}
1191+
}
1192+
}
1193+
11481194
/// Propagate swifterror values through the machine function CFG.
11491195
static void propagateSwiftErrorVRegs(FunctionLoweringInfo *FuncInfo) {
11501196
auto *TLI = FuncInfo->TLI;
@@ -1317,6 +1363,8 @@ void SelectionDAGISel::SelectAllBasicBlocks(const Function &Fn) {
13171363
}
13181364
createSwiftErrorEntriesInEntryBlock(FuncInfo, FastIS, TLI, TII, SDB);
13191365

1366+
processDbgDeclares(FuncInfo);
1367+
13201368
// Iterate over all basic blocks in the function.
13211369
for (const BasicBlock *LLVMBB : RPOT) {
13221370
if (OptLevel != CodeGenOpt::None) {

‎llvm/test/CodeGen/X86/2010-01-18-DbgValue.ll

Lines changed: 8 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,18 @@
1-
; RUN: llc -march=x86 -O0 < %s | FileCheck %s
2-
; Currently, dbg.declare generates a DEBUG_VALUE comment. Eventually it will
3-
; generate DWARF and this test will need to be modified or removed.
1+
; RUN: llc -march=x86 -O0 < %s -filetype=obj | llvm-dwarfdump - | FileCheck %s
42

3+
; CHECK-LABEL: .debug_info contents:
4+
5+
; CHECK-LABEL: DW_TAG_subprogram
6+
; CHECK: DW_AT_name [DW_FORM_strp] ( {{.*}}"foo")
7+
; CHECK: DW_TAG_formal_parameter
8+
; CHECK-NEXT: DW_AT_location [DW_FORM_exprloc] (<0x2> 91 08 )
9+
; CHECK-NEXT: DW_AT_name [DW_FORM_strp] ( {{.*}}"my_r0")
510

611
%struct.Pt = type { double, double }
712
%struct.Rect = type { %struct.Pt, %struct.Pt }
813

914
define double @foo(%struct.Rect* byval %my_r0) nounwind ssp !dbg !1 {
1015
entry:
11-
;CHECK: DEBUG_VALUE
1216
%retval = alloca double ; <double*> [#uses=2]
1317
%0 = alloca double ; <double*> [#uses=2]
1418
%"alloca point" = bitcast i32 0 to i32 ; <i32> [#uses=0]

‎llvm/test/CodeGen/X86/2012-11-30-handlemove-dbg.ll

Lines changed: 0 additions & 51 deletions
This file was deleted.

‎llvm/test/CodeGen/X86/dbg-baseptr.ll

Lines changed: 50 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
11
; RUN: llc -o - %s | FileCheck %s
2+
; RUN: llc -filetype=obj -o - %s | llvm-dwarfdump - | FileCheck %s --check-prefix=DWARF
23
; This test checks that parameters on the stack pointer are correctly
34
; referenced by debug info.
45
target triple = "x86_64--"
@@ -7,24 +8,54 @@ target triple = "x86_64--"
78
@ptr = external global i32*
89
%struct.s = type { i32, i32, i32, i32, i32 }
910

11+
; Simple case: no FP, use offset from RSP.
12+
1013
; CHECK-LABEL: f0:
11-
; CHECK: DEBUG_VALUE: f:input <- [%RSP+8]
14+
; CHECK-NOT: pushq
15+
; CHECK: movl $42, %eax
16+
; CHECK: retq
1217
define i32 @f0(%struct.s* byval align 8 %input) !dbg !8 {
1318
call void @llvm.dbg.declare(metadata %struct.s* %input, metadata !4, metadata !17), !dbg !18
14-
ret i32 42
19+
ret i32 42, !dbg !18
1520
}
1621

22+
; DWARF-LABEL: .debug_info contents:
23+
24+
; DWARF-LABEL: DW_TAG_subprogram
25+
; DWARF: DW_AT_frame_base [DW_FORM_exprloc] (<0x1> 57 )
26+
; 0x57 -> RSP
27+
; DWARF: DW_AT_name [DW_FORM_strp] ( {{.*}}"f0")
28+
; DWARF: DW_TAG_formal_parameter
29+
; DWARF-NEXT: DW_AT_location [DW_FORM_exprloc] (<0x2> 91 08 )
30+
; DW_OP_fbreg (0x91) 0x08
31+
; DWARF-NEXT: DW_AT_name [DW_FORM_strp] ( {{.*}}"input")
32+
33+
34+
; Dynamic alloca forces the use of RBP as the base pointer
35+
1736
; CHECK-LABEL: f1:
18-
; CHECK: DEBUG_VALUE: f:input <- [%RBP+16]
37+
; CHECK: pushq %rbp
38+
; CHECK: movl $42, %eax
39+
; CHECK: popq %rbp
40+
; CHECK: retq
1941
define i32 @f1(%struct.s* byval align 8 %input) !dbg !19 {
2042
%val = load i64, i64* @glob
2143
; this alloca should force FP usage.
2244
%stackspace = alloca i32, i64 %val, align 1
2345
store i32* %stackspace, i32** @ptr
2446
call void @llvm.dbg.declare(metadata %struct.s* %input, metadata !20, metadata !17), !dbg !21
25-
ret i32 42
47+
ret i32 42, !dbg !21
2648
}
2749

50+
; DWARF-LABEL: DW_TAG_subprogram
51+
; DWARF: DW_AT_frame_base [DW_FORM_exprloc] (<0x1> 56 )
52+
; 0x56 -> RBP
53+
; DWARF: DW_AT_name [DW_FORM_strp] ( {{.*}}"f1")
54+
; DWARF: DW_TAG_formal_parameter
55+
; DWARF-NEXT: DW_AT_location [DW_FORM_exprloc] (<0x2> 91 10 )
56+
; DW_OP_fbreg (0x91) 0x10
57+
; DWARF-NEXT: DW_AT_name [DW_FORM_strp] ( {{.*}}"input")
58+
2859
; CHECK-LABEL: f2:
2960
; Just check that we are indeed aligning the stack and setting up a base pointer
3061
; in RBX.
@@ -34,33 +65,40 @@ define i32 @f1(%struct.s* byval align 8 %input) !dbg !19 {
3465
; CHECK: andq $-64, %rsp
3566
; CHECK: subq $64, %rsp
3667
; CHECK: movq %rsp, %rbx
37-
; The parameter should still be referenced through RBP though.
38-
; CHECK-NOT: DEBUG_VALUE: f:input <- [%RBX
39-
; CHECK: DEBUG_VALUE: f:input <- [%RBP+16]
4068
define i32 @f2(%struct.s* byval align 8 %input) !dbg !22 {
4169
%val = load i64, i64* @glob
4270
%stackspace = alloca i32, i64 %val, align 64
4371
store i32* %stackspace, i32** @ptr
4472
call void @llvm.dbg.declare(metadata %struct.s* %input, metadata !23, metadata !17), !dbg !24
45-
ret i32 42
73+
ret i32 42, !dbg !24
4674
}
4775

76+
; "input" should still be referred to through RBP.
77+
; DWARF-LABEL: DW_TAG_subprogram
78+
; DWARF: DW_AT_frame_base [DW_FORM_exprloc] (<0x1> 56 )
79+
; 0x56 -> RBP
80+
; DWARF: DW_AT_name [DW_FORM_strp] ( {{.*}}"f2")
81+
; DWARF: DW_TAG_formal_parameter
82+
; DWARF-NEXT: DW_AT_location [DW_FORM_exprloc] (<0x2> 91 10 )
83+
; DW_OP_fbreg (0x91) 0x10
84+
; DWARF-NEXT: DW_AT_name [DW_FORM_strp] ( {{.*}}"input")
85+
4886
declare void @llvm.dbg.declare(metadata, metadata, metadata)
4987

5088
!llvm.dbg.cu = !{!2}
5189
!llvm.module.flags = !{!0, !1}
5290

5391
!0 = !{i32 2, !"Dwarf Version", i32 4}
5492
!1 = !{i32 2, !"Debug Info Version", i32 3}
55-
!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3)
93+
!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, emissionKind: FullDebug)
5694
!3 = !DIFile(filename: "dbg-baseptr.ll", directory: "/")
5795
!4 = !DILocalVariable(name: "input", arg: 1, scope: !8, file: !3, line: 5, type: !9)
5896
!5 = !{}
5997

6098
!6 = !DISubroutineType(types: !7)
6199
!7 = !{!10, !9}
62100

63-
!8 = distinct !DISubprogram(name: "f", file: !3, line: 5, type: !6, isLocal: false, isDefinition: true, flags: DIFlagPrototyped, unit: !2, variables: !5)
101+
!8 = distinct !DISubprogram(name: "f0", file: !3, line: 5, type: !6, isLocal: false, isDefinition: true, unit: !2, variables: !5)
64102

65103
!9 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "s", elements: !11)
66104
!10 = !DIBasicType(name: "unsigned int", size: 32, encoding: DW_ATE_unsigned)
@@ -74,9 +112,9 @@ declare void @llvm.dbg.declare(metadata, metadata, metadata)
74112
!17 = !DIExpression()
75113
!18 = !DILocation(line: 5, scope: !8)
76114

77-
!19 = distinct !DISubprogram(name: "f", file: !3, line: 5, type: !6, isLocal: false, isDefinition: true, flags: DIFlagPrototyped, unit: !2, variables: !5)
115+
!19 = distinct !DISubprogram(name: "f1", file: !3, line: 5, type: !6, isLocal: false, isDefinition: true, flags: DIFlagPrototyped, unit: !2, variables: !5)
78116
!20 = !DILocalVariable(name: "input", arg: 1, scope: !19, file: !3, line: 5, type: !9)
79117
!21 = !DILocation(line: 5, scope: !19)
80-
!22 = distinct !DISubprogram(name: "f", file: !3, line: 5, type: !6, isLocal: false, isDefinition: true, flags: DIFlagPrototyped, unit: !2, variables: !5)
118+
!22 = distinct !DISubprogram(name: "f2", file: !3, line: 5, type: !6, isLocal: false, isDefinition: true, flags: DIFlagPrototyped, unit: !2, variables: !5)
81119
!23 = !DILocalVariable(name: "input", arg: 1, scope: !22, file: !3, line: 5, type: !9)
82120
!24 = !DILocation(line: 5, scope: !22)

‎llvm/test/DebugInfo/X86/dbg-declare-inalloca.ll

Lines changed: 158 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,158 @@
1+
; RUN: llc -O0 < %s | FileCheck %s --check-prefix=CHECK --check-prefix=DEBUG
2+
; RUN: llc < %s | FileCheck %s
3+
4+
; IR generated by the following source:
5+
; struct NonTrivial {
6+
; NonTrivial();// : x(42) {}
7+
; ~NonTrivial();// {}
8+
; int x;
9+
; };
10+
; extern "C" void g(int);// {}
11+
; extern "C" void h(int);// {}
12+
; extern "C" void f(NonTrivial a, int b, int unused, int c) {
13+
; if (b) {
14+
; g(c);
15+
; } else {
16+
; h(a.x);
17+
; }
18+
; (void)unused;
19+
; }
20+
; //int main() {
21+
; // NonTrivial x;
22+
; // f(x, 1, 2, 3);
23+
; //}
24+
;
25+
; Remove C++ comments to have a complete, debuggable program.
26+
27+
; We don't need (or want) DBG_VALUE instructions to describe the location of
28+
; inalloca arguments. We want frame indices in the side table, especially at
29+
; -O0, because they are reliable across the entire function and don't require
30+
; any propagation or analysis.
31+
32+
; CHECK: _f: # @f
33+
; CHECK: Lfunc_begin0:
34+
; CHECK-NOT: DEBUG_VALUE
35+
; CHECK: [[start:Ltmp[0-9]+]]:
36+
; CHECK-NOT: DEBUG_VALUE
37+
; CHECK: cmpl
38+
; CHECK: calll _g
39+
; CHECK: calll _h
40+
; CHECK: jmp "??1NonTrivial@@QAE@XZ"
41+
; CHECK: [[end:Ltmp[0-9]+]]:
42+
; CHECK: Lfunc_end0:
43+
44+
; FIXME: Optimized debug info should preserve this.
45+
; DEBUG: .short 4414 # Record kind: S_LOCAL
46+
; DEBUG: .asciz "a"
47+
; DEBUG: .cv_def_range [[start]] [[end]]
48+
49+
; CHECK: .short 4414 # Record kind: S_LOCAL
50+
; CHECK: .asciz "b"
51+
; CHECK: .cv_def_range [[start]] [[end]]
52+
53+
; CHECK: .short 4414 # Record kind: S_LOCAL
54+
; CHECK: .asciz "c"
55+
; CHECK: .cv_def_range [[start]] [[end]]
56+
57+
58+
59+
; ModuleID = 't.cpp'
60+
source_filename = "t.cpp"
61+
target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
62+
target triple = "i386-pc-windows-msvc19.10.24728"
63+
64+
%struct.NonTrivial = type { i32 }
65+
66+
; Function Attrs: nounwind
67+
define void @f(<{ %struct.NonTrivial, i32, i32, i32 }>* inalloca) local_unnamed_addr #0 !dbg !7 {
68+
entry:
69+
%a = getelementptr inbounds <{ %struct.NonTrivial, i32, i32, i32 }>, <{ %struct.NonTrivial, i32, i32, i32 }>* %0, i32 0, i32 0
70+
%b = getelementptr inbounds <{ %struct.NonTrivial, i32, i32, i32 }>, <{ %struct.NonTrivial, i32, i32, i32 }>* %0, i32 0, i32 1
71+
tail call void @llvm.dbg.declare(metadata i32* %c, metadata !20, metadata !24), !dbg !25
72+
tail call void @llvm.dbg.declare(metadata i32* %b, metadata !22, metadata !24), !dbg !26
73+
tail call void @llvm.dbg.declare(metadata %struct.NonTrivial* %a, metadata !23, metadata !24), !dbg !27
74+
%1 = load i32, i32* %b, align 4, !dbg !28, !tbaa !30
75+
%tobool = icmp eq i32 %1, 0, !dbg !28
76+
br i1 %tobool, label %if.else, label %if.then, !dbg !34
77+
78+
if.then: ; preds = %entry
79+
%c = getelementptr inbounds <{ %struct.NonTrivial, i32, i32, i32 }>, <{ %struct.NonTrivial, i32, i32, i32 }>* %0, i32 0, i32 3
80+
%2 = load i32, i32* %c, align 4, !dbg !35, !tbaa !30
81+
tail call void @g(i32 %2) #4, !dbg !37
82+
br label %if.end, !dbg !38
83+
84+
if.else: ; preds = %entry
85+
%x = getelementptr inbounds <{ %struct.NonTrivial, i32, i32, i32 }>, <{ %struct.NonTrivial, i32, i32, i32 }>* %0, i32 0, i32 0, i32 0, !dbg !39
86+
%3 = load i32, i32* %x, align 4, !dbg !39, !tbaa !41
87+
tail call void @h(i32 %3) #4, !dbg !43
88+
br label %if.end
89+
90+
if.end: ; preds = %if.else, %if.then
91+
tail call x86_thiscallcc void @"\01??1NonTrivial@@QAE@XZ"(%struct.NonTrivial* nonnull %a) #4, !dbg !44
92+
ret void, !dbg !44
93+
}
94+
95+
; Function Attrs: nounwind readnone speculatable
96+
declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
97+
98+
declare void @g(i32) local_unnamed_addr
99+
100+
declare void @h(i32) local_unnamed_addr
101+
102+
; Function Attrs: nounwind
103+
declare x86_thiscallcc void @"\01??1NonTrivial@@QAE@XZ"(%struct.NonTrivial*) unnamed_addr #3
104+
105+
attributes #0 = { nounwind }
106+
attributes #1 = { nounwind readnone speculatable }
107+
attributes #3 = { nounwind }
108+
attributes #4 = { nounwind }
109+
110+
!llvm.dbg.cu = !{!0}
111+
!llvm.module.flags = !{!3, !4, !5}
112+
!llvm.ident = !{!6}
113+
114+
!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 5.0.0 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
115+
!1 = !DIFile(filename: "t.cpp", directory: "C:\5Csrc\5Cllvm-project\5Cbuild", checksumkind: CSK_MD5, checksum: "e41e3fda2a91b52e121ed6c29a209eae")
116+
!2 = !{}
117+
!3 = !{i32 1, !"NumRegisterParameters", i32 0}
118+
!4 = !{i32 2, !"CodeView", i32 1}
119+
!5 = !{i32 2, !"Debug Info Version", i32 3}
120+
!6 = !{!"clang version 5.0.0 "}
121+
!7 = distinct !DISubprogram(name: "f", scope: !1, file: !1, line: 8, type: !8, isLocal: false, isDefinition: true, scopeLine: 8, flags: DIFlagPrototyped, isOptimized: true, unit: !0, variables: !19)
122+
!8 = !DISubroutineType(types: !9)
123+
!9 = !{null, !10, !13, !13, !13}
124+
!10 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "NonTrivial", file: !1, line: 1, size: 32, elements: !11, identifier: ".?AUNonTrivial@@")
125+
!11 = !{!12, !14, !18}
126+
!12 = !DIDerivedType(tag: DW_TAG_member, name: "x", scope: !10, file: !1, line: 4, baseType: !13, size: 32)
127+
!13 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
128+
!14 = !DISubprogram(name: "NonTrivial", scope: !10, file: !1, line: 2, type: !15, isLocal: false, isDefinition: false, scopeLine: 2, flags: DIFlagPrototyped, isOptimized: true)
129+
!15 = !DISubroutineType(cc: DW_CC_BORLAND_thiscall, types: !16)
130+
!16 = !{null, !17}
131+
!17 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !10, size: 32, flags: DIFlagArtificial | DIFlagObjectPointer)
132+
!18 = !DISubprogram(name: "~NonTrivial", scope: !10, file: !1, line: 3, type: !15, isLocal: false, isDefinition: false, scopeLine: 3, flags: DIFlagPrototyped, isOptimized: true)
133+
!19 = !{!20, !21, !22, !23}
134+
!20 = !DILocalVariable(name: "c", arg: 4, scope: !7, file: !1, line: 8, type: !13)
135+
!21 = !DILocalVariable(name: "unused", arg: 3, scope: !7, file: !1, line: 8, type: !13)
136+
!22 = !DILocalVariable(name: "b", arg: 2, scope: !7, file: !1, line: 8, type: !13)
137+
!23 = !DILocalVariable(name: "a", arg: 1, scope: !7, file: !1, line: 8, type: !10)
138+
!24 = !DIExpression()
139+
!25 = !DILocation(line: 8, column: 56, scope: !7)
140+
!26 = !DILocation(line: 8, column: 37, scope: !7)
141+
!27 = !DILocation(line: 8, column: 30, scope: !7)
142+
!28 = !DILocation(line: 9, column: 7, scope: !29)
143+
!29 = distinct !DILexicalBlock(scope: !7, file: !1, line: 9, column: 7)
144+
!30 = !{!31, !31, i64 0}
145+
!31 = !{!"int", !32, i64 0}
146+
!32 = !{!"omnipotent char", !33, i64 0}
147+
!33 = !{!"Simple C++ TBAA"}
148+
!34 = !DILocation(line: 9, column: 7, scope: !7)
149+
!35 = !DILocation(line: 10, column: 7, scope: !36)
150+
!36 = distinct !DILexicalBlock(scope: !29, file: !1, line: 9, column: 10)
151+
!37 = !DILocation(line: 10, column: 5, scope: !36)
152+
!38 = !DILocation(line: 11, column: 3, scope: !36)
153+
!39 = !DILocation(line: 12, column: 9, scope: !40)
154+
!40 = distinct !DILexicalBlock(scope: !29, file: !1, line: 11, column: 10)
155+
!41 = !{!42, !31, i64 0}
156+
!42 = !{!"?AUNonTrivial@@", !31, i64 0}
157+
!43 = !DILocation(line: 12, column: 5, scope: !40)
158+
!44 = !DILocation(line: 15, column: 1, scope: !7)

0 commit comments

Comments
 (0)
Please sign in to comment.