Bug Summary

File:llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp
Warning:line 1555, column 3
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name DwarfDebug.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/build-llvm -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I lib/CodeGen/AsmPrinter -I /build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter -I include -I /build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-command-line-argument -Wno-unknown-warning-option -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/build-llvm -ferror-limit 19 -fvisibility-inlines-hidden -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-10-17-004846-21170-1 -x c++ /build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp
1//===- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ----------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file contains support for writing dwarf debug info into asm files.
10//
11//===----------------------------------------------------------------------===//
12
13#include "DwarfDebug.h"
14#include "ByteStreamer.h"
15#include "DIEHash.h"
16#include "DwarfCompileUnit.h"
17#include "DwarfExpression.h"
18#include "DwarfUnit.h"
19#include "llvm/ADT/APInt.h"
20#include "llvm/ADT/Statistic.h"
21#include "llvm/ADT/Triple.h"
22#include "llvm/ADT/Twine.h"
23#include "llvm/CodeGen/AsmPrinter.h"
24#include "llvm/CodeGen/DIE.h"
25#include "llvm/CodeGen/LexicalScopes.h"
26#include "llvm/CodeGen/MachineBasicBlock.h"
27#include "llvm/CodeGen/MachineFunction.h"
28#include "llvm/CodeGen/MachineModuleInfo.h"
29#include "llvm/CodeGen/MachineOperand.h"
30#include "llvm/CodeGen/TargetInstrInfo.h"
31#include "llvm/CodeGen/TargetLowering.h"
32#include "llvm/CodeGen/TargetRegisterInfo.h"
33#include "llvm/CodeGen/TargetSubtargetInfo.h"
34#include "llvm/DebugInfo/DWARF/DWARFExpression.h"
35#include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
36#include "llvm/IR/Constants.h"
37#include "llvm/IR/Function.h"
38#include "llvm/IR/GlobalVariable.h"
39#include "llvm/IR/Module.h"
40#include "llvm/MC/MCAsmInfo.h"
41#include "llvm/MC/MCContext.h"
42#include "llvm/MC/MCSection.h"
43#include "llvm/MC/MCStreamer.h"
44#include "llvm/MC/MCSymbol.h"
45#include "llvm/MC/MCTargetOptions.h"
46#include "llvm/MC/MachineLocation.h"
47#include "llvm/MC/SectionKind.h"
48#include "llvm/Pass.h"
49#include "llvm/Support/Casting.h"
50#include "llvm/Support/CommandLine.h"
51#include "llvm/Support/Debug.h"
52#include "llvm/Support/ErrorHandling.h"
53#include "llvm/Support/MD5.h"
54#include "llvm/Support/MathExtras.h"
55#include "llvm/Support/Timer.h"
56#include "llvm/Support/raw_ostream.h"
57#include "llvm/Target/TargetLoweringObjectFile.h"
58#include "llvm/Target/TargetMachine.h"
59#include <algorithm>
60#include <cstddef>
61#include <iterator>
62#include <string>
63
64using namespace llvm;
65
66#define DEBUG_TYPE"dwarfdebug" "dwarfdebug"
67
68STATISTIC(NumCSParams, "Number of dbg call site params created")static llvm::Statistic NumCSParams = {"dwarfdebug", "NumCSParams"
, "Number of dbg call site params created"}
;
69
70static cl::opt<bool> UseDwarfRangesBaseAddressSpecifier(
71 "use-dwarf-ranges-base-address-specifier", cl::Hidden,
72 cl::desc("Use base address specifiers in debug_ranges"), cl::init(false));
73
74static cl::opt<bool> GenerateARangeSection("generate-arange-section",
75 cl::Hidden,
76 cl::desc("Generate dwarf aranges"),
77 cl::init(false));
78
79static cl::opt<bool>
80 GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
81 cl::desc("Generate DWARF4 type units."),
82 cl::init(false));
83
84static cl::opt<bool> SplitDwarfCrossCuReferences(
85 "split-dwarf-cross-cu-references", cl::Hidden,
86 cl::desc("Enable cross-cu references in DWO files"), cl::init(false));
87
88enum DefaultOnOff { Default, Enable, Disable };
89
90static cl::opt<DefaultOnOff> UnknownLocations(
91 "use-unknown-locations", cl::Hidden,
92 cl::desc("Make an absence of debug location information explicit."),
93 cl::values(clEnumVal(Default, "At top of block or after label")llvm::cl::OptionEnumValue { "Default", int(Default), "At top of block or after label"
}
,
94 clEnumVal(Enable, "In all cases")llvm::cl::OptionEnumValue { "Enable", int(Enable), "In all cases"
}
, clEnumVal(Disable, "Never")llvm::cl::OptionEnumValue { "Disable", int(Disable), "Never" }),
95 cl::init(Default));
96
97static cl::opt<AccelTableKind> AccelTables(
98 "accel-tables", cl::Hidden, cl::desc("Output dwarf accelerator tables."),
99 cl::values(clEnumValN(AccelTableKind::Default, "Default",llvm::cl::OptionEnumValue { "Default", int(AccelTableKind::Default
), "Default for platform" }
100 "Default for platform")llvm::cl::OptionEnumValue { "Default", int(AccelTableKind::Default
), "Default for platform" }
,
101 clEnumValN(AccelTableKind::None, "Disable", "Disabled.")llvm::cl::OptionEnumValue { "Disable", int(AccelTableKind::None
), "Disabled." }
,
102 clEnumValN(AccelTableKind::Apple, "Apple", "Apple")llvm::cl::OptionEnumValue { "Apple", int(AccelTableKind::Apple
), "Apple" }
,
103 clEnumValN(AccelTableKind::Dwarf, "Dwarf", "DWARF")llvm::cl::OptionEnumValue { "Dwarf", int(AccelTableKind::Dwarf
), "DWARF" }
),
104 cl::init(AccelTableKind::Default));
105
106static cl::opt<DefaultOnOff>
107DwarfInlinedStrings("dwarf-inlined-strings", cl::Hidden,
108 cl::desc("Use inlined strings rather than string section."),
109 cl::values(clEnumVal(Default, "Default for platform")llvm::cl::OptionEnumValue { "Default", int(Default), "Default for platform"
}
,
110 clEnumVal(Enable, "Enabled")llvm::cl::OptionEnumValue { "Enable", int(Enable), "Enabled" },
111 clEnumVal(Disable, "Disabled")llvm::cl::OptionEnumValue { "Disable", int(Disable), "Disabled"
}
),
112 cl::init(Default));
113
114static cl::opt<bool>
115 NoDwarfRangesSection("no-dwarf-ranges-section", cl::Hidden,
116 cl::desc("Disable emission .debug_ranges section."),
117 cl::init(false));
118
119static cl::opt<DefaultOnOff> DwarfSectionsAsReferences(
120 "dwarf-sections-as-references", cl::Hidden,
121 cl::desc("Use sections+offset as references rather than labels."),
122 cl::values(clEnumVal(Default, "Default for platform")llvm::cl::OptionEnumValue { "Default", int(Default), "Default for platform"
}
,
123 clEnumVal(Enable, "Enabled")llvm::cl::OptionEnumValue { "Enable", int(Enable), "Enabled" }, clEnumVal(Disable, "Disabled")llvm::cl::OptionEnumValue { "Disable", int(Disable), "Disabled"
}
),
124 cl::init(Default));
125
126static cl::opt<bool>
127 UseGNUDebugMacro("use-gnu-debug-macro", cl::Hidden,
128 cl::desc("Emit the GNU .debug_macro format with DWARF <5"),
129 cl::init(false));
130
131static cl::opt<DefaultOnOff> DwarfOpConvert(
132 "dwarf-op-convert", cl::Hidden,
133 cl::desc("Enable use of the DWARFv5 DW_OP_convert operator"),
134 cl::values(clEnumVal(Default, "Default for platform")llvm::cl::OptionEnumValue { "Default", int(Default), "Default for platform"
}
,
135 clEnumVal(Enable, "Enabled")llvm::cl::OptionEnumValue { "Enable", int(Enable), "Enabled" }, clEnumVal(Disable, "Disabled")llvm::cl::OptionEnumValue { "Disable", int(Disable), "Disabled"
}
),
136 cl::init(Default));
137
138enum LinkageNameOption {
139 DefaultLinkageNames,
140 AllLinkageNames,
141 AbstractLinkageNames
142};
143
144static cl::opt<LinkageNameOption>
145 DwarfLinkageNames("dwarf-linkage-names", cl::Hidden,
146 cl::desc("Which DWARF linkage-name attributes to emit."),
147 cl::values(clEnumValN(DefaultLinkageNames, "Default",llvm::cl::OptionEnumValue { "Default", int(DefaultLinkageNames
), "Default for platform" }
148 "Default for platform")llvm::cl::OptionEnumValue { "Default", int(DefaultLinkageNames
), "Default for platform" }
,
149 clEnumValN(AllLinkageNames, "All", "All")llvm::cl::OptionEnumValue { "All", int(AllLinkageNames), "All"
}
,
150 clEnumValN(AbstractLinkageNames, "Abstract",llvm::cl::OptionEnumValue { "Abstract", int(AbstractLinkageNames
), "Abstract subprograms" }
151 "Abstract subprograms")llvm::cl::OptionEnumValue { "Abstract", int(AbstractLinkageNames
), "Abstract subprograms" }
),
152 cl::init(DefaultLinkageNames));
153
154static cl::opt<DwarfDebug::MinimizeAddrInV5> MinimizeAddrInV5Option(
155 "minimize-addr-in-v5", cl::Hidden,
156 cl::desc("Always use DW_AT_ranges in DWARFv5 whenever it could allow more "
157 "address pool entry sharing to reduce relocations/object size"),
158 cl::values(clEnumValN(DwarfDebug::MinimizeAddrInV5::Default, "Default",llvm::cl::OptionEnumValue { "Default", int(DwarfDebug::MinimizeAddrInV5
::Default), "Default address minimization strategy" }
159 "Default address minimization strategy")llvm::cl::OptionEnumValue { "Default", int(DwarfDebug::MinimizeAddrInV5
::Default), "Default address minimization strategy" }
,
160 clEnumValN(DwarfDebug::MinimizeAddrInV5::Ranges, "Ranges",llvm::cl::OptionEnumValue { "Ranges", int(DwarfDebug::MinimizeAddrInV5
::Ranges), "Use rnglists for contiguous ranges if that allows "
"using a pre-existing base address" }
161 "Use rnglists for contiguous ranges if that allows "llvm::cl::OptionEnumValue { "Ranges", int(DwarfDebug::MinimizeAddrInV5
::Ranges), "Use rnglists for contiguous ranges if that allows "
"using a pre-existing base address" }
162 "using a pre-existing base address")llvm::cl::OptionEnumValue { "Ranges", int(DwarfDebug::MinimizeAddrInV5
::Ranges), "Use rnglists for contiguous ranges if that allows "
"using a pre-existing base address" }
,
163 clEnumValN(DwarfDebug::MinimizeAddrInV5::Expressions,llvm::cl::OptionEnumValue { "Expressions", int(DwarfDebug::MinimizeAddrInV5
::Expressions), "Use exprloc addrx+offset expressions for any "
"address with a prior base address" }
164 "Expressions",llvm::cl::OptionEnumValue { "Expressions", int(DwarfDebug::MinimizeAddrInV5
::Expressions), "Use exprloc addrx+offset expressions for any "
"address with a prior base address" }
165 "Use exprloc addrx+offset expressions for any "llvm::cl::OptionEnumValue { "Expressions", int(DwarfDebug::MinimizeAddrInV5
::Expressions), "Use exprloc addrx+offset expressions for any "
"address with a prior base address" }
166 "address with a prior base address")llvm::cl::OptionEnumValue { "Expressions", int(DwarfDebug::MinimizeAddrInV5
::Expressions), "Use exprloc addrx+offset expressions for any "
"address with a prior base address" }
,
167 clEnumValN(DwarfDebug::MinimizeAddrInV5::Form, "Form",llvm::cl::OptionEnumValue { "Form", int(DwarfDebug::MinimizeAddrInV5
::Form), "Use addrx+offset extension form for any address " "with a prior base address"
}
168 "Use addrx+offset extension form for any address "llvm::cl::OptionEnumValue { "Form", int(DwarfDebug::MinimizeAddrInV5
::Form), "Use addrx+offset extension form for any address " "with a prior base address"
}
169 "with a prior base address")llvm::cl::OptionEnumValue { "Form", int(DwarfDebug::MinimizeAddrInV5
::Form), "Use addrx+offset extension form for any address " "with a prior base address"
}
,
170 clEnumValN(DwarfDebug::MinimizeAddrInV5::Disabled, "Disabled",llvm::cl::OptionEnumValue { "Disabled", int(DwarfDebug::MinimizeAddrInV5
::Disabled), "Stuff" }
171 "Stuff")llvm::cl::OptionEnumValue { "Disabled", int(DwarfDebug::MinimizeAddrInV5
::Disabled), "Stuff" }
),
172 cl::init(DwarfDebug::MinimizeAddrInV5::Default));
173
174static constexpr unsigned ULEB128PadSize = 4;
175
176void DebugLocDwarfExpression::emitOp(uint8_t Op, const char *Comment) {
177 getActiveStreamer().emitInt8(
178 Op, Comment ? Twine(Comment) + " " + dwarf::OperationEncodingString(Op)
179 : dwarf::OperationEncodingString(Op));
180}
181
182void DebugLocDwarfExpression::emitSigned(int64_t Value) {
183 getActiveStreamer().emitSLEB128(Value, Twine(Value));
184}
185
186void DebugLocDwarfExpression::emitUnsigned(uint64_t Value) {
187 getActiveStreamer().emitULEB128(Value, Twine(Value));
188}
189
190void DebugLocDwarfExpression::emitData1(uint8_t Value) {
191 getActiveStreamer().emitInt8(Value, Twine(Value));
192}
193
194void DebugLocDwarfExpression::emitBaseTypeRef(uint64_t Idx) {
195 assert(Idx < (1ULL << (ULEB128PadSize * 7)) && "Idx wont fit")(static_cast <bool> (Idx < (1ULL << (ULEB128PadSize
* 7)) && "Idx wont fit") ? void (0) : __assert_fail (
"Idx < (1ULL << (ULEB128PadSize * 7)) && \"Idx wont fit\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 195, __extension__ __PRETTY_FUNCTION__))
;
196 getActiveStreamer().emitULEB128(Idx, Twine(Idx), ULEB128PadSize);
197}
198
199bool DebugLocDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
200 llvm::Register MachineReg) {
201 // This information is not available while emitting .debug_loc entries.
202 return false;
203}
204
205void DebugLocDwarfExpression::enableTemporaryBuffer() {
206 assert(!IsBuffering && "Already buffering?")(static_cast <bool> (!IsBuffering && "Already buffering?"
) ? void (0) : __assert_fail ("!IsBuffering && \"Already buffering?\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 206, __extension__ __PRETTY_FUNCTION__))
;
207 if (!TmpBuf)
208 TmpBuf = std::make_unique<TempBuffer>(OutBS.GenerateComments);
209 IsBuffering = true;
210}
211
212void DebugLocDwarfExpression::disableTemporaryBuffer() { IsBuffering = false; }
213
214unsigned DebugLocDwarfExpression::getTemporaryBufferSize() {
215 return TmpBuf ? TmpBuf->Bytes.size() : 0;
216}
217
218void DebugLocDwarfExpression::commitTemporaryBuffer() {
219 if (!TmpBuf)
220 return;
221 for (auto Byte : enumerate(TmpBuf->Bytes)) {
222 const char *Comment = (Byte.index() < TmpBuf->Comments.size())
223 ? TmpBuf->Comments[Byte.index()].c_str()
224 : "";
225 OutBS.emitInt8(Byte.value(), Comment);
226 }
227 TmpBuf->Bytes.clear();
228 TmpBuf->Comments.clear();
229}
230
231const DIType *DbgVariable::getType() const {
232 return getVariable()->getType();
233}
234
235/// Get .debug_loc entry for the instruction range starting at MI.
236static DbgValueLoc getDebugLocValue(const MachineInstr *MI) {
237 const DIExpression *Expr = MI->getDebugExpression();
238 const bool IsVariadic = MI->isDebugValueList();
239 assert(MI->getNumOperands() >= 3)(static_cast <bool> (MI->getNumOperands() >= 3) ?
void (0) : __assert_fail ("MI->getNumOperands() >= 3",
"/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 239, __extension__ __PRETTY_FUNCTION__))
;
240 SmallVector<DbgValueLocEntry, 4> DbgValueLocEntries;
241 for (const MachineOperand &Op : MI->debug_operands()) {
242 if (Op.isReg()) {
243 MachineLocation MLoc(Op.getReg(),
244 MI->isNonListDebugValue() && MI->isDebugOffsetImm());
245 DbgValueLocEntries.push_back(DbgValueLocEntry(MLoc));
246 } else if (Op.isTargetIndex()) {
247 DbgValueLocEntries.push_back(
248 DbgValueLocEntry(TargetIndexLocation(Op.getIndex(), Op.getOffset())));
249 } else if (Op.isImm())
250 DbgValueLocEntries.push_back(DbgValueLocEntry(Op.getImm()));
251 else if (Op.isFPImm())
252 DbgValueLocEntries.push_back(DbgValueLocEntry(Op.getFPImm()));
253 else if (Op.isCImm())
254 DbgValueLocEntries.push_back(DbgValueLocEntry(Op.getCImm()));
255 else
256 llvm_unreachable("Unexpected debug operand in DBG_VALUE* instruction!")::llvm::llvm_unreachable_internal("Unexpected debug operand in DBG_VALUE* instruction!"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 256)
;
257 }
258 return DbgValueLoc(Expr, DbgValueLocEntries, IsVariadic);
259}
260
261void DbgVariable::initializeDbgValue(const MachineInstr *DbgValue) {
262 assert(FrameIndexExprs.empty() && "Already initialized?")(static_cast <bool> (FrameIndexExprs.empty() &&
"Already initialized?") ? void (0) : __assert_fail ("FrameIndexExprs.empty() && \"Already initialized?\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 262, __extension__ __PRETTY_FUNCTION__))
;
263 assert(!ValueLoc.get() && "Already initialized?")(static_cast <bool> (!ValueLoc.get() && "Already initialized?"
) ? void (0) : __assert_fail ("!ValueLoc.get() && \"Already initialized?\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 263, __extension__ __PRETTY_FUNCTION__))
;
264
265 assert(getVariable() == DbgValue->getDebugVariable() && "Wrong variable")(static_cast <bool> (getVariable() == DbgValue->getDebugVariable
() && "Wrong variable") ? void (0) : __assert_fail ("getVariable() == DbgValue->getDebugVariable() && \"Wrong variable\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 265, __extension__ __PRETTY_FUNCTION__))
;
266 assert(getInlinedAt() == DbgValue->getDebugLoc()->getInlinedAt() &&(static_cast <bool> (getInlinedAt() == DbgValue->getDebugLoc
()->getInlinedAt() && "Wrong inlined-at") ? void (
0) : __assert_fail ("getInlinedAt() == DbgValue->getDebugLoc()->getInlinedAt() && \"Wrong inlined-at\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 267, __extension__ __PRETTY_FUNCTION__))
267 "Wrong inlined-at")(static_cast <bool> (getInlinedAt() == DbgValue->getDebugLoc
()->getInlinedAt() && "Wrong inlined-at") ? void (
0) : __assert_fail ("getInlinedAt() == DbgValue->getDebugLoc()->getInlinedAt() && \"Wrong inlined-at\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 267, __extension__ __PRETTY_FUNCTION__))
;
268
269 ValueLoc = std::make_unique<DbgValueLoc>(getDebugLocValue(DbgValue));
270 if (auto *E = DbgValue->getDebugExpression())
271 if (E->getNumElements())
272 FrameIndexExprs.push_back({0, E});
273}
274
275ArrayRef<DbgVariable::FrameIndexExpr> DbgVariable::getFrameIndexExprs() const {
276 if (FrameIndexExprs.size() == 1)
277 return FrameIndexExprs;
278
279 assert(llvm::all_of(FrameIndexExprs,(static_cast <bool> (llvm::all_of(FrameIndexExprs, [](const
FrameIndexExpr &A) { return A.Expr->isFragment(); }) &&
"multiple FI expressions without DW_OP_LLVM_fragment") ? void
(0) : __assert_fail ("llvm::all_of(FrameIndexExprs, [](const FrameIndexExpr &A) { return A.Expr->isFragment(); }) && \"multiple FI expressions without DW_OP_LLVM_fragment\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 283, __extension__ __PRETTY_FUNCTION__))
280 [](const FrameIndexExpr &A) {(static_cast <bool> (llvm::all_of(FrameIndexExprs, [](const
FrameIndexExpr &A) { return A.Expr->isFragment(); }) &&
"multiple FI expressions without DW_OP_LLVM_fragment") ? void
(0) : __assert_fail ("llvm::all_of(FrameIndexExprs, [](const FrameIndexExpr &A) { return A.Expr->isFragment(); }) && \"multiple FI expressions without DW_OP_LLVM_fragment\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 283, __extension__ __PRETTY_FUNCTION__))
281 return A.Expr->isFragment();(static_cast <bool> (llvm::all_of(FrameIndexExprs, [](const
FrameIndexExpr &A) { return A.Expr->isFragment(); }) &&
"multiple FI expressions without DW_OP_LLVM_fragment") ? void
(0) : __assert_fail ("llvm::all_of(FrameIndexExprs, [](const FrameIndexExpr &A) { return A.Expr->isFragment(); }) && \"multiple FI expressions without DW_OP_LLVM_fragment\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 283, __extension__ __PRETTY_FUNCTION__))
282 }) &&(static_cast <bool> (llvm::all_of(FrameIndexExprs, [](const
FrameIndexExpr &A) { return A.Expr->isFragment(); }) &&
"multiple FI expressions without DW_OP_LLVM_fragment") ? void
(0) : __assert_fail ("llvm::all_of(FrameIndexExprs, [](const FrameIndexExpr &A) { return A.Expr->isFragment(); }) && \"multiple FI expressions without DW_OP_LLVM_fragment\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 283, __extension__ __PRETTY_FUNCTION__))
283 "multiple FI expressions without DW_OP_LLVM_fragment")(static_cast <bool> (llvm::all_of(FrameIndexExprs, [](const
FrameIndexExpr &A) { return A.Expr->isFragment(); }) &&
"multiple FI expressions without DW_OP_LLVM_fragment") ? void
(0) : __assert_fail ("llvm::all_of(FrameIndexExprs, [](const FrameIndexExpr &A) { return A.Expr->isFragment(); }) && \"multiple FI expressions without DW_OP_LLVM_fragment\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 283, __extension__ __PRETTY_FUNCTION__))
;
284 llvm::sort(FrameIndexExprs,
285 [](const FrameIndexExpr &A, const FrameIndexExpr &B) -> bool {
286 return A.Expr->getFragmentInfo()->OffsetInBits <
287 B.Expr->getFragmentInfo()->OffsetInBits;
288 });
289
290 return FrameIndexExprs;
291}
292
293void DbgVariable::addMMIEntry(const DbgVariable &V) {
294 assert(DebugLocListIndex == ~0U && !ValueLoc.get() && "not an MMI entry")(static_cast <bool> (DebugLocListIndex == ~0U &&
!ValueLoc.get() && "not an MMI entry") ? void (0) : __assert_fail
("DebugLocListIndex == ~0U && !ValueLoc.get() && \"not an MMI entry\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 294, __extension__ __PRETTY_FUNCTION__))
;
295 assert(V.DebugLocListIndex == ~0U && !V.ValueLoc.get() && "not an MMI entry")(static_cast <bool> (V.DebugLocListIndex == ~0U &&
!V.ValueLoc.get() && "not an MMI entry") ? void (0) :
__assert_fail ("V.DebugLocListIndex == ~0U && !V.ValueLoc.get() && \"not an MMI entry\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 295, __extension__ __PRETTY_FUNCTION__))
;
296 assert(V.getVariable() == getVariable() && "conflicting variable")(static_cast <bool> (V.getVariable() == getVariable() &&
"conflicting variable") ? void (0) : __assert_fail ("V.getVariable() == getVariable() && \"conflicting variable\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 296, __extension__ __PRETTY_FUNCTION__))
;
297 assert(V.getInlinedAt() == getInlinedAt() && "conflicting inlined-at location")(static_cast <bool> (V.getInlinedAt() == getInlinedAt()
&& "conflicting inlined-at location") ? void (0) : __assert_fail
("V.getInlinedAt() == getInlinedAt() && \"conflicting inlined-at location\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 297, __extension__ __PRETTY_FUNCTION__))
;
298
299 assert(!FrameIndexExprs.empty() && "Expected an MMI entry")(static_cast <bool> (!FrameIndexExprs.empty() &&
"Expected an MMI entry") ? void (0) : __assert_fail ("!FrameIndexExprs.empty() && \"Expected an MMI entry\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 299, __extension__ __PRETTY_FUNCTION__))
;
300 assert(!V.FrameIndexExprs.empty() && "Expected an MMI entry")(static_cast <bool> (!V.FrameIndexExprs.empty() &&
"Expected an MMI entry") ? void (0) : __assert_fail ("!V.FrameIndexExprs.empty() && \"Expected an MMI entry\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 300, __extension__ __PRETTY_FUNCTION__))
;
301
302 // FIXME: This logic should not be necessary anymore, as we now have proper
303 // deduplication. However, without it, we currently run into the assertion
304 // below, which means that we are likely dealing with broken input, i.e. two
305 // non-fragment entries for the same variable at different frame indices.
306 if (FrameIndexExprs.size()) {
307 auto *Expr = FrameIndexExprs.back().Expr;
308 if (!Expr || !Expr->isFragment())
309 return;
310 }
311
312 for (const auto &FIE : V.FrameIndexExprs)
313 // Ignore duplicate entries.
314 if (llvm::none_of(FrameIndexExprs, [&](const FrameIndexExpr &Other) {
315 return FIE.FI == Other.FI && FIE.Expr == Other.Expr;
316 }))
317 FrameIndexExprs.push_back(FIE);
318
319 assert((FrameIndexExprs.size() == 1 ||(static_cast <bool> ((FrameIndexExprs.size() == 1 || llvm
::all_of(FrameIndexExprs, [](FrameIndexExpr &FIE) { return
FIE.Expr && FIE.Expr->isFragment(); })) &&
"conflicting locations for variable") ? void (0) : __assert_fail
("(FrameIndexExprs.size() == 1 || llvm::all_of(FrameIndexExprs, [](FrameIndexExpr &FIE) { return FIE.Expr && FIE.Expr->isFragment(); })) && \"conflicting locations for variable\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 324, __extension__ __PRETTY_FUNCTION__))
320 llvm::all_of(FrameIndexExprs,(static_cast <bool> ((FrameIndexExprs.size() == 1 || llvm
::all_of(FrameIndexExprs, [](FrameIndexExpr &FIE) { return
FIE.Expr && FIE.Expr->isFragment(); })) &&
"conflicting locations for variable") ? void (0) : __assert_fail
("(FrameIndexExprs.size() == 1 || llvm::all_of(FrameIndexExprs, [](FrameIndexExpr &FIE) { return FIE.Expr && FIE.Expr->isFragment(); })) && \"conflicting locations for variable\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 324, __extension__ __PRETTY_FUNCTION__))
321 [](FrameIndexExpr &FIE) {(static_cast <bool> ((FrameIndexExprs.size() == 1 || llvm
::all_of(FrameIndexExprs, [](FrameIndexExpr &FIE) { return
FIE.Expr && FIE.Expr->isFragment(); })) &&
"conflicting locations for variable") ? void (0) : __assert_fail
("(FrameIndexExprs.size() == 1 || llvm::all_of(FrameIndexExprs, [](FrameIndexExpr &FIE) { return FIE.Expr && FIE.Expr->isFragment(); })) && \"conflicting locations for variable\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 324, __extension__ __PRETTY_FUNCTION__))
322 return FIE.Expr && FIE.Expr->isFragment();(static_cast <bool> ((FrameIndexExprs.size() == 1 || llvm
::all_of(FrameIndexExprs, [](FrameIndexExpr &FIE) { return
FIE.Expr && FIE.Expr->isFragment(); })) &&
"conflicting locations for variable") ? void (0) : __assert_fail
("(FrameIndexExprs.size() == 1 || llvm::all_of(FrameIndexExprs, [](FrameIndexExpr &FIE) { return FIE.Expr && FIE.Expr->isFragment(); })) && \"conflicting locations for variable\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 324, __extension__ __PRETTY_FUNCTION__))
323 })) &&(static_cast <bool> ((FrameIndexExprs.size() == 1 || llvm
::all_of(FrameIndexExprs, [](FrameIndexExpr &FIE) { return
FIE.Expr && FIE.Expr->isFragment(); })) &&
"conflicting locations for variable") ? void (0) : __assert_fail
("(FrameIndexExprs.size() == 1 || llvm::all_of(FrameIndexExprs, [](FrameIndexExpr &FIE) { return FIE.Expr && FIE.Expr->isFragment(); })) && \"conflicting locations for variable\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 324, __extension__ __PRETTY_FUNCTION__))
324 "conflicting locations for variable")(static_cast <bool> ((FrameIndexExprs.size() == 1 || llvm
::all_of(FrameIndexExprs, [](FrameIndexExpr &FIE) { return
FIE.Expr && FIE.Expr->isFragment(); })) &&
"conflicting locations for variable") ? void (0) : __assert_fail
("(FrameIndexExprs.size() == 1 || llvm::all_of(FrameIndexExprs, [](FrameIndexExpr &FIE) { return FIE.Expr && FIE.Expr->isFragment(); })) && \"conflicting locations for variable\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 324, __extension__ __PRETTY_FUNCTION__))
;
325}
326
327static AccelTableKind computeAccelTableKind(unsigned DwarfVersion,
328 bool GenerateTypeUnits,
329 DebuggerKind Tuning,
330 const Triple &TT) {
331 // Honor an explicit request.
332 if (AccelTables != AccelTableKind::Default)
333 return AccelTables;
334
335 // Accelerator tables with type units are currently not supported.
336 if (GenerateTypeUnits)
337 return AccelTableKind::None;
338
339 // Accelerator tables get emitted if targetting DWARF v5 or LLDB. DWARF v5
340 // always implies debug_names. For lower standard versions we use apple
341 // accelerator tables on apple platforms and debug_names elsewhere.
342 if (DwarfVersion >= 5)
343 return AccelTableKind::Dwarf;
344 if (Tuning == DebuggerKind::LLDB)
345 return TT.isOSBinFormatMachO() ? AccelTableKind::Apple
346 : AccelTableKind::Dwarf;
347 return AccelTableKind::None;
348}
349
350DwarfDebug::DwarfDebug(AsmPrinter *A)
351 : DebugHandlerBase(A), DebugLocs(A->OutStreamer->isVerboseAsm()),
352 InfoHolder(A, "info_string", DIEValueAllocator),
353 SkeletonHolder(A, "skel_string", DIEValueAllocator),
354 IsDarwin(A->TM.getTargetTriple().isOSDarwin()) {
355 const Triple &TT = Asm->TM.getTargetTriple();
356
357 // Make sure we know our "debugger tuning". The target option takes
358 // precedence; fall back to triple-based defaults.
359 if (Asm->TM.Options.DebuggerTuning != DebuggerKind::Default)
360 DebuggerTuning = Asm->TM.Options.DebuggerTuning;
361 else if (IsDarwin)
362 DebuggerTuning = DebuggerKind::LLDB;
363 else if (TT.isPS4CPU())
364 DebuggerTuning = DebuggerKind::SCE;
365 else if (TT.isOSAIX())
366 DebuggerTuning = DebuggerKind::DBX;
367 else
368 DebuggerTuning = DebuggerKind::GDB;
369
370 if (DwarfInlinedStrings == Default)
371 UseInlineStrings = TT.isNVPTX() || tuneForDBX();
372 else
373 UseInlineStrings = DwarfInlinedStrings == Enable;
374
375 UseLocSection = !TT.isNVPTX();
376
377 HasAppleExtensionAttributes = tuneForLLDB();
378
379 // Handle split DWARF.
380 HasSplitDwarf = !Asm->TM.Options.MCOptions.SplitDwarfFile.empty();
381
382 // SCE defaults to linkage names only for abstract subprograms.
383 if (DwarfLinkageNames == DefaultLinkageNames)
384 UseAllLinkageNames = !tuneForSCE();
385 else
386 UseAllLinkageNames = DwarfLinkageNames == AllLinkageNames;
387
388 unsigned DwarfVersionNumber = Asm->TM.Options.MCOptions.DwarfVersion;
389 unsigned DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
390 : MMI->getModule()->getDwarfVersion();
391 // Use dwarf 4 by default if nothing is requested. For NVPTX, use dwarf 2.
392 DwarfVersion =
393 TT.isNVPTX() ? 2 : (DwarfVersion ? DwarfVersion : dwarf::DWARF_VERSION);
394
395 bool Dwarf64 = DwarfVersion >= 3 && // DWARF64 was introduced in DWARFv3.
396 TT.isArch64Bit(); // DWARF64 requires 64-bit relocations.
397
398 // Support DWARF64
399 // 1: For ELF when requested.
400 // 2: For XCOFF64: the AIX assembler will fill in debug section lengths
401 // according to the DWARF64 format for 64-bit assembly, so we must use
402 // DWARF64 in the compiler too for 64-bit mode.
403 Dwarf64 &=
404 ((Asm->TM.Options.MCOptions.Dwarf64 || MMI->getModule()->isDwarf64()) &&
405 TT.isOSBinFormatELF()) ||
406 TT.isOSBinFormatXCOFF();
407
408 if (!Dwarf64 && TT.isArch64Bit() && TT.isOSBinFormatXCOFF())
409 report_fatal_error("XCOFF requires DWARF64 for 64-bit mode!");
410
411 UseRangesSection = !NoDwarfRangesSection && !TT.isNVPTX();
412
413 // Use sections as references. Force for NVPTX.
414 if (DwarfSectionsAsReferences == Default)
415 UseSectionsAsReferences = TT.isNVPTX();
416 else
417 UseSectionsAsReferences = DwarfSectionsAsReferences == Enable;
418
419 // Don't generate type units for unsupported object file formats.
420 GenerateTypeUnits = (A->TM.getTargetTriple().isOSBinFormatELF() ||
421 A->TM.getTargetTriple().isOSBinFormatWasm()) &&
422 GenerateDwarfTypeUnits;
423
424 TheAccelTableKind = computeAccelTableKind(
425 DwarfVersion, GenerateTypeUnits, DebuggerTuning, A->TM.getTargetTriple());
426
427 // Work around a GDB bug. GDB doesn't support the standard opcode;
428 // SCE doesn't support GNU's; LLDB prefers the standard opcode, which
429 // is defined as of DWARF 3.
430 // See GDB bug 11616 - DW_OP_form_tls_address is unimplemented
431 // https://sourceware.org/bugzilla/show_bug.cgi?id=11616
432 UseGNUTLSOpcode = tuneForGDB() || DwarfVersion < 3;
433
434 // GDB does not fully support the DWARF 4 representation for bitfields.
435 UseDWARF2Bitfields = (DwarfVersion < 4) || tuneForGDB();
436
437 // The DWARF v5 string offsets table has - possibly shared - contributions
438 // from each compile and type unit each preceded by a header. The string
439 // offsets table used by the pre-DWARF v5 split-DWARF implementation uses
440 // a monolithic string offsets table without any header.
441 UseSegmentedStringOffsetsTable = DwarfVersion >= 5;
442
443 // Emit call-site-param debug info for GDB and LLDB, if the target supports
444 // the debug entry values feature. It can also be enabled explicitly.
445 EmitDebugEntryValues = Asm->TM.Options.ShouldEmitDebugEntryValues();
446
447 // It is unclear if the GCC .debug_macro extension is well-specified
448 // for split DWARF. For now, do not allow LLVM to emit it.
449 UseDebugMacroSection =
450 DwarfVersion >= 5 || (UseGNUDebugMacro && !useSplitDwarf());
451 if (DwarfOpConvert == Default)
452 EnableOpConvert = !((tuneForGDB() && useSplitDwarf()) || (tuneForLLDB() && !TT.isOSBinFormatMachO()));
453 else
454 EnableOpConvert = (DwarfOpConvert == Enable);
455
456 // Split DWARF would benefit object size significantly by trading reductions
457 // in address pool usage for slightly increased range list encodings.
458 if (DwarfVersion >= 5) {
459 MinimizeAddr = MinimizeAddrInV5Option;
460 // FIXME: In the future, enable this by default for Split DWARF where the
461 // tradeoff is more pronounced due to being able to offload the range
462 // lists to the dwo file and shrink object files/reduce relocations there.
463 if (MinimizeAddr == MinimizeAddrInV5::Default)
464 MinimizeAddr = MinimizeAddrInV5::Disabled;
465 }
466
467 Asm->OutStreamer->getContext().setDwarfVersion(DwarfVersion);
468 Asm->OutStreamer->getContext().setDwarfFormat(Dwarf64 ? dwarf::DWARF64
469 : dwarf::DWARF32);
470}
471
472// Define out of line so we don't have to include DwarfUnit.h in DwarfDebug.h.
473DwarfDebug::~DwarfDebug() = default;
474
475static bool isObjCClass(StringRef Name) {
476 return Name.startswith("+") || Name.startswith("-");
477}
478
479static bool hasObjCCategory(StringRef Name) {
480 if (!isObjCClass(Name))
481 return false;
482
483 return Name.find(") ") != StringRef::npos;
484}
485
486static void getObjCClassCategory(StringRef In, StringRef &Class,
487 StringRef &Category) {
488 if (!hasObjCCategory(In)) {
489 Class = In.slice(In.find('[') + 1, In.find(' '));
490 Category = "";
491 return;
492 }
493
494 Class = In.slice(In.find('[') + 1, In.find('('));
495 Category = In.slice(In.find('[') + 1, In.find(' '));
496}
497
498static StringRef getObjCMethodName(StringRef In) {
499 return In.slice(In.find(' ') + 1, In.find(']'));
500}
501
502// Add the various names to the Dwarf accelerator table names.
503void DwarfDebug::addSubprogramNames(const DICompileUnit &CU,
504 const DISubprogram *SP, DIE &Die) {
505 if (getAccelTableKind() != AccelTableKind::Apple &&
506 CU.getNameTableKind() == DICompileUnit::DebugNameTableKind::None)
507 return;
508
509 if (!SP->isDefinition())
510 return;
511
512 if (SP->getName() != "")
513 addAccelName(CU, SP->getName(), Die);
514
515 // If the linkage name is different than the name, go ahead and output that as
516 // well into the name table. Only do that if we are going to actually emit
517 // that name.
518 if (SP->getLinkageName() != "" && SP->getName() != SP->getLinkageName() &&
519 (useAllLinkageNames() || InfoHolder.getAbstractSPDies().lookup(SP)))
520 addAccelName(CU, SP->getLinkageName(), Die);
521
522 // If this is an Objective-C selector name add it to the ObjC accelerator
523 // too.
524 if (isObjCClass(SP->getName())) {
525 StringRef Class, Category;
526 getObjCClassCategory(SP->getName(), Class, Category);
527 addAccelObjC(CU, Class, Die);
528 if (Category != "")
529 addAccelObjC(CU, Category, Die);
530 // Also add the base method name to the name table.
531 addAccelName(CU, getObjCMethodName(SP->getName()), Die);
532 }
533}
534
535/// Check whether we should create a DIE for the given Scope, return true
536/// if we don't create a DIE (the corresponding DIE is null).
537bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
538 if (Scope->isAbstractScope())
539 return false;
540
541 // We don't create a DIE if there is no Range.
542 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
543 if (Ranges.empty())
544 return true;
545
546 if (Ranges.size() > 1)
547 return false;
548
549 // We don't create a DIE if we have a single Range and the end label
550 // is null.
551 return !getLabelAfterInsn(Ranges.front().second);
552}
553
554template <typename Func> static void forBothCUs(DwarfCompileUnit &CU, Func F) {
555 F(CU);
556 if (auto *SkelCU = CU.getSkeleton())
557 if (CU.getCUNode()->getSplitDebugInlining())
558 F(*SkelCU);
559}
560
561bool DwarfDebug::shareAcrossDWOCUs() const {
562 return SplitDwarfCrossCuReferences;
563}
564
565void DwarfDebug::constructAbstractSubprogramScopeDIE(DwarfCompileUnit &SrcCU,
566 LexicalScope *Scope) {
567 assert(Scope && Scope->getScopeNode())(static_cast <bool> (Scope && Scope->getScopeNode
()) ? void (0) : __assert_fail ("Scope && Scope->getScopeNode()"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 567, __extension__ __PRETTY_FUNCTION__))
;
568 assert(Scope->isAbstractScope())(static_cast <bool> (Scope->isAbstractScope()) ? void
(0) : __assert_fail ("Scope->isAbstractScope()", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 568, __extension__ __PRETTY_FUNCTION__))
;
569 assert(!Scope->getInlinedAt())(static_cast <bool> (!Scope->getInlinedAt()) ? void (
0) : __assert_fail ("!Scope->getInlinedAt()", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 569, __extension__ __PRETTY_FUNCTION__))
;
570
571 auto *SP = cast<DISubprogram>(Scope->getScopeNode());
572
573 // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
574 // was inlined from another compile unit.
575 if (useSplitDwarf() && !shareAcrossDWOCUs() && !SP->getUnit()->getSplitDebugInlining())
576 // Avoid building the original CU if it won't be used
577 SrcCU.constructAbstractSubprogramScopeDIE(Scope);
578 else {
579 auto &CU = getOrCreateDwarfCompileUnit(SP->getUnit());
580 if (auto *SkelCU = CU.getSkeleton()) {
581 (shareAcrossDWOCUs() ? CU : SrcCU)
582 .constructAbstractSubprogramScopeDIE(Scope);
583 if (CU.getCUNode()->getSplitDebugInlining())
584 SkelCU->constructAbstractSubprogramScopeDIE(Scope);
585 } else
586 CU.constructAbstractSubprogramScopeDIE(Scope);
587 }
588}
589
590/// Represents a parameter whose call site value can be described by applying a
591/// debug expression to a register in the forwarded register worklist.
592struct FwdRegParamInfo {
593 /// The described parameter register.
594 unsigned ParamReg;
595
596 /// Debug expression that has been built up when walking through the
597 /// instruction chain that produces the parameter's value.
598 const DIExpression *Expr;
599};
600
601/// Register worklist for finding call site values.
602using FwdRegWorklist = MapVector<unsigned, SmallVector<FwdRegParamInfo, 2>>;
603
604/// Append the expression \p Addition to \p Original and return the result.
605static const DIExpression *combineDIExpressions(const DIExpression *Original,
606 const DIExpression *Addition) {
607 std::vector<uint64_t> Elts = Addition->getElements().vec();
608 // Avoid multiple DW_OP_stack_values.
609 if (Original->isImplicit() && Addition->isImplicit())
610 erase_value(Elts, dwarf::DW_OP_stack_value);
611 const DIExpression *CombinedExpr =
612 (Elts.size() > 0) ? DIExpression::append(Original, Elts) : Original;
613 return CombinedExpr;
614}
615
616/// Emit call site parameter entries that are described by the given value and
617/// debug expression.
618template <typename ValT>
619static void finishCallSiteParams(ValT Val, const DIExpression *Expr,
620 ArrayRef<FwdRegParamInfo> DescribedParams,
621 ParamSet &Params) {
622 for (auto Param : DescribedParams) {
623 bool ShouldCombineExpressions = Expr && Param.Expr->getNumElements() > 0;
624
625 // TODO: Entry value operations can currently not be combined with any
626 // other expressions, so we can't emit call site entries in those cases.
627 if (ShouldCombineExpressions && Expr->isEntryValue())
628 continue;
629
630 // If a parameter's call site value is produced by a chain of
631 // instructions we may have already created an expression for the
632 // parameter when walking through the instructions. Append that to the
633 // base expression.
634 const DIExpression *CombinedExpr =
635 ShouldCombineExpressions ? combineDIExpressions(Expr, Param.Expr)
636 : Expr;
637 assert((!CombinedExpr || CombinedExpr->isValid()) &&(static_cast <bool> ((!CombinedExpr || CombinedExpr->
isValid()) && "Combined debug expression is invalid")
? void (0) : __assert_fail ("(!CombinedExpr || CombinedExpr->isValid()) && \"Combined debug expression is invalid\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 638, __extension__ __PRETTY_FUNCTION__))
638 "Combined debug expression is invalid")(static_cast <bool> ((!CombinedExpr || CombinedExpr->
isValid()) && "Combined debug expression is invalid")
? void (0) : __assert_fail ("(!CombinedExpr || CombinedExpr->isValid()) && \"Combined debug expression is invalid\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 638, __extension__ __PRETTY_FUNCTION__))
;
639
640 DbgValueLoc DbgLocVal(CombinedExpr, DbgValueLocEntry(Val));
641 DbgCallSiteParam CSParm(Param.ParamReg, DbgLocVal);
642 Params.push_back(CSParm);
643 ++NumCSParams;
644 }
645}
646
647/// Add \p Reg to the worklist, if it's not already present, and mark that the
648/// given parameter registers' values can (potentially) be described using
649/// that register and an debug expression.
650static void addToFwdRegWorklist(FwdRegWorklist &Worklist, unsigned Reg,
651 const DIExpression *Expr,
652 ArrayRef<FwdRegParamInfo> ParamsToAdd) {
653 auto I = Worklist.insert({Reg, {}});
654 auto &ParamsForFwdReg = I.first->second;
655 for (auto Param : ParamsToAdd) {
656 assert(none_of(ParamsForFwdReg,(static_cast <bool> (none_of(ParamsForFwdReg, [Param](const
FwdRegParamInfo &D) { return D.ParamReg == Param.ParamReg
; }) && "Same parameter described twice by forwarding reg"
) ? void (0) : __assert_fail ("none_of(ParamsForFwdReg, [Param](const FwdRegParamInfo &D) { return D.ParamReg == Param.ParamReg; }) && \"Same parameter described twice by forwarding reg\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 660, __extension__ __PRETTY_FUNCTION__))
657 [Param](const FwdRegParamInfo &D) {(static_cast <bool> (none_of(ParamsForFwdReg, [Param](const
FwdRegParamInfo &D) { return D.ParamReg == Param.ParamReg
; }) && "Same parameter described twice by forwarding reg"
) ? void (0) : __assert_fail ("none_of(ParamsForFwdReg, [Param](const FwdRegParamInfo &D) { return D.ParamReg == Param.ParamReg; }) && \"Same parameter described twice by forwarding reg\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 660, __extension__ __PRETTY_FUNCTION__))
658 return D.ParamReg == Param.ParamReg;(static_cast <bool> (none_of(ParamsForFwdReg, [Param](const
FwdRegParamInfo &D) { return D.ParamReg == Param.ParamReg
; }) && "Same parameter described twice by forwarding reg"
) ? void (0) : __assert_fail ("none_of(ParamsForFwdReg, [Param](const FwdRegParamInfo &D) { return D.ParamReg == Param.ParamReg; }) && \"Same parameter described twice by forwarding reg\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 660, __extension__ __PRETTY_FUNCTION__))
659 }) &&(static_cast <bool> (none_of(ParamsForFwdReg, [Param](const
FwdRegParamInfo &D) { return D.ParamReg == Param.ParamReg
; }) && "Same parameter described twice by forwarding reg"
) ? void (0) : __assert_fail ("none_of(ParamsForFwdReg, [Param](const FwdRegParamInfo &D) { return D.ParamReg == Param.ParamReg; }) && \"Same parameter described twice by forwarding reg\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 660, __extension__ __PRETTY_FUNCTION__))
660 "Same parameter described twice by forwarding reg")(static_cast <bool> (none_of(ParamsForFwdReg, [Param](const
FwdRegParamInfo &D) { return D.ParamReg == Param.ParamReg
; }) && "Same parameter described twice by forwarding reg"
) ? void (0) : __assert_fail ("none_of(ParamsForFwdReg, [Param](const FwdRegParamInfo &D) { return D.ParamReg == Param.ParamReg; }) && \"Same parameter described twice by forwarding reg\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 660, __extension__ __PRETTY_FUNCTION__))
;
661
662 // If a parameter's call site value is produced by a chain of
663 // instructions we may have already created an expression for the
664 // parameter when walking through the instructions. Append that to the
665 // new expression.
666 const DIExpression *CombinedExpr = combineDIExpressions(Expr, Param.Expr);
667 ParamsForFwdReg.push_back({Param.ParamReg, CombinedExpr});
668 }
669}
670
671/// Interpret values loaded into registers by \p CurMI.
672static void interpretValues(const MachineInstr *CurMI,
673 FwdRegWorklist &ForwardedRegWorklist,
674 ParamSet &Params) {
675
676 const MachineFunction *MF = CurMI->getMF();
677 const DIExpression *EmptyExpr =
678 DIExpression::get(MF->getFunction().getContext(), {});
679 const auto &TRI = *MF->getSubtarget().getRegisterInfo();
680 const auto &TII = *MF->getSubtarget().getInstrInfo();
681 const auto &TLI = *MF->getSubtarget().getTargetLowering();
682
683 // If an instruction defines more than one item in the worklist, we may run
684 // into situations where a worklist register's value is (potentially)
685 // described by the previous value of another register that is also defined
686 // by that instruction.
687 //
688 // This can for example occur in cases like this:
689 //
690 // $r1 = mov 123
691 // $r0, $r1 = mvrr $r1, 456
692 // call @foo, $r0, $r1
693 //
694 // When describing $r1's value for the mvrr instruction, we need to make sure
695 // that we don't finalize an entry value for $r0, as that is dependent on the
696 // previous value of $r1 (123 rather than 456).
697 //
698 // In order to not have to distinguish between those cases when finalizing
699 // entry values, we simply postpone adding new parameter registers to the
700 // worklist, by first keeping them in this temporary container until the
701 // instruction has been handled.
702 FwdRegWorklist TmpWorklistItems;
703
704 // If the MI is an instruction defining one or more parameters' forwarding
705 // registers, add those defines.
706 auto getForwardingRegsDefinedByMI = [&](const MachineInstr &MI,
707 SmallSetVector<unsigned, 4> &Defs) {
708 if (MI.isDebugInstr())
709 return;
710
711 for (const MachineOperand &MO : MI.operands()) {
712 if (MO.isReg() && MO.isDef() &&
713 Register::isPhysicalRegister(MO.getReg())) {
714 for (auto &FwdReg : ForwardedRegWorklist)
715 if (TRI.regsOverlap(FwdReg.first, MO.getReg()))
716 Defs.insert(FwdReg.first);
717 }
718 }
719 };
720
721 // Set of worklist registers that are defined by this instruction.
722 SmallSetVector<unsigned, 4> FwdRegDefs;
723
724 getForwardingRegsDefinedByMI(*CurMI, FwdRegDefs);
725 if (FwdRegDefs.empty())
726 return;
727
728 for (auto ParamFwdReg : FwdRegDefs) {
729 if (auto ParamValue = TII.describeLoadedValue(*CurMI, ParamFwdReg)) {
730 if (ParamValue->first.isImm()) {
731 int64_t Val = ParamValue->first.getImm();
732 finishCallSiteParams(Val, ParamValue->second,
733 ForwardedRegWorklist[ParamFwdReg], Params);
734 } else if (ParamValue->first.isReg()) {
735 Register RegLoc = ParamValue->first.getReg();
736 Register SP = TLI.getStackPointerRegisterToSaveRestore();
737 Register FP = TRI.getFrameRegister(*MF);
738 bool IsSPorFP = (RegLoc == SP) || (RegLoc == FP);
739 if (TRI.isCalleeSavedPhysReg(RegLoc, *MF) || IsSPorFP) {
740 MachineLocation MLoc(RegLoc, /*Indirect=*/IsSPorFP);
741 finishCallSiteParams(MLoc, ParamValue->second,
742 ForwardedRegWorklist[ParamFwdReg], Params);
743 } else {
744 // ParamFwdReg was described by the non-callee saved register
745 // RegLoc. Mark that the call site values for the parameters are
746 // dependent on that register instead of ParamFwdReg. Since RegLoc
747 // may be a register that will be handled in this iteration, we
748 // postpone adding the items to the worklist, and instead keep them
749 // in a temporary container.
750 addToFwdRegWorklist(TmpWorklistItems, RegLoc, ParamValue->second,
751 ForwardedRegWorklist[ParamFwdReg]);
752 }
753 }
754 }
755 }
756
757 // Remove all registers that this instruction defines from the worklist.
758 for (auto ParamFwdReg : FwdRegDefs)
759 ForwardedRegWorklist.erase(ParamFwdReg);
760
761 // Now that we are done handling this instruction, add items from the
762 // temporary worklist to the real one.
763 for (auto &New : TmpWorklistItems)
764 addToFwdRegWorklist(ForwardedRegWorklist, New.first, EmptyExpr, New.second);
765 TmpWorklistItems.clear();
766}
767
768static bool interpretNextInstr(const MachineInstr *CurMI,
769 FwdRegWorklist &ForwardedRegWorklist,
770 ParamSet &Params) {
771 // Skip bundle headers.
772 if (CurMI->isBundle())
773 return true;
774
775 // If the next instruction is a call we can not interpret parameter's
776 // forwarding registers or we finished the interpretation of all
777 // parameters.
778 if (CurMI->isCall())
779 return false;
780
781 if (ForwardedRegWorklist.empty())
782 return false;
783
784 // Avoid NOP description.
785 if (CurMI->getNumOperands() == 0)
786 return true;
787
788 interpretValues(CurMI, ForwardedRegWorklist, Params);
789
790 return true;
791}
792
793/// Try to interpret values loaded into registers that forward parameters
794/// for \p CallMI. Store parameters with interpreted value into \p Params.
795static void collectCallSiteParameters(const MachineInstr *CallMI,
796 ParamSet &Params) {
797 const MachineFunction *MF = CallMI->getMF();
798 const auto &CalleesMap = MF->getCallSitesInfo();
799 auto CallFwdRegsInfo = CalleesMap.find(CallMI);
800
801 // There is no information for the call instruction.
802 if (CallFwdRegsInfo == CalleesMap.end())
803 return;
804
805 const MachineBasicBlock *MBB = CallMI->getParent();
806
807 // Skip the call instruction.
808 auto I = std::next(CallMI->getReverseIterator());
809
810 FwdRegWorklist ForwardedRegWorklist;
811
812 const DIExpression *EmptyExpr =
813 DIExpression::get(MF->getFunction().getContext(), {});
814
815 // Add all the forwarding registers into the ForwardedRegWorklist.
816 for (const auto &ArgReg : CallFwdRegsInfo->second) {
817 bool InsertedReg =
818 ForwardedRegWorklist.insert({ArgReg.Reg, {{ArgReg.Reg, EmptyExpr}}})
819 .second;
820 assert(InsertedReg && "Single register used to forward two arguments?")(static_cast <bool> (InsertedReg && "Single register used to forward two arguments?"
) ? void (0) : __assert_fail ("InsertedReg && \"Single register used to forward two arguments?\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 820, __extension__ __PRETTY_FUNCTION__))
;
821 (void)InsertedReg;
822 }
823
824 // Do not emit CSInfo for undef forwarding registers.
825 for (auto &MO : CallMI->uses())
826 if (MO.isReg() && MO.isUndef())
827 ForwardedRegWorklist.erase(MO.getReg());
828
829 // We erase, from the ForwardedRegWorklist, those forwarding registers for
830 // which we successfully describe a loaded value (by using
831 // the describeLoadedValue()). For those remaining arguments in the working
832 // list, for which we do not describe a loaded value by
833 // the describeLoadedValue(), we try to generate an entry value expression
834 // for their call site value description, if the call is within the entry MBB.
835 // TODO: Handle situations when call site parameter value can be described
836 // as the entry value within basic blocks other than the first one.
837 bool ShouldTryEmitEntryVals = MBB->getIterator() == MF->begin();
838
839 // Search for a loading value in forwarding registers inside call delay slot.
840 if (CallMI->hasDelaySlot()) {
841 auto Suc = std::next(CallMI->getIterator());
842 // Only one-instruction delay slot is supported.
843 auto BundleEnd = llvm::getBundleEnd(CallMI->getIterator());
844 (void)BundleEnd;
845 assert(std::next(Suc) == BundleEnd &&(static_cast <bool> (std::next(Suc) == BundleEnd &&
"More than one instruction in call delay slot") ? void (0) :
__assert_fail ("std::next(Suc) == BundleEnd && \"More than one instruction in call delay slot\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 846, __extension__ __PRETTY_FUNCTION__))
846 "More than one instruction in call delay slot")(static_cast <bool> (std::next(Suc) == BundleEnd &&
"More than one instruction in call delay slot") ? void (0) :
__assert_fail ("std::next(Suc) == BundleEnd && \"More than one instruction in call delay slot\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 846, __extension__ __PRETTY_FUNCTION__))
;
847 // Try to interpret value loaded by instruction.
848 if (!interpretNextInstr(&*Suc, ForwardedRegWorklist, Params))
849 return;
850 }
851
852 // Search for a loading value in forwarding registers.
853 for (; I != MBB->rend(); ++I) {
854 // Try to interpret values loaded by instruction.
855 if (!interpretNextInstr(&*I, ForwardedRegWorklist, Params))
856 return;
857 }
858
859 // Emit the call site parameter's value as an entry value.
860 if (ShouldTryEmitEntryVals) {
861 // Create an expression where the register's entry value is used.
862 DIExpression *EntryExpr = DIExpression::get(
863 MF->getFunction().getContext(), {dwarf::DW_OP_LLVM_entry_value, 1});
864 for (auto &RegEntry : ForwardedRegWorklist) {
865 MachineLocation MLoc(RegEntry.first);
866 finishCallSiteParams(MLoc, EntryExpr, RegEntry.second, Params);
867 }
868 }
869}
870
871void DwarfDebug::constructCallSiteEntryDIEs(const DISubprogram &SP,
872 DwarfCompileUnit &CU, DIE &ScopeDIE,
873 const MachineFunction &MF) {
874 // Add a call site-related attribute (DWARF5, Sec. 3.3.1.3). Do this only if
875 // the subprogram is required to have one.
876 if (!SP.areAllCallsDescribed() || !SP.isDefinition())
877 return;
878
879 // Use DW_AT_call_all_calls to express that call site entries are present
880 // for both tail and non-tail calls. Don't use DW_AT_call_all_source_calls
881 // because one of its requirements is not met: call site entries for
882 // optimized-out calls are elided.
883 CU.addFlag(ScopeDIE, CU.getDwarf5OrGNUAttr(dwarf::DW_AT_call_all_calls));
884
885 const TargetInstrInfo *TII = MF.getSubtarget().getInstrInfo();
886 assert(TII && "TargetInstrInfo not found: cannot label tail calls")(static_cast <bool> (TII && "TargetInstrInfo not found: cannot label tail calls"
) ? void (0) : __assert_fail ("TII && \"TargetInstrInfo not found: cannot label tail calls\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 886, __extension__ __PRETTY_FUNCTION__))
;
887
888 // Delay slot support check.
889 auto delaySlotSupported = [&](const MachineInstr &MI) {
890 if (!MI.isBundledWithSucc())
891 return false;
892 auto Suc = std::next(MI.getIterator());
893 auto CallInstrBundle = getBundleStart(MI.getIterator());
894 (void)CallInstrBundle;
895 auto DelaySlotBundle = getBundleStart(Suc);
896 (void)DelaySlotBundle;
897 // Ensure that label after call is following delay slot instruction.
898 // Ex. CALL_INSTRUCTION {
899 // DELAY_SLOT_INSTRUCTION }
900 // LABEL_AFTER_CALL
901 assert(getLabelAfterInsn(&*CallInstrBundle) ==(static_cast <bool> (getLabelAfterInsn(&*CallInstrBundle
) == getLabelAfterInsn(&*DelaySlotBundle) && "Call and its successor instruction don't have same label after."
) ? void (0) : __assert_fail ("getLabelAfterInsn(&*CallInstrBundle) == getLabelAfterInsn(&*DelaySlotBundle) && \"Call and its successor instruction don't have same label after.\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 903, __extension__ __PRETTY_FUNCTION__))
902 getLabelAfterInsn(&*DelaySlotBundle) &&(static_cast <bool> (getLabelAfterInsn(&*CallInstrBundle
) == getLabelAfterInsn(&*DelaySlotBundle) && "Call and its successor instruction don't have same label after."
) ? void (0) : __assert_fail ("getLabelAfterInsn(&*CallInstrBundle) == getLabelAfterInsn(&*DelaySlotBundle) && \"Call and its successor instruction don't have same label after.\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 903, __extension__ __PRETTY_FUNCTION__))
903 "Call and its successor instruction don't have same label after.")(static_cast <bool> (getLabelAfterInsn(&*CallInstrBundle
) == getLabelAfterInsn(&*DelaySlotBundle) && "Call and its successor instruction don't have same label after."
) ? void (0) : __assert_fail ("getLabelAfterInsn(&*CallInstrBundle) == getLabelAfterInsn(&*DelaySlotBundle) && \"Call and its successor instruction don't have same label after.\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 903, __extension__ __PRETTY_FUNCTION__))
;
904 return true;
905 };
906
907 // Emit call site entries for each call or tail call in the function.
908 for (const MachineBasicBlock &MBB : MF) {
909 for (const MachineInstr &MI : MBB.instrs()) {
910 // Bundles with call in them will pass the isCall() test below but do not
911 // have callee operand information so skip them here. Iterator will
912 // eventually reach the call MI.
913 if (MI.isBundle())
914 continue;
915
916 // Skip instructions which aren't calls. Both calls and tail-calling jump
917 // instructions (e.g TAILJMPd64) are classified correctly here.
918 if (!MI.isCandidateForCallSiteEntry())
919 continue;
920
921 // Skip instructions marked as frame setup, as they are not interesting to
922 // the user.
923 if (MI.getFlag(MachineInstr::FrameSetup))
924 continue;
925
926 // Check if delay slot support is enabled.
927 if (MI.hasDelaySlot() && !delaySlotSupported(*&MI))
928 return;
929
930 // If this is a direct call, find the callee's subprogram.
931 // In the case of an indirect call find the register that holds
932 // the callee.
933 const MachineOperand &CalleeOp = TII->getCalleeOperand(MI);
934 if (!CalleeOp.isGlobal() &&
935 (!CalleeOp.isReg() ||
936 !Register::isPhysicalRegister(CalleeOp.getReg())))
937 continue;
938
939 unsigned CallReg = 0;
940 const DISubprogram *CalleeSP = nullptr;
941 const Function *CalleeDecl = nullptr;
942 if (CalleeOp.isReg()) {
943 CallReg = CalleeOp.getReg();
944 if (!CallReg)
945 continue;
946 } else {
947 CalleeDecl = dyn_cast<Function>(CalleeOp.getGlobal());
948 if (!CalleeDecl || !CalleeDecl->getSubprogram())
949 continue;
950 CalleeSP = CalleeDecl->getSubprogram();
951 }
952
953 // TODO: Omit call site entries for runtime calls (objc_msgSend, etc).
954
955 bool IsTail = TII->isTailCall(MI);
956
957 // If MI is in a bundle, the label was created after the bundle since
958 // EmitFunctionBody iterates over top-level MIs. Get that top-level MI
959 // to search for that label below.
960 const MachineInstr *TopLevelCallMI =
961 MI.isInsideBundle() ? &*getBundleStart(MI.getIterator()) : &MI;
962
963 // For non-tail calls, the return PC is needed to disambiguate paths in
964 // the call graph which could lead to some target function. For tail
965 // calls, no return PC information is needed, unless tuning for GDB in
966 // DWARF4 mode in which case we fake a return PC for compatibility.
967 const MCSymbol *PCAddr =
968 (!IsTail || CU.useGNUAnalogForDwarf5Feature())
969 ? const_cast<MCSymbol *>(getLabelAfterInsn(TopLevelCallMI))
970 : nullptr;
971
972 // For tail calls, it's necessary to record the address of the branch
973 // instruction so that the debugger can show where the tail call occurred.
974 const MCSymbol *CallAddr =
975 IsTail ? getLabelBeforeInsn(TopLevelCallMI) : nullptr;
976
977 assert((IsTail || PCAddr) && "Non-tail call without return PC")(static_cast <bool> ((IsTail || PCAddr) && "Non-tail call without return PC"
) ? void (0) : __assert_fail ("(IsTail || PCAddr) && \"Non-tail call without return PC\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 977, __extension__ __PRETTY_FUNCTION__))
;
978
979 LLVM_DEBUG(dbgs() << "CallSiteEntry: " << MF.getName() << " -> "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { dbgs() << "CallSiteEntry: " << MF
.getName() << " -> " << (CalleeDecl ? CalleeDecl
->getName() : StringRef(MF.getSubtarget() .getRegisterInfo
() ->getName(CallReg))) << (IsTail ? " [IsTail]" : ""
) << "\n"; } } while (false)
980 << (CalleeDecl ? CalleeDecl->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { dbgs() << "CallSiteEntry: " << MF
.getName() << " -> " << (CalleeDecl ? CalleeDecl
->getName() : StringRef(MF.getSubtarget() .getRegisterInfo
() ->getName(CallReg))) << (IsTail ? " [IsTail]" : ""
) << "\n"; } } while (false)
981 : StringRef(MF.getSubtarget()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { dbgs() << "CallSiteEntry: " << MF
.getName() << " -> " << (CalleeDecl ? CalleeDecl
->getName() : StringRef(MF.getSubtarget() .getRegisterInfo
() ->getName(CallReg))) << (IsTail ? " [IsTail]" : ""
) << "\n"; } } while (false)
982 .getRegisterInfo()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { dbgs() << "CallSiteEntry: " << MF
.getName() << " -> " << (CalleeDecl ? CalleeDecl
->getName() : StringRef(MF.getSubtarget() .getRegisterInfo
() ->getName(CallReg))) << (IsTail ? " [IsTail]" : ""
) << "\n"; } } while (false)
983 ->getName(CallReg)))do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { dbgs() << "CallSiteEntry: " << MF
.getName() << " -> " << (CalleeDecl ? CalleeDecl
->getName() : StringRef(MF.getSubtarget() .getRegisterInfo
() ->getName(CallReg))) << (IsTail ? " [IsTail]" : ""
) << "\n"; } } while (false)
984 << (IsTail ? " [IsTail]" : "") << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { dbgs() << "CallSiteEntry: " << MF
.getName() << " -> " << (CalleeDecl ? CalleeDecl
->getName() : StringRef(MF.getSubtarget() .getRegisterInfo
() ->getName(CallReg))) << (IsTail ? " [IsTail]" : ""
) << "\n"; } } while (false)
;
985
986 DIE &CallSiteDIE = CU.constructCallSiteEntryDIE(
987 ScopeDIE, CalleeSP, IsTail, PCAddr, CallAddr, CallReg);
988
989 // Optionally emit call-site-param debug info.
990 if (emitDebugEntryValues()) {
991 ParamSet Params;
992 // Try to interpret values of call site parameters.
993 collectCallSiteParameters(&MI, Params);
994 CU.constructCallSiteParmEntryDIEs(CallSiteDIE, Params);
995 }
996 }
997 }
998}
999
1000void DwarfDebug::addGnuPubAttributes(DwarfCompileUnit &U, DIE &D) const {
1001 if (!U.hasDwarfPubSections())
1002 return;
1003
1004 U.addFlag(D, dwarf::DW_AT_GNU_pubnames);
1005}
1006
1007void DwarfDebug::finishUnitAttributes(const DICompileUnit *DIUnit,
1008 DwarfCompileUnit &NewCU) {
1009 DIE &Die = NewCU.getUnitDie();
1010 StringRef FN = DIUnit->getFilename();
1011
1012 StringRef Producer = DIUnit->getProducer();
1013 StringRef Flags = DIUnit->getFlags();
1014 if (!Flags.empty() && !useAppleExtensionAttributes()) {
1015 std::string ProducerWithFlags = Producer.str() + " " + Flags.str();
1016 NewCU.addString(Die, dwarf::DW_AT_producer, ProducerWithFlags);
1017 } else
1018 NewCU.addString(Die, dwarf::DW_AT_producer, Producer);
1019
1020 NewCU.addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
1021 DIUnit->getSourceLanguage());
1022 NewCU.addString(Die, dwarf::DW_AT_name, FN);
1023 StringRef SysRoot = DIUnit->getSysRoot();
1024 if (!SysRoot.empty())
1025 NewCU.addString(Die, dwarf::DW_AT_LLVM_sysroot, SysRoot);
1026 StringRef SDK = DIUnit->getSDK();
1027 if (!SDK.empty())
1028 NewCU.addString(Die, dwarf::DW_AT_APPLE_sdk, SDK);
1029
1030 // Add DW_str_offsets_base to the unit DIE, except for split units.
1031 if (useSegmentedStringOffsetsTable() && !useSplitDwarf())
1032 NewCU.addStringOffsetsStart();
1033
1034 if (!useSplitDwarf()) {
1035 NewCU.initStmtList();
1036
1037 // If we're using split dwarf the compilation dir is going to be in the
1038 // skeleton CU and so we don't need to duplicate it here.
1039 if (!CompilationDir.empty())
1040 NewCU.addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
1041 addGnuPubAttributes(NewCU, Die);
1042 }
1043
1044 if (useAppleExtensionAttributes()) {
1045 if (DIUnit->isOptimized())
1046 NewCU.addFlag(Die, dwarf::DW_AT_APPLE_optimized);
1047
1048 StringRef Flags = DIUnit->getFlags();
1049 if (!Flags.empty())
1050 NewCU.addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
1051
1052 if (unsigned RVer = DIUnit->getRuntimeVersion())
1053 NewCU.addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1054 dwarf::DW_FORM_data1, RVer);
1055 }
1056
1057 if (DIUnit->getDWOId()) {
1058 // This CU is either a clang module DWO or a skeleton CU.
1059 NewCU.addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8,
1060 DIUnit->getDWOId());
1061 if (!DIUnit->getSplitDebugFilename().empty()) {
1062 // This is a prefabricated skeleton CU.
1063 dwarf::Attribute attrDWOName = getDwarfVersion() >= 5
1064 ? dwarf::DW_AT_dwo_name
1065 : dwarf::DW_AT_GNU_dwo_name;
1066 NewCU.addString(Die, attrDWOName, DIUnit->getSplitDebugFilename());
1067 }
1068 }
1069}
1070// Create new DwarfCompileUnit for the given metadata node with tag
1071// DW_TAG_compile_unit.
1072DwarfCompileUnit &
1073DwarfDebug::getOrCreateDwarfCompileUnit(const DICompileUnit *DIUnit) {
1074 if (auto *CU = CUMap.lookup(DIUnit))
1075 return *CU;
1076
1077 CompilationDir = DIUnit->getDirectory();
1078
1079 auto OwnedUnit = std::make_unique<DwarfCompileUnit>(
1080 InfoHolder.getUnits().size(), DIUnit, Asm, this, &InfoHolder);
1081 DwarfCompileUnit &NewCU = *OwnedUnit;
1082 InfoHolder.addUnit(std::move(OwnedUnit));
1083
1084 for (auto *IE : DIUnit->getImportedEntities())
1085 NewCU.addImportedEntity(IE);
1086
1087 // LTO with assembly output shares a single line table amongst multiple CUs.
1088 // To avoid the compilation directory being ambiguous, let the line table
1089 // explicitly describe the directory of all files, never relying on the
1090 // compilation directory.
1091 if (!Asm->OutStreamer->hasRawTextSupport() || SingleCU)
1092 Asm->OutStreamer->emitDwarfFile0Directive(
1093 CompilationDir, DIUnit->getFilename(), getMD5AsBytes(DIUnit->getFile()),
1094 DIUnit->getSource(), NewCU.getUniqueID());
1095
1096 if (useSplitDwarf()) {
1097 NewCU.setSkeleton(constructSkeletonCU(NewCU));
1098 NewCU.setSection(Asm->getObjFileLowering().getDwarfInfoDWOSection());
1099 } else {
1100 finishUnitAttributes(DIUnit, NewCU);
1101 NewCU.setSection(Asm->getObjFileLowering().getDwarfInfoSection());
1102 }
1103
1104 CUMap.insert({DIUnit, &NewCU});
1105 CUDieMap.insert({&NewCU.getUnitDie(), &NewCU});
1106 return NewCU;
1107}
1108
1109void DwarfDebug::constructAndAddImportedEntityDIE(DwarfCompileUnit &TheCU,
1110 const DIImportedEntity *N) {
1111 if (isa<DILocalScope>(N->getScope()))
1112 return;
1113 if (DIE *D = TheCU.getOrCreateContextDIE(N->getScope()))
1114 D->addChild(TheCU.constructImportedEntityDIE(N));
1115}
1116
1117/// Sort and unique GVEs by comparing their fragment offset.
1118static SmallVectorImpl<DwarfCompileUnit::GlobalExpr> &
1119sortGlobalExprs(SmallVectorImpl<DwarfCompileUnit::GlobalExpr> &GVEs) {
1120 llvm::sort(
1121 GVEs, [](DwarfCompileUnit::GlobalExpr A, DwarfCompileUnit::GlobalExpr B) {
1122 // Sort order: first null exprs, then exprs without fragment
1123 // info, then sort by fragment offset in bits.
1124 // FIXME: Come up with a more comprehensive comparator so
1125 // the sorting isn't non-deterministic, and so the following
1126 // std::unique call works correctly.
1127 if (!A.Expr || !B.Expr)
1128 return !!B.Expr;
1129 auto FragmentA = A.Expr->getFragmentInfo();
1130 auto FragmentB = B.Expr->getFragmentInfo();
1131 if (!FragmentA || !FragmentB)
1132 return !!FragmentB;
1133 return FragmentA->OffsetInBits < FragmentB->OffsetInBits;
1134 });
1135 GVEs.erase(std::unique(GVEs.begin(), GVEs.end(),
1136 [](DwarfCompileUnit::GlobalExpr A,
1137 DwarfCompileUnit::GlobalExpr B) {
1138 return A.Expr == B.Expr;
1139 }),
1140 GVEs.end());
1141 return GVEs;
1142}
1143
1144// Emit all Dwarf sections that should come prior to the content. Create
1145// global DIEs and emit initial debug info sections. This is invoked by
1146// the target AsmPrinter.
1147void DwarfDebug::beginModule(Module *M) {
1148 DebugHandlerBase::beginModule(M);
1149
1150 if (!Asm || !MMI->hasDebugInfo())
1151 return;
1152
1153 unsigned NumDebugCUs = std::distance(M->debug_compile_units_begin(),
1154 M->debug_compile_units_end());
1155 assert(NumDebugCUs > 0 && "Asm unexpectedly initialized")(static_cast <bool> (NumDebugCUs > 0 && "Asm unexpectedly initialized"
) ? void (0) : __assert_fail ("NumDebugCUs > 0 && \"Asm unexpectedly initialized\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 1155, __extension__ __PRETTY_FUNCTION__))
;
1156 assert(MMI->hasDebugInfo() &&(static_cast <bool> (MMI->hasDebugInfo() && "DebugInfoAvailabilty unexpectedly not initialized"
) ? void (0) : __assert_fail ("MMI->hasDebugInfo() && \"DebugInfoAvailabilty unexpectedly not initialized\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 1157, __extension__ __PRETTY_FUNCTION__))
1157 "DebugInfoAvailabilty unexpectedly not initialized")(static_cast <bool> (MMI->hasDebugInfo() && "DebugInfoAvailabilty unexpectedly not initialized"
) ? void (0) : __assert_fail ("MMI->hasDebugInfo() && \"DebugInfoAvailabilty unexpectedly not initialized\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 1157, __extension__ __PRETTY_FUNCTION__))
;
1158 SingleCU = NumDebugCUs == 1;
1159 DenseMap<DIGlobalVariable *, SmallVector<DwarfCompileUnit::GlobalExpr, 1>>
1160 GVMap;
1161 for (const GlobalVariable &Global : M->globals()) {
1162 SmallVector<DIGlobalVariableExpression *, 1> GVs;
1163 Global.getDebugInfo(GVs);
1164 for (auto *GVE : GVs)
1165 GVMap[GVE->getVariable()].push_back({&Global, GVE->getExpression()});
1166 }
1167
1168 // Create the symbol that designates the start of the unit's contribution
1169 // to the string offsets table. In a split DWARF scenario, only the skeleton
1170 // unit has the DW_AT_str_offsets_base attribute (and hence needs the symbol).
1171 if (useSegmentedStringOffsetsTable())
1172 (useSplitDwarf() ? SkeletonHolder : InfoHolder)
1173 .setStringOffsetsStartSym(Asm->createTempSymbol("str_offsets_base"));
1174
1175
1176 // Create the symbols that designates the start of the DWARF v5 range list
1177 // and locations list tables. They are located past the table headers.
1178 if (getDwarfVersion() >= 5) {
1179 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1180 Holder.setRnglistsTableBaseSym(
1181 Asm->createTempSymbol("rnglists_table_base"));
1182
1183 if (useSplitDwarf())
1184 InfoHolder.setRnglistsTableBaseSym(
1185 Asm->createTempSymbol("rnglists_dwo_table_base"));
1186 }
1187
1188 // Create the symbol that points to the first entry following the debug
1189 // address table (.debug_addr) header.
1190 AddrPool.setLabel(Asm->createTempSymbol("addr_table_base"));
1191 DebugLocs.setSym(Asm->createTempSymbol("loclists_table_base"));
1192
1193 for (DICompileUnit *CUNode : M->debug_compile_units()) {
1194 // FIXME: Move local imported entities into a list attached to the
1195 // subprogram, then this search won't be needed and a
1196 // getImportedEntities().empty() test should go below with the rest.
1197 bool HasNonLocalImportedEntities = llvm::any_of(
1198 CUNode->getImportedEntities(), [](const DIImportedEntity *IE) {
1199 return !isa<DILocalScope>(IE->getScope());
1200 });
1201
1202 if (!HasNonLocalImportedEntities && CUNode->getEnumTypes().empty() &&
1203 CUNode->getRetainedTypes().empty() &&
1204 CUNode->getGlobalVariables().empty() && CUNode->getMacros().empty())
1205 continue;
1206
1207 DwarfCompileUnit &CU = getOrCreateDwarfCompileUnit(CUNode);
1208
1209 // Global Variables.
1210 for (auto *GVE : CUNode->getGlobalVariables()) {
1211 // Don't bother adding DIGlobalVariableExpressions listed in the CU if we
1212 // already know about the variable and it isn't adding a constant
1213 // expression.
1214 auto &GVMapEntry = GVMap[GVE->getVariable()];
1215 auto *Expr = GVE->getExpression();
1216 if (!GVMapEntry.size() || (Expr && Expr->isConstant()))
1217 GVMapEntry.push_back({nullptr, Expr});
1218 }
1219
1220 DenseSet<DIGlobalVariable *> Processed;
1221 for (auto *GVE : CUNode->getGlobalVariables()) {
1222 DIGlobalVariable *GV = GVE->getVariable();
1223 if (Processed.insert(GV).second)
1224 CU.getOrCreateGlobalVariableDIE(GV, sortGlobalExprs(GVMap[GV]));
1225 }
1226
1227 for (auto *Ty : CUNode->getEnumTypes()) {
1228 // The enum types array by design contains pointers to
1229 // MDNodes rather than DIRefs. Unique them here.
1230 CU.getOrCreateTypeDIE(cast<DIType>(Ty));
1231 }
1232 for (auto *Ty : CUNode->getRetainedTypes()) {
1233 // The retained types array by design contains pointers to
1234 // MDNodes rather than DIRefs. Unique them here.
1235 if (DIType *RT = dyn_cast<DIType>(Ty))
1236 // There is no point in force-emitting a forward declaration.
1237 CU.getOrCreateTypeDIE(RT);
1238 }
1239 // Emit imported_modules last so that the relevant context is already
1240 // available.
1241 for (auto *IE : CUNode->getImportedEntities())
1242 constructAndAddImportedEntityDIE(CU, IE);
1243 }
1244}
1245
1246void DwarfDebug::finishEntityDefinitions() {
1247 for (const auto &Entity : ConcreteEntities) {
1248 DIE *Die = Entity->getDIE();
1249 assert(Die)(static_cast <bool> (Die) ? void (0) : __assert_fail ("Die"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 1249, __extension__ __PRETTY_FUNCTION__))
;
1250 // FIXME: Consider the time-space tradeoff of just storing the unit pointer
1251 // in the ConcreteEntities list, rather than looking it up again here.
1252 // DIE::getUnit isn't simple - it walks parent pointers, etc.
1253 DwarfCompileUnit *Unit = CUDieMap.lookup(Die->getUnitDie());
1254 assert(Unit)(static_cast <bool> (Unit) ? void (0) : __assert_fail (
"Unit", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 1254, __extension__ __PRETTY_FUNCTION__))
;
1255 Unit->finishEntityDefinition(Entity.get());
1256 }
1257}
1258
1259void DwarfDebug::finishSubprogramDefinitions() {
1260 for (const DISubprogram *SP : ProcessedSPNodes) {
1261 assert(SP->getUnit()->getEmissionKind() != DICompileUnit::NoDebug)(static_cast <bool> (SP->getUnit()->getEmissionKind
() != DICompileUnit::NoDebug) ? void (0) : __assert_fail ("SP->getUnit()->getEmissionKind() != DICompileUnit::NoDebug"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 1261, __extension__ __PRETTY_FUNCTION__))
;
1262 forBothCUs(
1263 getOrCreateDwarfCompileUnit(SP->getUnit()),
1264 [&](DwarfCompileUnit &CU) { CU.finishSubprogramDefinition(SP); });
1265 }
1266}
1267
1268void DwarfDebug::finalizeModuleInfo() {
1269 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1270
1271 finishSubprogramDefinitions();
1272
1273 finishEntityDefinitions();
1274
1275 // Include the DWO file name in the hash if there's more than one CU.
1276 // This handles ThinLTO's situation where imported CUs may very easily be
1277 // duplicate with the same CU partially imported into another ThinLTO unit.
1278 StringRef DWOName;
1279 if (CUMap.size() > 1)
1280 DWOName = Asm->TM.Options.MCOptions.SplitDwarfFile;
1281
1282 // Handle anything that needs to be done on a per-unit basis after
1283 // all other generation.
1284 for (const auto &P : CUMap) {
1285 auto &TheCU = *P.second;
1286 if (TheCU.getCUNode()->isDebugDirectivesOnly())
1287 continue;
1288 // Emit DW_AT_containing_type attribute to connect types with their
1289 // vtable holding type.
1290 TheCU.constructContainingTypeDIEs();
1291
1292 // Add CU specific attributes if we need to add any.
1293 // If we're splitting the dwarf out now that we've got the entire
1294 // CU then add the dwo id to it.
1295 auto *SkCU = TheCU.getSkeleton();
1296
1297 bool HasSplitUnit = SkCU && !TheCU.getUnitDie().children().empty();
1298
1299 if (HasSplitUnit) {
1300 dwarf::Attribute attrDWOName = getDwarfVersion() >= 5
1301 ? dwarf::DW_AT_dwo_name
1302 : dwarf::DW_AT_GNU_dwo_name;
1303 finishUnitAttributes(TheCU.getCUNode(), TheCU);
1304 TheCU.addString(TheCU.getUnitDie(), attrDWOName,
1305 Asm->TM.Options.MCOptions.SplitDwarfFile);
1306 SkCU->addString(SkCU->getUnitDie(), attrDWOName,
1307 Asm->TM.Options.MCOptions.SplitDwarfFile);
1308 // Emit a unique identifier for this CU.
1309 uint64_t ID =
1310 DIEHash(Asm, &TheCU).computeCUSignature(DWOName, TheCU.getUnitDie());
1311 if (getDwarfVersion() >= 5) {
1312 TheCU.setDWOId(ID);
1313 SkCU->setDWOId(ID);
1314 } else {
1315 TheCU.addUInt(TheCU.getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1316 dwarf::DW_FORM_data8, ID);
1317 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1318 dwarf::DW_FORM_data8, ID);
1319 }
1320
1321 if (getDwarfVersion() < 5 && !SkeletonHolder.getRangeLists().empty()) {
1322 const MCSymbol *Sym = TLOF.getDwarfRangesSection()->getBeginSymbol();
1323 SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_ranges_base,
1324 Sym, Sym);
1325 }
1326 } else if (SkCU) {
1327 finishUnitAttributes(SkCU->getCUNode(), *SkCU);
1328 }
1329
1330 // If we have code split among multiple sections or non-contiguous
1331 // ranges of code then emit a DW_AT_ranges attribute on the unit that will
1332 // remain in the .o file, otherwise add a DW_AT_low_pc.
1333 // FIXME: We should use ranges allow reordering of code ala
1334 // .subsections_via_symbols in mach-o. This would mean turning on
1335 // ranges for all subprogram DIEs for mach-o.
1336 DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
1337
1338 if (unsigned NumRanges = TheCU.getRanges().size()) {
1339 if (NumRanges > 1 && useRangesSection())
1340 // A DW_AT_low_pc attribute may also be specified in combination with
1341 // DW_AT_ranges to specify the default base address for use in
1342 // location lists (see Section 2.6.2) and range lists (see Section
1343 // 2.17.3).
1344 U.addUInt(U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
1345 else
1346 U.setBaseAddress(TheCU.getRanges().front().Begin);
1347 U.attachRangesOrLowHighPC(U.getUnitDie(), TheCU.takeRanges());
1348 }
1349
1350 // We don't keep track of which addresses are used in which CU so this
1351 // is a bit pessimistic under LTO.
1352 if ((HasSplitUnit || getDwarfVersion() >= 5) && !AddrPool.isEmpty())
1353 U.addAddrTableBase();
1354
1355 if (getDwarfVersion() >= 5) {
1356 if (U.hasRangeLists())
1357 U.addRnglistsBase();
1358
1359 if (!DebugLocs.getLists().empty()) {
1360 if (!useSplitDwarf())
1361 U.addSectionLabel(U.getUnitDie(), dwarf::DW_AT_loclists_base,
1362 DebugLocs.getSym(),
1363 TLOF.getDwarfLoclistsSection()->getBeginSymbol());
1364 }
1365 }
1366
1367 auto *CUNode = cast<DICompileUnit>(P.first);
1368 // If compile Unit has macros, emit "DW_AT_macro_info/DW_AT_macros"
1369 // attribute.
1370 if (CUNode->getMacros()) {
1371 if (UseDebugMacroSection) {
1372 if (useSplitDwarf())
1373 TheCU.addSectionDelta(
1374 TheCU.getUnitDie(), dwarf::DW_AT_macros, U.getMacroLabelBegin(),
1375 TLOF.getDwarfMacroDWOSection()->getBeginSymbol());
1376 else {
1377 dwarf::Attribute MacrosAttr = getDwarfVersion() >= 5
1378 ? dwarf::DW_AT_macros
1379 : dwarf::DW_AT_GNU_macros;
1380 U.addSectionLabel(U.getUnitDie(), MacrosAttr, U.getMacroLabelBegin(),
1381 TLOF.getDwarfMacroSection()->getBeginSymbol());
1382 }
1383 } else {
1384 if (useSplitDwarf())
1385 TheCU.addSectionDelta(
1386 TheCU.getUnitDie(), dwarf::DW_AT_macro_info,
1387 U.getMacroLabelBegin(),
1388 TLOF.getDwarfMacinfoDWOSection()->getBeginSymbol());
1389 else
1390 U.addSectionLabel(U.getUnitDie(), dwarf::DW_AT_macro_info,
1391 U.getMacroLabelBegin(),
1392 TLOF.getDwarfMacinfoSection()->getBeginSymbol());
1393 }
1394 }
1395 }
1396
1397 // Emit all frontend-produced Skeleton CUs, i.e., Clang modules.
1398 for (auto *CUNode : MMI->getModule()->debug_compile_units())
1399 if (CUNode->getDWOId())
1400 getOrCreateDwarfCompileUnit(CUNode);
1401
1402 // Compute DIE offsets and sizes.
1403 InfoHolder.computeSizeAndOffsets();
1404 if (useSplitDwarf())
1405 SkeletonHolder.computeSizeAndOffsets();
1406}
1407
1408// Emit all Dwarf sections that should come after the content.
1409void DwarfDebug::endModule() {
1410 assert(CurFn == nullptr)(static_cast <bool> (CurFn == nullptr) ? void (0) : __assert_fail
("CurFn == nullptr", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 1410, __extension__ __PRETTY_FUNCTION__))
;
1411 assert(CurMI == nullptr)(static_cast <bool> (CurMI == nullptr) ? void (0) : __assert_fail
("CurMI == nullptr", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 1411, __extension__ __PRETTY_FUNCTION__))
;
1412
1413 for (const auto &P : CUMap) {
1414 auto &CU = *P.second;
1415 CU.createBaseTypeDIEs();
1416 }
1417
1418 // If we aren't actually generating debug info (check beginModule -
1419 // conditionalized on the presence of the llvm.dbg.cu metadata node)
1420 if (!Asm || !MMI->hasDebugInfo())
1421 return;
1422
1423 // Finalize the debug info for the module.
1424 finalizeModuleInfo();
1425
1426 if (useSplitDwarf())
1427 // Emit debug_loc.dwo/debug_loclists.dwo section.
1428 emitDebugLocDWO();
1429 else
1430 // Emit debug_loc/debug_loclists section.
1431 emitDebugLoc();
1432
1433 // Corresponding abbreviations into a abbrev section.
1434 emitAbbreviations();
1435
1436 // Emit all the DIEs into a debug info section.
1437 emitDebugInfo();
1438
1439 // Emit info into a debug aranges section.
1440 if (GenerateARangeSection)
1441 emitDebugARanges();
1442
1443 // Emit info into a debug ranges section.
1444 emitDebugRanges();
1445
1446 if (useSplitDwarf())
1447 // Emit info into a debug macinfo.dwo section.
1448 emitDebugMacinfoDWO();
1449 else
1450 // Emit info into a debug macinfo/macro section.
1451 emitDebugMacinfo();
1452
1453 emitDebugStr();
1454
1455 if (useSplitDwarf()) {
1456 emitDebugStrDWO();
1457 emitDebugInfoDWO();
1458 emitDebugAbbrevDWO();
1459 emitDebugLineDWO();
1460 emitDebugRangesDWO();
1461 }
1462
1463 emitDebugAddr();
1464
1465 // Emit info into the dwarf accelerator table sections.
1466 switch (getAccelTableKind()) {
1467 case AccelTableKind::Apple:
1468 emitAccelNames();
1469 emitAccelObjC();
1470 emitAccelNamespaces();
1471 emitAccelTypes();
1472 break;
1473 case AccelTableKind::Dwarf:
1474 emitAccelDebugNames();
1475 break;
1476 case AccelTableKind::None:
1477 break;
1478 case AccelTableKind::Default:
1479 llvm_unreachable("Default should have already been resolved.")::llvm::llvm_unreachable_internal("Default should have already been resolved."
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 1479)
;
1480 }
1481
1482 // Emit the pubnames and pubtypes sections if requested.
1483 emitDebugPubSections();
1484
1485 // clean up.
1486 // FIXME: AbstractVariables.clear();
1487}
1488
1489void DwarfDebug::ensureAbstractEntityIsCreated(DwarfCompileUnit &CU,
1490 const DINode *Node,
1491 const MDNode *ScopeNode) {
1492 if (CU.getExistingAbstractEntity(Node))
1493 return;
1494
1495 CU.createAbstractEntity(Node, LScopes.getOrCreateAbstractScope(
1496 cast<DILocalScope>(ScopeNode)));
1497}
1498
1499void DwarfDebug::ensureAbstractEntityIsCreatedIfScoped(DwarfCompileUnit &CU,
1500 const DINode *Node, const MDNode *ScopeNode) {
1501 if (CU.getExistingAbstractEntity(Node))
1502 return;
1503
1504 if (LexicalScope *Scope =
1505 LScopes.findAbstractScope(cast_or_null<DILocalScope>(ScopeNode)))
1506 CU.createAbstractEntity(Node, Scope);
1507}
1508
1509// Collect variable information from side table maintained by MF.
1510void DwarfDebug::collectVariableInfoFromMFTable(
1511 DwarfCompileUnit &TheCU, DenseSet<InlinedEntity> &Processed) {
1512 SmallDenseMap<InlinedEntity, DbgVariable *> MFVars;
1513 LLVM_DEBUG(dbgs() << "DwarfDebug: collecting variables from MF side table\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { dbgs() << "DwarfDebug: collecting variables from MF side table\n"
; } } while (false)
;
1514 for (const auto &VI : Asm->MF->getVariableDbgInfo()) {
1515 if (!VI.Var)
1516 continue;
1517 assert(VI.Var->isValidLocationForIntrinsic(VI.Loc) &&(static_cast <bool> (VI.Var->isValidLocationForIntrinsic
(VI.Loc) && "Expected inlined-at fields to agree") ? void
(0) : __assert_fail ("VI.Var->isValidLocationForIntrinsic(VI.Loc) && \"Expected inlined-at fields to agree\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 1518, __extension__ __PRETTY_FUNCTION__))
1518 "Expected inlined-at fields to agree")(static_cast <bool> (VI.Var->isValidLocationForIntrinsic
(VI.Loc) && "Expected inlined-at fields to agree") ? void
(0) : __assert_fail ("VI.Var->isValidLocationForIntrinsic(VI.Loc) && \"Expected inlined-at fields to agree\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 1518, __extension__ __PRETTY_FUNCTION__))
;
1519
1520 InlinedEntity Var(VI.Var, VI.Loc->getInlinedAt());
1521 Processed.insert(Var);
1522 LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
1523
1524 // If variable scope is not found then skip this variable.
1525 if (!Scope) {
1526 LLVM_DEBUG(dbgs() << "Dropping debug info for " << VI.Var->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { dbgs() << "Dropping debug info for " <<
VI.Var->getName() << ", no variable scope found\n";
} } while (false)
1527 << ", no variable scope found\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { dbgs() << "Dropping debug info for " <<
VI.Var->getName() << ", no variable scope found\n";
} } while (false)
;
1528 continue;
1529 }
1530
1531 ensureAbstractEntityIsCreatedIfScoped(TheCU, Var.first, Scope->getScopeNode());
1532 auto RegVar = std::make_unique<DbgVariable>(
1533 cast<DILocalVariable>(Var.first), Var.second);
1534 RegVar->initializeMMI(VI.Expr, VI.Slot);
1535 LLVM_DEBUG(dbgs() << "Created DbgVariable for " << VI.Var->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { dbgs() << "Created DbgVariable for " <<
VI.Var->getName() << "\n"; } } while (false)
1536 << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { dbgs() << "Created DbgVariable for " <<
VI.Var->getName() << "\n"; } } while (false)
;
1537
1538 if (DbgVariable *DbgVar = MFVars.lookup(Var))
1539 DbgVar->addMMIEntry(*RegVar);
1540 else if (InfoHolder.addScopeVariable(Scope, RegVar.get())) {
1541 MFVars.insert({Var, RegVar.get()});
1542 ConcreteEntities.push_back(std::move(RegVar));
1543 }
1544 }
1545}
1546
1547/// Determine whether a *singular* DBG_VALUE is valid for the entirety of its
1548/// enclosing lexical scope. The check ensures there are no other instructions
1549/// in the same lexical scope preceding the DBG_VALUE and that its range is
1550/// either open or otherwise rolls off the end of the scope.
1551static bool validThroughout(LexicalScopes &LScopes,
1552 const MachineInstr *DbgValue,
1553 const MachineInstr *RangeEnd,
1554 const InstructionOrdering &Ordering) {
1555 assert(DbgValue->getDebugLoc() && "DBG_VALUE without a debug location")(static_cast <bool> (DbgValue->getDebugLoc() &&
"DBG_VALUE without a debug location") ? void (0) : __assert_fail
("DbgValue->getDebugLoc() && \"DBG_VALUE without a debug location\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 1555, __extension__ __PRETTY_FUNCTION__))
;
5
Called C++ object pointer is null
1556 auto MBB = DbgValue->getParent();
1557 auto DL = DbgValue->getDebugLoc();
1558 auto *LScope = LScopes.findLexicalScope(DL);
1559 // Scope doesn't exist; this is a dead DBG_VALUE.
1560 if (!LScope)
1561 return false;
1562 auto &LSRange = LScope->getRanges();
1563 if (LSRange.size() == 0)
1564 return false;
1565
1566 const MachineInstr *LScopeBegin = LSRange.front().first;
1567 // If the scope starts before the DBG_VALUE then we may have a negative
1568 // result. Otherwise the location is live coming into the scope and we
1569 // can skip the following checks.
1570 if (!Ordering.isBefore(DbgValue, LScopeBegin)) {
1571 // Exit if the lexical scope begins outside of the current block.
1572 if (LScopeBegin->getParent() != MBB)
1573 return false;
1574
1575 MachineBasicBlock::const_reverse_iterator Pred(DbgValue);
1576 for (++Pred; Pred != MBB->rend(); ++Pred) {
1577 if (Pred->getFlag(MachineInstr::FrameSetup))
1578 break;
1579 auto PredDL = Pred->getDebugLoc();
1580 if (!PredDL || Pred->isMetaInstruction())
1581 continue;
1582 // Check whether the instruction preceding the DBG_VALUE is in the same
1583 // (sub)scope as the DBG_VALUE.
1584 if (DL->getScope() == PredDL->getScope())
1585 return false;
1586 auto *PredScope = LScopes.findLexicalScope(PredDL);
1587 if (!PredScope || LScope->dominates(PredScope))
1588 return false;
1589 }
1590 }
1591
1592 // If the range of the DBG_VALUE is open-ended, report success.
1593 if (!RangeEnd)
1594 return true;
1595
1596 // Single, constant DBG_VALUEs in the prologue are promoted to be live
1597 // throughout the function. This is a hack, presumably for DWARF v2 and not
1598 // necessarily correct. It would be much better to use a dbg.declare instead
1599 // if we know the constant is live throughout the scope.
1600 if (MBB->pred_empty() &&
1601 all_of(DbgValue->debug_operands(),
1602 [](const MachineOperand &Op) { return Op.isImm(); }))
1603 return true;
1604
1605 // Test if the location terminates before the end of the scope.
1606 const MachineInstr *LScopeEnd = LSRange.back().second;
1607 if (Ordering.isBefore(RangeEnd, LScopeEnd))
1608 return false;
1609
1610 // There's a single location which starts at the scope start, and ends at or
1611 // after the scope end.
1612 return true;
1613}
1614
1615/// Build the location list for all DBG_VALUEs in the function that
1616/// describe the same variable. The resulting DebugLocEntries will have
1617/// strict monotonically increasing begin addresses and will never
1618/// overlap. If the resulting list has only one entry that is valid
1619/// throughout variable's scope return true.
1620//
1621// See the definition of DbgValueHistoryMap::Entry for an explanation of the
1622// different kinds of history map entries. One thing to be aware of is that if
1623// a debug value is ended by another entry (rather than being valid until the
1624// end of the function), that entry's instruction may or may not be included in
1625// the range, depending on if the entry is a clobbering entry (it has an
1626// instruction that clobbers one or more preceding locations), or if it is an
1627// (overlapping) debug value entry. This distinction can be seen in the example
1628// below. The first debug value is ended by the clobbering entry 2, and the
1629// second and third debug values are ended by the overlapping debug value entry
1630// 4.
1631//
1632// Input:
1633//
1634// History map entries [type, end index, mi]
1635//
1636// 0 | [DbgValue, 2, DBG_VALUE $reg0, [...] (fragment 0, 32)]
1637// 1 | | [DbgValue, 4, DBG_VALUE $reg1, [...] (fragment 32, 32)]
1638// 2 | | [Clobber, $reg0 = [...], -, -]
1639// 3 | | [DbgValue, 4, DBG_VALUE 123, [...] (fragment 64, 32)]
1640// 4 [DbgValue, ~0, DBG_VALUE @g, [...] (fragment 0, 96)]
1641//
1642// Output [start, end) [Value...]:
1643//
1644// [0-1) [(reg0, fragment 0, 32)]
1645// [1-3) [(reg0, fragment 0, 32), (reg1, fragment 32, 32)]
1646// [3-4) [(reg1, fragment 32, 32), (123, fragment 64, 32)]
1647// [4-) [(@g, fragment 0, 96)]
1648bool DwarfDebug::buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc,
1649 const DbgValueHistoryMap::Entries &Entries) {
1650 using OpenRange =
1651 std::pair<DbgValueHistoryMap::EntryIndex, DbgValueLoc>;
1652 SmallVector<OpenRange, 4> OpenRanges;
1653 bool isSafeForSingleLocation = true;
1654 const MachineInstr *StartDebugMI = nullptr;
1
'StartDebugMI' initialized to a null pointer value
1655 const MachineInstr *EndMI = nullptr;
1656
1657 for (auto EB = Entries.begin(), EI = EB, EE = Entries.end(); EI != EE; ++EI) {
2
Assuming 'EI' is equal to 'EE'
1658 const MachineInstr *Instr = EI->getInstr();
1659
1660 // Remove all values that are no longer live.
1661 size_t Index = std::distance(EB, EI);
1662 erase_if(OpenRanges, [&](OpenRange &R) { return R.first <= Index; });
1663
1664 // If we are dealing with a clobbering entry, this iteration will result in
1665 // a location list entry starting after the clobbering instruction.
1666 const MCSymbol *StartLabel =
1667 EI->isClobber() ? getLabelAfterInsn(Instr) : getLabelBeforeInsn(Instr);
1668 assert(StartLabel &&(static_cast <bool> (StartLabel && "Forgot label before/after instruction starting a range!"
) ? void (0) : __assert_fail ("StartLabel && \"Forgot label before/after instruction starting a range!\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 1669, __extension__ __PRETTY_FUNCTION__))
1669 "Forgot label before/after instruction starting a range!")(static_cast <bool> (StartLabel && "Forgot label before/after instruction starting a range!"
) ? void (0) : __assert_fail ("StartLabel && \"Forgot label before/after instruction starting a range!\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 1669, __extension__ __PRETTY_FUNCTION__))
;
1670
1671 const MCSymbol *EndLabel;
1672 if (std::next(EI) == Entries.end()) {
1673 const MachineBasicBlock &EndMBB = Asm->MF->back();
1674 EndLabel = Asm->MBBSectionRanges[EndMBB.getSectionIDNum()].EndLabel;
1675 if (EI->isClobber())
1676 EndMI = EI->getInstr();
1677 }
1678 else if (std::next(EI)->isClobber())
1679 EndLabel = getLabelAfterInsn(std::next(EI)->getInstr());
1680 else
1681 EndLabel = getLabelBeforeInsn(std::next(EI)->getInstr());
1682 assert(EndLabel && "Forgot label after instruction ending a range!")(static_cast <bool> (EndLabel && "Forgot label after instruction ending a range!"
) ? void (0) : __assert_fail ("EndLabel && \"Forgot label after instruction ending a range!\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 1682, __extension__ __PRETTY_FUNCTION__))
;
1683
1684 if (EI->isDbgValue())
1685 LLVM_DEBUG(dbgs() << "DotDebugLoc: " << *Instr << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { dbgs() << "DotDebugLoc: " << *Instr
<< "\n"; } } while (false)
;
1686
1687 // If this history map entry has a debug value, add that to the list of
1688 // open ranges and check if its location is valid for a single value
1689 // location.
1690 if (EI->isDbgValue()) {
1691 // Do not add undef debug values, as they are redundant information in
1692 // the location list entries. An undef debug results in an empty location
1693 // description. If there are any non-undef fragments then padding pieces
1694 // with empty location descriptions will automatically be inserted, and if
1695 // all fragments are undef then the whole location list entry is
1696 // redundant.
1697 if (!Instr->isUndefDebugValue()) {
1698 auto Value = getDebugLocValue(Instr);
1699 OpenRanges.emplace_back(EI->getEndIndex(), Value);
1700
1701 // TODO: Add support for single value fragment locations.
1702 if (Instr->getDebugExpression()->isFragment())
1703 isSafeForSingleLocation = false;
1704
1705 if (!StartDebugMI)
1706 StartDebugMI = Instr;
1707 } else {
1708 isSafeForSingleLocation = false;
1709 }
1710 }
1711
1712 // Location list entries with empty location descriptions are redundant
1713 // information in DWARF, so do not emit those.
1714 if (OpenRanges.empty())
1715 continue;
1716
1717 // Omit entries with empty ranges as they do not have any effect in DWARF.
1718 if (StartLabel == EndLabel) {
1719 LLVM_DEBUG(dbgs() << "Omitting location list entry with empty range.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { dbgs() << "Omitting location list entry with empty range.\n"
; } } while (false)
;
1720 continue;
1721 }
1722
1723 SmallVector<DbgValueLoc, 4> Values;
1724 for (auto &R : OpenRanges)
1725 Values.push_back(R.second);
1726
1727 // With Basic block sections, it is posssible that the StartLabel and the
1728 // Instr are not in the same section. This happens when the StartLabel is
1729 // the function begin label and the dbg value appears in a basic block
1730 // that is not the entry. In this case, the range needs to be split to
1731 // span each individual section in the range from StartLabel to EndLabel.
1732 if (Asm->MF->hasBBSections() && StartLabel == Asm->getFunctionBegin() &&
1733 !Instr->getParent()->sameSection(&Asm->MF->front())) {
1734 const MCSymbol *BeginSectionLabel = StartLabel;
1735
1736 for (const MachineBasicBlock &MBB : *Asm->MF) {
1737 if (MBB.isBeginSection() && &MBB != &Asm->MF->front())
1738 BeginSectionLabel = MBB.getSymbol();
1739
1740 if (MBB.sameSection(Instr->getParent())) {
1741 DebugLoc.emplace_back(BeginSectionLabel, EndLabel, Values);
1742 break;
1743 }
1744 if (MBB.isEndSection())
1745 DebugLoc.emplace_back(BeginSectionLabel, MBB.getEndSymbol(), Values);
1746 }
1747 } else {
1748 DebugLoc.emplace_back(StartLabel, EndLabel, Values);
1749 }
1750
1751 // Attempt to coalesce the ranges of two otherwise identical
1752 // DebugLocEntries.
1753 auto CurEntry = DebugLoc.rbegin();
1754 LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { { dbgs() << CurEntry->getValues().
size() << " Values:\n"; for (auto &Value : CurEntry
->getValues()) Value.dump(); dbgs() << "-----\n"; };
} } while (false)
1755 dbgs() << CurEntry->getValues().size() << " Values:\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { { dbgs() << CurEntry->getValues().
size() << " Values:\n"; for (auto &Value : CurEntry
->getValues()) Value.dump(); dbgs() << "-----\n"; };
} } while (false)
1756 for (auto &Value : CurEntry->getValues())do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { { dbgs() << CurEntry->getValues().
size() << " Values:\n"; for (auto &Value : CurEntry
->getValues()) Value.dump(); dbgs() << "-----\n"; };
} } while (false)
1757 Value.dump();do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { { dbgs() << CurEntry->getValues().
size() << " Values:\n"; for (auto &Value : CurEntry
->getValues()) Value.dump(); dbgs() << "-----\n"; };
} } while (false)
1758 dbgs() << "-----\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { { dbgs() << CurEntry->getValues().
size() << " Values:\n"; for (auto &Value : CurEntry
->getValues()) Value.dump(); dbgs() << "-----\n"; };
} } while (false)
1759 })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { { dbgs() << CurEntry->getValues().
size() << " Values:\n"; for (auto &Value : CurEntry
->getValues()) Value.dump(); dbgs() << "-----\n"; };
} } while (false)
;
1760
1761 auto PrevEntry = std::next(CurEntry);
1762 if (PrevEntry != DebugLoc.rend() && PrevEntry->MergeRanges(*CurEntry))
1763 DebugLoc.pop_back();
1764 }
1765
1766 if (!isSafeForSingleLocation
2.1
'isSafeForSingleLocation' is true
||
1767 !validThroughout(LScopes, StartDebugMI, EndMI, getInstOrdering()))
3
Passing null pointer value via 2nd parameter 'DbgValue'
4
Calling 'validThroughout'
1768 return false;
1769
1770 if (DebugLoc.size() == 1)
1771 return true;
1772
1773 if (!Asm->MF->hasBBSections())
1774 return false;
1775
1776 // Check here to see if loclist can be merged into a single range. If not,
1777 // we must keep the split loclists per section. This does exactly what
1778 // MergeRanges does without sections. We don't actually merge the ranges
1779 // as the split ranges must be kept intact if this cannot be collapsed
1780 // into a single range.
1781 const MachineBasicBlock *RangeMBB = nullptr;
1782 if (DebugLoc[0].getBeginSym() == Asm->getFunctionBegin())
1783 RangeMBB = &Asm->MF->front();
1784 else
1785 RangeMBB = Entries.begin()->getInstr()->getParent();
1786 auto *CurEntry = DebugLoc.begin();
1787 auto *NextEntry = std::next(CurEntry);
1788 while (NextEntry != DebugLoc.end()) {
1789 // Get the last machine basic block of this section.
1790 while (!RangeMBB->isEndSection())
1791 RangeMBB = RangeMBB->getNextNode();
1792 if (!RangeMBB->getNextNode())
1793 return false;
1794 // CurEntry should end the current section and NextEntry should start
1795 // the next section and the Values must match for these two ranges to be
1796 // merged.
1797 if (CurEntry->getEndSym() != RangeMBB->getEndSymbol() ||
1798 NextEntry->getBeginSym() != RangeMBB->getNextNode()->getSymbol() ||
1799 CurEntry->getValues() != NextEntry->getValues())
1800 return false;
1801 RangeMBB = RangeMBB->getNextNode();
1802 CurEntry = NextEntry;
1803 NextEntry = std::next(CurEntry);
1804 }
1805 return true;
1806}
1807
1808DbgEntity *DwarfDebug::createConcreteEntity(DwarfCompileUnit &TheCU,
1809 LexicalScope &Scope,
1810 const DINode *Node,
1811 const DILocation *Location,
1812 const MCSymbol *Sym) {
1813 ensureAbstractEntityIsCreatedIfScoped(TheCU, Node, Scope.getScopeNode());
1814 if (isa<const DILocalVariable>(Node)) {
1815 ConcreteEntities.push_back(
1816 std::make_unique<DbgVariable>(cast<const DILocalVariable>(Node),
1817 Location));
1818 InfoHolder.addScopeVariable(&Scope,
1819 cast<DbgVariable>(ConcreteEntities.back().get()));
1820 } else if (isa<const DILabel>(Node)) {
1821 ConcreteEntities.push_back(
1822 std::make_unique<DbgLabel>(cast<const DILabel>(Node),
1823 Location, Sym));
1824 InfoHolder.addScopeLabel(&Scope,
1825 cast<DbgLabel>(ConcreteEntities.back().get()));
1826 }
1827 return ConcreteEntities.back().get();
1828}
1829
1830// Find variables for each lexical scope.
1831void DwarfDebug::collectEntityInfo(DwarfCompileUnit &TheCU,
1832 const DISubprogram *SP,
1833 DenseSet<InlinedEntity> &Processed) {
1834 // Grab the variable info that was squirreled away in the MMI side-table.
1835 collectVariableInfoFromMFTable(TheCU, Processed);
1836
1837 for (const auto &I : DbgValues) {
1838 InlinedEntity IV = I.first;
1839 if (Processed.count(IV))
1840 continue;
1841
1842 // Instruction ranges, specifying where IV is accessible.
1843 const auto &HistoryMapEntries = I.second;
1844
1845 // Try to find any non-empty variable location. Do not create a concrete
1846 // entity if there are no locations.
1847 if (!DbgValues.hasNonEmptyLocation(HistoryMapEntries))
1848 continue;
1849
1850 LexicalScope *Scope = nullptr;
1851 const DILocalVariable *LocalVar = cast<DILocalVariable>(IV.first);
1852 if (const DILocation *IA = IV.second)
1853 Scope = LScopes.findInlinedScope(LocalVar->getScope(), IA);
1854 else
1855 Scope = LScopes.findLexicalScope(LocalVar->getScope());
1856 // If variable scope is not found then skip this variable.
1857 if (!Scope)
1858 continue;
1859
1860 Processed.insert(IV);
1861 DbgVariable *RegVar = cast<DbgVariable>(createConcreteEntity(TheCU,
1862 *Scope, LocalVar, IV.second));
1863
1864 const MachineInstr *MInsn = HistoryMapEntries.front().getInstr();
1865 assert(MInsn->isDebugValue() && "History must begin with debug value")(static_cast <bool> (MInsn->isDebugValue() &&
"History must begin with debug value") ? void (0) : __assert_fail
("MInsn->isDebugValue() && \"History must begin with debug value\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 1865, __extension__ __PRETTY_FUNCTION__))
;
1866
1867 // Check if there is a single DBG_VALUE, valid throughout the var's scope.
1868 // If the history map contains a single debug value, there may be an
1869 // additional entry which clobbers the debug value.
1870 size_t HistSize = HistoryMapEntries.size();
1871 bool SingleValueWithClobber =
1872 HistSize == 2 && HistoryMapEntries[1].isClobber();
1873 if (HistSize == 1 || SingleValueWithClobber) {
1874 const auto *End =
1875 SingleValueWithClobber ? HistoryMapEntries[1].getInstr() : nullptr;
1876 if (validThroughout(LScopes, MInsn, End, getInstOrdering())) {
1877 RegVar->initializeDbgValue(MInsn);
1878 continue;
1879 }
1880 }
1881
1882 // Do not emit location lists if .debug_loc secton is disabled.
1883 if (!useLocSection())
1884 continue;
1885
1886 // Handle multiple DBG_VALUE instructions describing one variable.
1887 DebugLocStream::ListBuilder List(DebugLocs, TheCU, *Asm, *RegVar, *MInsn);
1888
1889 // Build the location list for this variable.
1890 SmallVector<DebugLocEntry, 8> Entries;
1891 bool isValidSingleLocation = buildLocationList(Entries, HistoryMapEntries);
1892
1893 // Check whether buildLocationList managed to merge all locations to one
1894 // that is valid throughout the variable's scope. If so, produce single
1895 // value location.
1896 if (isValidSingleLocation) {
1897 RegVar->initializeDbgValue(Entries[0].getValues()[0]);
1898 continue;
1899 }
1900
1901 // If the variable has a DIBasicType, extract it. Basic types cannot have
1902 // unique identifiers, so don't bother resolving the type with the
1903 // identifier map.
1904 const DIBasicType *BT = dyn_cast<DIBasicType>(
1905 static_cast<const Metadata *>(LocalVar->getType()));
1906
1907 // Finalize the entry by lowering it into a DWARF bytestream.
1908 for (auto &Entry : Entries)
1909 Entry.finalize(*Asm, List, BT, TheCU);
1910 }
1911
1912 // For each InlinedEntity collected from DBG_LABEL instructions, convert to
1913 // DWARF-related DbgLabel.
1914 for (const auto &I : DbgLabels) {
1915 InlinedEntity IL = I.first;
1916 const MachineInstr *MI = I.second;
1917 if (MI == nullptr)
1918 continue;
1919
1920 LexicalScope *Scope = nullptr;
1921 const DILabel *Label = cast<DILabel>(IL.first);
1922 // The scope could have an extra lexical block file.
1923 const DILocalScope *LocalScope =
1924 Label->getScope()->getNonLexicalBlockFileScope();
1925 // Get inlined DILocation if it is inlined label.
1926 if (const DILocation *IA = IL.second)
1927 Scope = LScopes.findInlinedScope(LocalScope, IA);
1928 else
1929 Scope = LScopes.findLexicalScope(LocalScope);
1930 // If label scope is not found then skip this label.
1931 if (!Scope)
1932 continue;
1933
1934 Processed.insert(IL);
1935 /// At this point, the temporary label is created.
1936 /// Save the temporary label to DbgLabel entity to get the
1937 /// actually address when generating Dwarf DIE.
1938 MCSymbol *Sym = getLabelBeforeInsn(MI);
1939 createConcreteEntity(TheCU, *Scope, Label, IL.second, Sym);
1940 }
1941
1942 // Collect info for variables/labels that were optimized out.
1943 for (const DINode *DN : SP->getRetainedNodes()) {
1944 if (!Processed.insert(InlinedEntity(DN, nullptr)).second)
1945 continue;
1946 LexicalScope *Scope = nullptr;
1947 if (auto *DV = dyn_cast<DILocalVariable>(DN)) {
1948 Scope = LScopes.findLexicalScope(DV->getScope());
1949 } else if (auto *DL = dyn_cast<DILabel>(DN)) {
1950 Scope = LScopes.findLexicalScope(DL->getScope());
1951 }
1952
1953 if (Scope)
1954 createConcreteEntity(TheCU, *Scope, DN, nullptr);
1955 }
1956}
1957
1958// Process beginning of an instruction.
1959void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1960 const MachineFunction &MF = *MI->getMF();
1961 const auto *SP = MF.getFunction().getSubprogram();
1962 bool NoDebug =
1963 !SP || SP->getUnit()->getEmissionKind() == DICompileUnit::NoDebug;
1964
1965 // Delay slot support check.
1966 auto delaySlotSupported = [](const MachineInstr &MI) {
1967 if (!MI.isBundledWithSucc())
1968 return false;
1969 auto Suc = std::next(MI.getIterator());
1970 (void)Suc;
1971 // Ensure that delay slot instruction is successor of the call instruction.
1972 // Ex. CALL_INSTRUCTION {
1973 // DELAY_SLOT_INSTRUCTION }
1974 assert(Suc->isBundledWithPred() &&(static_cast <bool> (Suc->isBundledWithPred() &&
"Call bundle instructions are out of order") ? void (0) : __assert_fail
("Suc->isBundledWithPred() && \"Call bundle instructions are out of order\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 1975, __extension__ __PRETTY_FUNCTION__))
1975 "Call bundle instructions are out of order")(static_cast <bool> (Suc->isBundledWithPred() &&
"Call bundle instructions are out of order") ? void (0) : __assert_fail
("Suc->isBundledWithPred() && \"Call bundle instructions are out of order\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 1975, __extension__ __PRETTY_FUNCTION__))
;
1976 return true;
1977 };
1978
1979 // When describing calls, we need a label for the call instruction.
1980 if (!NoDebug && SP->areAllCallsDescribed() &&
1981 MI->isCandidateForCallSiteEntry(MachineInstr::AnyInBundle) &&
1982 (!MI->hasDelaySlot() || delaySlotSupported(*MI))) {
1983 const TargetInstrInfo *TII = MF.getSubtarget().getInstrInfo();
1984 bool IsTail = TII->isTailCall(*MI);
1985 // For tail calls, we need the address of the branch instruction for
1986 // DW_AT_call_pc.
1987 if (IsTail)
1988 requestLabelBeforeInsn(MI);
1989 // For non-tail calls, we need the return address for the call for
1990 // DW_AT_call_return_pc. Under GDB tuning, this information is needed for
1991 // tail calls as well.
1992 requestLabelAfterInsn(MI);
1993 }
1994
1995 DebugHandlerBase::beginInstruction(MI);
1996 if (!CurMI)
1997 return;
1998
1999 if (NoDebug)
2000 return;
2001
2002 // Check if source location changes, but ignore DBG_VALUE and CFI locations.
2003 // If the instruction is part of the function frame setup code, do not emit
2004 // any line record, as there is no correspondence with any user code.
2005 if (MI->isMetaInstruction() || MI->getFlag(MachineInstr::FrameSetup))
2006 return;
2007 const DebugLoc &DL = MI->getDebugLoc();
2008 // When we emit a line-0 record, we don't update PrevInstLoc; so look at
2009 // the last line number actually emitted, to see if it was line 0.
2010 unsigned LastAsmLine =
2011 Asm->OutStreamer->getContext().getCurrentDwarfLoc().getLine();
2012
2013 if (DL == PrevInstLoc) {
2014 // If we have an ongoing unspecified location, nothing to do here.
2015 if (!DL)
2016 return;
2017 // We have an explicit location, same as the previous location.
2018 // But we might be coming back to it after a line 0 record.
2019 if (LastAsmLine == 0 && DL.getLine() != 0) {
2020 // Reinstate the source location but not marked as a statement.
2021 const MDNode *Scope = DL.getScope();
2022 recordSourceLine(DL.getLine(), DL.getCol(), Scope, /*Flags=*/0);
2023 }
2024 return;
2025 }
2026
2027 if (!DL) {
2028 // We have an unspecified location, which might want to be line 0.
2029 // If we have already emitted a line-0 record, don't repeat it.
2030 if (LastAsmLine == 0)
2031 return;
2032 // If user said Don't Do That, don't do that.
2033 if (UnknownLocations == Disable)
2034 return;
2035 // See if we have a reason to emit a line-0 record now.
2036 // Reasons to emit a line-0 record include:
2037 // - User asked for it (UnknownLocations).
2038 // - Instruction has a label, so it's referenced from somewhere else,
2039 // possibly debug information; we want it to have a source location.
2040 // - Instruction is at the top of a block; we don't want to inherit the
2041 // location from the physically previous (maybe unrelated) block.
2042 if (UnknownLocations == Enable || PrevLabel ||
2043 (PrevInstBB && PrevInstBB != MI->getParent())) {
2044 // Preserve the file and column numbers, if we can, to save space in
2045 // the encoded line table.
2046 // Do not update PrevInstLoc, it remembers the last non-0 line.
2047 const MDNode *Scope = nullptr;
2048 unsigned Column = 0;
2049 if (PrevInstLoc) {
2050 Scope = PrevInstLoc.getScope();
2051 Column = PrevInstLoc.getCol();
2052 }
2053 recordSourceLine(/*Line=*/0, Column, Scope, /*Flags=*/0);
2054 }
2055 return;
2056 }
2057
2058 // We have an explicit location, different from the previous location.
2059 // Don't repeat a line-0 record, but otherwise emit the new location.
2060 // (The new location might be an explicit line 0, which we do emit.)
2061 if (DL.getLine() == 0 && LastAsmLine == 0)
2062 return;
2063 unsigned Flags = 0;
2064 if (DL == PrologEndLoc) {
2065 Flags |= DWARF2_FLAG_PROLOGUE_END(1 << 2) | DWARF2_FLAG_IS_STMT(1 << 0);
2066 PrologEndLoc = DebugLoc();
2067 }
2068 // If the line changed, we call that a new statement; unless we went to
2069 // line 0 and came back, in which case it is not a new statement.
2070 unsigned OldLine = PrevInstLoc ? PrevInstLoc.getLine() : LastAsmLine;
2071 if (DL.getLine() && DL.getLine() != OldLine)
2072 Flags |= DWARF2_FLAG_IS_STMT(1 << 0);
2073
2074 const MDNode *Scope = DL.getScope();
2075 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
2076
2077 // If we're not at line 0, remember this location.
2078 if (DL.getLine())
2079 PrevInstLoc = DL;
2080}
2081
2082static DebugLoc findPrologueEndLoc(const MachineFunction *MF) {
2083 // First known non-DBG_VALUE and non-frame setup location marks
2084 // the beginning of the function body.
2085 DebugLoc LineZeroLoc;
2086 for (const auto &MBB : *MF) {
2087 for (const auto &MI : MBB) {
2088 if (!MI.isMetaInstruction() && !MI.getFlag(MachineInstr::FrameSetup) &&
2089 MI.getDebugLoc()) {
2090 // Scan forward to try to find a non-zero line number. The prologue_end
2091 // marks the first breakpoint in the function after the frame setup, and
2092 // a compiler-generated line 0 location is not a meaningful breakpoint.
2093 // If none is found, return the first location after the frame setup.
2094 if (MI.getDebugLoc().getLine())
2095 return MI.getDebugLoc();
2096 LineZeroLoc = MI.getDebugLoc();
2097 }
2098 }
2099 }
2100 return LineZeroLoc;
2101}
2102
2103/// Register a source line with debug info. Returns the unique label that was
2104/// emitted and which provides correspondence to the source line list.
2105static void recordSourceLine(AsmPrinter &Asm, unsigned Line, unsigned Col,
2106 const MDNode *S, unsigned Flags, unsigned CUID,
2107 uint16_t DwarfVersion,
2108 ArrayRef<std::unique_ptr<DwarfCompileUnit>> DCUs) {
2109 StringRef Fn;
2110 unsigned FileNo = 1;
2111 unsigned Discriminator = 0;
2112 if (auto *Scope = cast_or_null<DIScope>(S)) {
2113 Fn = Scope->getFilename();
2114 if (Line != 0 && DwarfVersion >= 4)
2115 if (auto *LBF = dyn_cast<DILexicalBlockFile>(Scope))
2116 Discriminator = LBF->getDiscriminator();
2117
2118 FileNo = static_cast<DwarfCompileUnit &>(*DCUs[CUID])
2119 .getOrCreateSourceID(Scope->getFile());
2120 }
2121 Asm.OutStreamer->emitDwarfLocDirective(FileNo, Line, Col, Flags, 0,
2122 Discriminator, Fn);
2123}
2124
2125DebugLoc DwarfDebug::emitInitialLocDirective(const MachineFunction &MF,
2126 unsigned CUID) {
2127 // Get beginning of function.
2128 if (DebugLoc PrologEndLoc = findPrologueEndLoc(&MF)) {
2129 // Ensure the compile unit is created if the function is called before
2130 // beginFunction().
2131 (void)getOrCreateDwarfCompileUnit(
2132 MF.getFunction().getSubprogram()->getUnit());
2133 // We'd like to list the prologue as "not statements" but GDB behaves
2134 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
2135 const DISubprogram *SP = PrologEndLoc->getInlinedAtScope()->getSubprogram();
2136 ::recordSourceLine(*Asm, SP->getScopeLine(), 0, SP, DWARF2_FLAG_IS_STMT(1 << 0),
2137 CUID, getDwarfVersion(), getUnits());
2138 return PrologEndLoc;
2139 }
2140 return DebugLoc();
2141}
2142
2143// Gather pre-function debug information. Assumes being called immediately
2144// after the function entry point has been emitted.
2145void DwarfDebug::beginFunctionImpl(const MachineFunction *MF) {
2146 CurFn = MF;
2147
2148 auto *SP = MF->getFunction().getSubprogram();
2149 assert(LScopes.empty() || SP == LScopes.getCurrentFunctionScope()->getScopeNode())(static_cast <bool> (LScopes.empty() || SP == LScopes.getCurrentFunctionScope
()->getScopeNode()) ? void (0) : __assert_fail ("LScopes.empty() || SP == LScopes.getCurrentFunctionScope()->getScopeNode()"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2149, __extension__ __PRETTY_FUNCTION__))
;
2150 if (SP->getUnit()->getEmissionKind() == DICompileUnit::NoDebug)
2151 return;
2152
2153 DwarfCompileUnit &CU = getOrCreateDwarfCompileUnit(SP->getUnit());
2154
2155 Asm->OutStreamer->getContext().setDwarfCompileUnitID(
2156 getDwarfCompileUnitIDForLineTable(CU));
2157
2158 // Record beginning of function.
2159 PrologEndLoc = emitInitialLocDirective(
2160 *MF, Asm->OutStreamer->getContext().getDwarfCompileUnitID());
2161}
2162
2163unsigned
2164DwarfDebug::getDwarfCompileUnitIDForLineTable(const DwarfCompileUnit &CU) {
2165 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
2166 // belongs to so that we add to the correct per-cu line table in the
2167 // non-asm case.
2168 if (Asm->OutStreamer->hasRawTextSupport())
2169 // Use a single line table if we are generating assembly.
2170 return 0;
2171 else
2172 return CU.getUniqueID();
2173}
2174
2175void DwarfDebug::skippedNonDebugFunction() {
2176 // If we don't have a subprogram for this function then there will be a hole
2177 // in the range information. Keep note of this by setting the previously used
2178 // section to nullptr.
2179 PrevCU = nullptr;
2180 CurFn = nullptr;
2181}
2182
2183// Gather and emit post-function debug information.
2184void DwarfDebug::endFunctionImpl(const MachineFunction *MF) {
2185 const DISubprogram *SP = MF->getFunction().getSubprogram();
2186
2187 assert(CurFn == MF &&(static_cast <bool> (CurFn == MF && "endFunction should be called with the same function as beginFunction"
) ? void (0) : __assert_fail ("CurFn == MF && \"endFunction should be called with the same function as beginFunction\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2188, __extension__ __PRETTY_FUNCTION__))
2188 "endFunction should be called with the same function as beginFunction")(static_cast <bool> (CurFn == MF && "endFunction should be called with the same function as beginFunction"
) ? void (0) : __assert_fail ("CurFn == MF && \"endFunction should be called with the same function as beginFunction\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2188, __extension__ __PRETTY_FUNCTION__))
;
2189
2190 // Set DwarfDwarfCompileUnitID in MCContext to default value.
2191 Asm->OutStreamer->getContext().setDwarfCompileUnitID(0);
2192
2193 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
2194 assert(!FnScope || SP == FnScope->getScopeNode())(static_cast <bool> (!FnScope || SP == FnScope->getScopeNode
()) ? void (0) : __assert_fail ("!FnScope || SP == FnScope->getScopeNode()"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2194, __extension__ __PRETTY_FUNCTION__))
;
2195 DwarfCompileUnit &TheCU = *CUMap.lookup(SP->getUnit());
2196 if (TheCU.getCUNode()->isDebugDirectivesOnly()) {
2197 PrevLabel = nullptr;
2198 CurFn = nullptr;
2199 return;
2200 }
2201
2202 DenseSet<InlinedEntity> Processed;
2203 collectEntityInfo(TheCU, SP, Processed);
2204
2205 // Add the range of this function to the list of ranges for the CU.
2206 // With basic block sections, add ranges for all basic block sections.
2207 for (const auto &R : Asm->MBBSectionRanges)
2208 TheCU.addRange({R.second.BeginLabel, R.second.EndLabel});
2209
2210 // Under -gmlt, skip building the subprogram if there are no inlined
2211 // subroutines inside it. But with -fdebug-info-for-profiling, the subprogram
2212 // is still needed as we need its source location.
2213 if (!TheCU.getCUNode()->getDebugInfoForProfiling() &&
2214 TheCU.getCUNode()->getEmissionKind() == DICompileUnit::LineTablesOnly &&
2215 LScopes.getAbstractScopesList().empty() && !IsDarwin) {
2216 assert(InfoHolder.getScopeVariables().empty())(static_cast <bool> (InfoHolder.getScopeVariables().empty
()) ? void (0) : __assert_fail ("InfoHolder.getScopeVariables().empty()"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2216, __extension__ __PRETTY_FUNCTION__))
;
2217 PrevLabel = nullptr;
2218 CurFn = nullptr;
2219 return;
2220 }
2221
2222#ifndef NDEBUG
2223 size_t NumAbstractScopes = LScopes.getAbstractScopesList().size();
2224#endif
2225 // Construct abstract scopes.
2226 for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
2227 auto *SP = cast<DISubprogram>(AScope->getScopeNode());
2228 for (const DINode *DN : SP->getRetainedNodes()) {
2229 if (!Processed.insert(InlinedEntity(DN, nullptr)).second)
2230 continue;
2231
2232 const MDNode *Scope = nullptr;
2233 if (auto *DV = dyn_cast<DILocalVariable>(DN))
2234 Scope = DV->getScope();
2235 else if (auto *DL = dyn_cast<DILabel>(DN))
2236 Scope = DL->getScope();
2237 else
2238 llvm_unreachable("Unexpected DI type!")::llvm::llvm_unreachable_internal("Unexpected DI type!", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2238)
;
2239
2240 // Collect info for variables/labels that were optimized out.
2241 ensureAbstractEntityIsCreated(TheCU, DN, Scope);
2242 assert(LScopes.getAbstractScopesList().size() == NumAbstractScopes(static_cast <bool> (LScopes.getAbstractScopesList().size
() == NumAbstractScopes && "ensureAbstractEntityIsCreated inserted abstract scopes"
) ? void (0) : __assert_fail ("LScopes.getAbstractScopesList().size() == NumAbstractScopes && \"ensureAbstractEntityIsCreated inserted abstract scopes\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2243, __extension__ __PRETTY_FUNCTION__))
2243 && "ensureAbstractEntityIsCreated inserted abstract scopes")(static_cast <bool> (LScopes.getAbstractScopesList().size
() == NumAbstractScopes && "ensureAbstractEntityIsCreated inserted abstract scopes"
) ? void (0) : __assert_fail ("LScopes.getAbstractScopesList().size() == NumAbstractScopes && \"ensureAbstractEntityIsCreated inserted abstract scopes\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2243, __extension__ __PRETTY_FUNCTION__))
;
2244 }
2245 constructAbstractSubprogramScopeDIE(TheCU, AScope);
2246 }
2247
2248 ProcessedSPNodes.insert(SP);
2249 DIE &ScopeDIE = TheCU.constructSubprogramScopeDIE(SP, FnScope);
2250 if (auto *SkelCU = TheCU.getSkeleton())
2251 if (!LScopes.getAbstractScopesList().empty() &&
2252 TheCU.getCUNode()->getSplitDebugInlining())
2253 SkelCU->constructSubprogramScopeDIE(SP, FnScope);
2254
2255 // Construct call site entries.
2256 constructCallSiteEntryDIEs(*SP, TheCU, ScopeDIE, *MF);
2257
2258 // Clear debug info
2259 // Ownership of DbgVariables is a bit subtle - ScopeVariables owns all the
2260 // DbgVariables except those that are also in AbstractVariables (since they
2261 // can be used cross-function)
2262 InfoHolder.getScopeVariables().clear();
2263 InfoHolder.getScopeLabels().clear();
2264 PrevLabel = nullptr;
2265 CurFn = nullptr;
2266}
2267
2268// Register a source line with debug info. Returns the unique label that was
2269// emitted and which provides correspondence to the source line list.
2270void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
2271 unsigned Flags) {
2272 ::recordSourceLine(*Asm, Line, Col, S, Flags,
2273 Asm->OutStreamer->getContext().getDwarfCompileUnitID(),
2274 getDwarfVersion(), getUnits());
2275}
2276
2277//===----------------------------------------------------------------------===//
2278// Emit Methods
2279//===----------------------------------------------------------------------===//
2280
2281// Emit the debug info section.
2282void DwarfDebug::emitDebugInfo() {
2283 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2284 Holder.emitUnits(/* UseOffsets */ false);
2285}
2286
2287// Emit the abbreviation section.
2288void DwarfDebug::emitAbbreviations() {
2289 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2290
2291 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2292}
2293
2294void DwarfDebug::emitStringOffsetsTableHeader() {
2295 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2296 Holder.getStringPool().emitStringOffsetsTableHeader(
2297 *Asm, Asm->getObjFileLowering().getDwarfStrOffSection(),
2298 Holder.getStringOffsetsStartSym());
2299}
2300
2301template <typename AccelTableT>
2302void DwarfDebug::emitAccel(AccelTableT &Accel, MCSection *Section,
2303 StringRef TableName) {
2304 Asm->OutStreamer->SwitchSection(Section);
2305
2306 // Emit the full data.
2307 emitAppleAccelTable(Asm, Accel, TableName, Section->getBeginSymbol());
2308}
2309
2310void DwarfDebug::emitAccelDebugNames() {
2311 // Don't emit anything if we have no compilation units to index.
2312 if (getUnits().empty())
2313 return;
2314
2315 emitDWARF5AccelTable(Asm, AccelDebugNames, *this, getUnits());
2316}
2317
2318// Emit visible names into a hashed accelerator table section.
2319void DwarfDebug::emitAccelNames() {
2320 emitAccel(AccelNames, Asm->getObjFileLowering().getDwarfAccelNamesSection(),
2321 "Names");
2322}
2323
2324// Emit objective C classes and categories into a hashed accelerator table
2325// section.
2326void DwarfDebug::emitAccelObjC() {
2327 emitAccel(AccelObjC, Asm->getObjFileLowering().getDwarfAccelObjCSection(),
2328 "ObjC");
2329}
2330
2331// Emit namespace dies into a hashed accelerator table.
2332void DwarfDebug::emitAccelNamespaces() {
2333 emitAccel(AccelNamespace,
2334 Asm->getObjFileLowering().getDwarfAccelNamespaceSection(),
2335 "namespac");
2336}
2337
2338// Emit type dies into a hashed accelerator table.
2339void DwarfDebug::emitAccelTypes() {
2340 emitAccel(AccelTypes, Asm->getObjFileLowering().getDwarfAccelTypesSection(),
2341 "types");
2342}
2343
2344// Public name handling.
2345// The format for the various pubnames:
2346//
2347// dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2348// for the DIE that is named.
2349//
2350// gnu pubnames - offset/index value/name tuples where the offset is the offset
2351// into the CU and the index value is computed according to the type of value
2352// for the DIE that is named.
2353//
2354// For type units the offset is the offset of the skeleton DIE. For split dwarf
2355// it's the offset within the debug_info/debug_types dwo section, however, the
2356// reference in the pubname header doesn't change.
2357
2358/// computeIndexValue - Compute the gdb index value for the DIE and CU.
2359static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
2360 const DIE *Die) {
2361 // Entities that ended up only in a Type Unit reference the CU instead (since
2362 // the pub entry has offsets within the CU there's no real offset that can be
2363 // provided anyway). As it happens all such entities (namespaces and types,
2364 // types only in C++ at that) are rendered as TYPE+EXTERNAL. If this turns out
2365 // not to be true it would be necessary to persist this information from the
2366 // point at which the entry is added to the index data structure - since by
2367 // the time the index is built from that, the original type/namespace DIE in a
2368 // type unit has already been destroyed so it can't be queried for properties
2369 // like tag, etc.
2370 if (Die->getTag() == dwarf::DW_TAG_compile_unit)
2371 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE,
2372 dwarf::GIEL_EXTERNAL);
2373 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2374
2375 // We could have a specification DIE that has our most of our knowledge,
2376 // look for that now.
2377 if (DIEValue SpecVal = Die->findAttribute(dwarf::DW_AT_specification)) {
2378 DIE &SpecDIE = SpecVal.getDIEEntry().getEntry();
2379 if (SpecDIE.findAttribute(dwarf::DW_AT_external))
2380 Linkage = dwarf::GIEL_EXTERNAL;
2381 } else if (Die->findAttribute(dwarf::DW_AT_external))
2382 Linkage = dwarf::GIEL_EXTERNAL;
2383
2384 switch (Die->getTag()) {
2385 case dwarf::DW_TAG_class_type:
2386 case dwarf::DW_TAG_structure_type:
2387 case dwarf::DW_TAG_union_type:
2388 case dwarf::DW_TAG_enumeration_type:
2389 return dwarf::PubIndexEntryDescriptor(
2390 dwarf::GIEK_TYPE,
2391 dwarf::isCPlusPlus((dwarf::SourceLanguage)CU->getLanguage())
2392 ? dwarf::GIEL_EXTERNAL
2393 : dwarf::GIEL_STATIC);
2394 case dwarf::DW_TAG_typedef:
2395 case dwarf::DW_TAG_base_type:
2396 case dwarf::DW_TAG_subrange_type:
2397 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2398 case dwarf::DW_TAG_namespace:
2399 return dwarf::GIEK_TYPE;
2400 case dwarf::DW_TAG_subprogram:
2401 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2402 case dwarf::DW_TAG_variable:
2403 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2404 case dwarf::DW_TAG_enumerator:
2405 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2406 dwarf::GIEL_STATIC);
2407 default:
2408 return dwarf::GIEK_NONE;
2409 }
2410}
2411
2412/// emitDebugPubSections - Emit visible names and types into debug pubnames and
2413/// pubtypes sections.
2414void DwarfDebug::emitDebugPubSections() {
2415 for (const auto &NU : CUMap) {
2416 DwarfCompileUnit *TheU = NU.second;
2417 if (!TheU->hasDwarfPubSections())
2418 continue;
2419
2420 bool GnuStyle = TheU->getCUNode()->getNameTableKind() ==
2421 DICompileUnit::DebugNameTableKind::GNU;
2422
2423 Asm->OutStreamer->SwitchSection(
2424 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2425 : Asm->getObjFileLowering().getDwarfPubNamesSection());
2426 emitDebugPubSection(GnuStyle, "Names", TheU, TheU->getGlobalNames());
2427
2428 Asm->OutStreamer->SwitchSection(
2429 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2430 : Asm->getObjFileLowering().getDwarfPubTypesSection());
2431 emitDebugPubSection(GnuStyle, "Types", TheU, TheU->getGlobalTypes());
2432 }
2433}
2434
2435void DwarfDebug::emitSectionReference(const DwarfCompileUnit &CU) {
2436 if (useSectionsAsReferences())
2437 Asm->emitDwarfOffset(CU.getSection()->getBeginSymbol(),
2438 CU.getDebugSectionOffset());
2439 else
2440 Asm->emitDwarfSymbolReference(CU.getLabelBegin());
2441}
2442
2443void DwarfDebug::emitDebugPubSection(bool GnuStyle, StringRef Name,
2444 DwarfCompileUnit *TheU,
2445 const StringMap<const DIE *> &Globals) {
2446 if (auto *Skeleton = TheU->getSkeleton())
2447 TheU = Skeleton;
2448
2449 // Emit the header.
2450 MCSymbol *EndLabel = Asm->emitDwarfUnitLength(
2451 "pub" + Name, "Length of Public " + Name + " Info");
2452
2453 Asm->OutStreamer->AddComment("DWARF Version");
2454 Asm->emitInt16(dwarf::DW_PUBNAMES_VERSION);
2455
2456 Asm->OutStreamer->AddComment("Offset of Compilation Unit Info");
2457 emitSectionReference(*TheU);
2458
2459 Asm->OutStreamer->AddComment("Compilation Unit Length");
2460 Asm->emitDwarfLengthOrOffset(TheU->getLength());
2461
2462 // Emit the pubnames for this compilation unit.
2463 for (const auto &GI : Globals) {
2464 const char *Name = GI.getKeyData();
2465 const DIE *Entity = GI.second;
2466
2467 Asm->OutStreamer->AddComment("DIE offset");
2468 Asm->emitDwarfLengthOrOffset(Entity->getOffset());
2469
2470 if (GnuStyle) {
2471 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2472 Asm->OutStreamer->AddComment(
2473 Twine("Attributes: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) +
2474 ", " + dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2475 Asm->emitInt8(Desc.toBits());
2476 }
2477
2478 Asm->OutStreamer->AddComment("External Name");
2479 Asm->OutStreamer->emitBytes(StringRef(Name, GI.getKeyLength() + 1));
2480 }
2481
2482 Asm->OutStreamer->AddComment("End Mark");
2483 Asm->emitDwarfLengthOrOffset(0);
2484 Asm->OutStreamer->emitLabel(EndLabel);
2485}
2486
2487/// Emit null-terminated strings into a debug str section.
2488void DwarfDebug::emitDebugStr() {
2489 MCSection *StringOffsetsSection = nullptr;
2490 if (useSegmentedStringOffsetsTable()) {
2491 emitStringOffsetsTableHeader();
2492 StringOffsetsSection = Asm->getObjFileLowering().getDwarfStrOffSection();
2493 }
2494 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2495 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection(),
2496 StringOffsetsSection, /* UseRelativeOffsets = */ true);
2497}
2498
2499void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
2500 const DebugLocStream::Entry &Entry,
2501 const DwarfCompileUnit *CU) {
2502 auto &&Comments = DebugLocs.getComments(Entry);
2503 auto Comment = Comments.begin();
2504 auto End = Comments.end();
2505
2506 // The expressions are inserted into a byte stream rather early (see
2507 // DwarfExpression::addExpression) so for those ops (e.g. DW_OP_convert) that
2508 // need to reference a base_type DIE the offset of that DIE is not yet known.
2509 // To deal with this we instead insert a placeholder early and then extract
2510 // it here and replace it with the real reference.
2511 unsigned PtrSize = Asm->MAI->getCodePointerSize();
2512 DWARFDataExtractor Data(StringRef(DebugLocs.getBytes(Entry).data(),
2513 DebugLocs.getBytes(Entry).size()),
2514 Asm->getDataLayout().isLittleEndian(), PtrSize);
2515 DWARFExpression Expr(Data, PtrSize, Asm->OutContext.getDwarfFormat());
2516
2517 using Encoding = DWARFExpression::Operation::Encoding;
2518 uint64_t Offset = 0;
2519 for (auto &Op : Expr) {
2520 assert(Op.getCode() != dwarf::DW_OP_const_type &&(static_cast <bool> (Op.getCode() != dwarf::DW_OP_const_type
&& "3 operand ops not yet supported") ? void (0) : __assert_fail
("Op.getCode() != dwarf::DW_OP_const_type && \"3 operand ops not yet supported\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2521, __extension__ __PRETTY_FUNCTION__))
2521 "3 operand ops not yet supported")(static_cast <bool> (Op.getCode() != dwarf::DW_OP_const_type
&& "3 operand ops not yet supported") ? void (0) : __assert_fail
("Op.getCode() != dwarf::DW_OP_const_type && \"3 operand ops not yet supported\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2521, __extension__ __PRETTY_FUNCTION__))
;
2522 Streamer.emitInt8(Op.getCode(), Comment != End ? *(Comment++) : "");
2523 Offset++;
2524 for (unsigned I = 0; I < 2; ++I) {
2525 if (Op.getDescription().Op[I] == Encoding::SizeNA)
2526 continue;
2527 if (Op.getDescription().Op[I] == Encoding::BaseTypeRef) {
2528 uint64_t Offset =
2529 CU->ExprRefedBaseTypes[Op.getRawOperand(I)].Die->getOffset();
2530 assert(Offset < (1ULL << (ULEB128PadSize * 7)) && "Offset wont fit")(static_cast <bool> (Offset < (1ULL << (ULEB128PadSize
* 7)) && "Offset wont fit") ? void (0) : __assert_fail
("Offset < (1ULL << (ULEB128PadSize * 7)) && \"Offset wont fit\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2530, __extension__ __PRETTY_FUNCTION__))
;
2531 Streamer.emitULEB128(Offset, "", ULEB128PadSize);
2532 // Make sure comments stay aligned.
2533 for (unsigned J = 0; J < ULEB128PadSize; ++J)
2534 if (Comment != End)
2535 Comment++;
2536 } else {
2537 for (uint64_t J = Offset; J < Op.getOperandEndOffset(I); ++J)
2538 Streamer.emitInt8(Data.getData()[J], Comment != End ? *(Comment++) : "");
2539 }
2540 Offset = Op.getOperandEndOffset(I);
2541 }
2542 assert(Offset == Op.getEndOffset())(static_cast <bool> (Offset == Op.getEndOffset()) ? void
(0) : __assert_fail ("Offset == Op.getEndOffset()", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2542, __extension__ __PRETTY_FUNCTION__))
;
2543 }
2544}
2545
2546void DwarfDebug::emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
2547 const DbgValueLoc &Value,
2548 DwarfExpression &DwarfExpr) {
2549 auto *DIExpr = Value.getExpression();
2550 DIExpressionCursor ExprCursor(DIExpr);
2551 DwarfExpr.addFragmentOffset(DIExpr);
2552
2553 // If the DIExpr is is an Entry Value, we want to follow the same code path
2554 // regardless of whether the DBG_VALUE is variadic or not.
2555 if (DIExpr && DIExpr->isEntryValue()) {
2556 // Entry values can only be a single register with no additional DIExpr,
2557 // so just add it directly.
2558 assert(Value.getLocEntries().size() == 1)(static_cast <bool> (Value.getLocEntries().size() == 1)
? void (0) : __assert_fail ("Value.getLocEntries().size() == 1"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2558, __extension__ __PRETTY_FUNCTION__))
;
2559 assert(Value.getLocEntries()[0].isLocation())(static_cast <bool> (Value.getLocEntries()[0].isLocation
()) ? void (0) : __assert_fail ("Value.getLocEntries()[0].isLocation()"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2559, __extension__ __PRETTY_FUNCTION__))
;
2560 MachineLocation Location = Value.getLocEntries()[0].getLoc();
2561 DwarfExpr.setLocation(Location, DIExpr);
2562
2563 DwarfExpr.beginEntryValueExpression(ExprCursor);
2564
2565 const TargetRegisterInfo &TRI = *AP.MF->getSubtarget().getRegisterInfo();
2566 if (!DwarfExpr.addMachineRegExpression(TRI, ExprCursor, Location.getReg()))
2567 return;
2568 return DwarfExpr.addExpression(std::move(ExprCursor));
2569 }
2570
2571 // Regular entry.
2572 auto EmitValueLocEntry = [&DwarfExpr, &BT,
2573 &AP](const DbgValueLocEntry &Entry,
2574 DIExpressionCursor &Cursor) -> bool {
2575 if (Entry.isInt()) {
2576 if (BT && (BT->getEncoding() == dwarf::DW_ATE_signed ||
2577 BT->getEncoding() == dwarf::DW_ATE_signed_char))
2578 DwarfExpr.addSignedConstant(Entry.getInt());
2579 else
2580 DwarfExpr.addUnsignedConstant(Entry.getInt());
2581 } else if (Entry.isLocation()) {
2582 MachineLocation Location = Entry.getLoc();
2583 if (Location.isIndirect())
2584 DwarfExpr.setMemoryLocationKind();
2585
2586 const TargetRegisterInfo &TRI = *AP.MF->getSubtarget().getRegisterInfo();
2587 if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
2588 return false;
2589 } else if (Entry.isTargetIndexLocation()) {
2590 TargetIndexLocation Loc = Entry.getTargetIndexLocation();
2591 // TODO TargetIndexLocation is a target-independent. Currently only the
2592 // WebAssembly-specific encoding is supported.
2593 assert(AP.TM.getTargetTriple().isWasm())(static_cast <bool> (AP.TM.getTargetTriple().isWasm()) ?
void (0) : __assert_fail ("AP.TM.getTargetTriple().isWasm()"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2593, __extension__ __PRETTY_FUNCTION__))
;
2594 DwarfExpr.addWasmLocation(Loc.Index, static_cast<uint64_t>(Loc.Offset));
2595 } else if (Entry.isConstantFP()) {
2596 if (AP.getDwarfVersion() >= 4 && !AP.getDwarfDebug()->tuneForSCE() &&
2597 !Cursor) {
2598 DwarfExpr.addConstantFP(Entry.getConstantFP()->getValueAPF(), AP);
2599 } else if (Entry.getConstantFP()
2600 ->getValueAPF()
2601 .bitcastToAPInt()
2602 .getBitWidth() <= 64 /*bits*/) {
2603 DwarfExpr.addUnsignedConstant(
2604 Entry.getConstantFP()->getValueAPF().bitcastToAPInt());
2605 } else {
2606 LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { dbgs() << "Skipped DwarfExpression creation for ConstantFP of size"
<< Entry.getConstantFP() ->getValueAPF() .bitcastToAPInt
() .getBitWidth() << " bits\n"; } } while (false)
2607 dbgs() << "Skipped DwarfExpression creation for ConstantFP of size"do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { dbgs() << "Skipped DwarfExpression creation for ConstantFP of size"
<< Entry.getConstantFP() ->getValueAPF() .bitcastToAPInt
() .getBitWidth() << " bits\n"; } } while (false)
2608 << Entry.getConstantFP()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { dbgs() << "Skipped DwarfExpression creation for ConstantFP of size"
<< Entry.getConstantFP() ->getValueAPF() .bitcastToAPInt
() .getBitWidth() << " bits\n"; } } while (false)
2609 ->getValueAPF()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { dbgs() << "Skipped DwarfExpression creation for ConstantFP of size"
<< Entry.getConstantFP() ->getValueAPF() .bitcastToAPInt
() .getBitWidth() << " bits\n"; } } while (false)
2610 .bitcastToAPInt()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { dbgs() << "Skipped DwarfExpression creation for ConstantFP of size"
<< Entry.getConstantFP() ->getValueAPF() .bitcastToAPInt
() .getBitWidth() << " bits\n"; } } while (false)
2611 .getBitWidth()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { dbgs() << "Skipped DwarfExpression creation for ConstantFP of size"
<< Entry.getConstantFP() ->getValueAPF() .bitcastToAPInt
() .getBitWidth() << " bits\n"; } } while (false)
2612 << " bits\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dwarfdebug")) { dbgs() << "Skipped DwarfExpression creation for ConstantFP of size"
<< Entry.getConstantFP() ->getValueAPF() .bitcastToAPInt
() .getBitWidth() << " bits\n"; } } while (false)
;
2613 return false;
2614 }
2615 }
2616 return true;
2617 };
2618
2619 if (!Value.isVariadic()) {
2620 if (!EmitValueLocEntry(Value.getLocEntries()[0], ExprCursor))
2621 return;
2622 DwarfExpr.addExpression(std::move(ExprCursor));
2623 return;
2624 }
2625
2626 // If any of the location entries are registers with the value 0, then the
2627 // location is undefined.
2628 if (any_of(Value.getLocEntries(), [](const DbgValueLocEntry &Entry) {
2629 return Entry.isLocation() && !Entry.getLoc().getReg();
2630 }))
2631 return;
2632
2633 DwarfExpr.addExpression(
2634 std::move(ExprCursor),
2635 [EmitValueLocEntry, &Value](unsigned Idx,
2636 DIExpressionCursor &Cursor) -> bool {
2637 return EmitValueLocEntry(Value.getLocEntries()[Idx], Cursor);
2638 });
2639}
2640
2641void DebugLocEntry::finalize(const AsmPrinter &AP,
2642 DebugLocStream::ListBuilder &List,
2643 const DIBasicType *BT,
2644 DwarfCompileUnit &TheCU) {
2645 assert(!Values.empty() &&(static_cast <bool> (!Values.empty() && "location list entries without values are redundant"
) ? void (0) : __assert_fail ("!Values.empty() && \"location list entries without values are redundant\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2646, __extension__ __PRETTY_FUNCTION__))
2646 "location list entries without values are redundant")(static_cast <bool> (!Values.empty() && "location list entries without values are redundant"
) ? void (0) : __assert_fail ("!Values.empty() && \"location list entries without values are redundant\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2646, __extension__ __PRETTY_FUNCTION__))
;
2647 assert(Begin != End && "unexpected location list entry with empty range")(static_cast <bool> (Begin != End && "unexpected location list entry with empty range"
) ? void (0) : __assert_fail ("Begin != End && \"unexpected location list entry with empty range\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2647, __extension__ __PRETTY_FUNCTION__))
;
2648 DebugLocStream::EntryBuilder Entry(List, Begin, End);
2649 BufferByteStreamer Streamer = Entry.getStreamer();
2650 DebugLocDwarfExpression DwarfExpr(AP.getDwarfVersion(), Streamer, TheCU);
2651 const DbgValueLoc &Value = Values[0];
2652 if (Value.isFragment()) {
2653 // Emit all fragments that belong to the same variable and range.
2654 assert(llvm::all_of(Values, [](DbgValueLoc P) {(static_cast <bool> (llvm::all_of(Values, [](DbgValueLoc
P) { return P.isFragment(); }) && "all values are expected to be fragments"
) ? void (0) : __assert_fail ("llvm::all_of(Values, [](DbgValueLoc P) { return P.isFragment(); }) && \"all values are expected to be fragments\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2656, __extension__ __PRETTY_FUNCTION__))
2655 return P.isFragment();(static_cast <bool> (llvm::all_of(Values, [](DbgValueLoc
P) { return P.isFragment(); }) && "all values are expected to be fragments"
) ? void (0) : __assert_fail ("llvm::all_of(Values, [](DbgValueLoc P) { return P.isFragment(); }) && \"all values are expected to be fragments\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2656, __extension__ __PRETTY_FUNCTION__))
2656 }) && "all values are expected to be fragments")(static_cast <bool> (llvm::all_of(Values, [](DbgValueLoc
P) { return P.isFragment(); }) && "all values are expected to be fragments"
) ? void (0) : __assert_fail ("llvm::all_of(Values, [](DbgValueLoc P) { return P.isFragment(); }) && \"all values are expected to be fragments\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2656, __extension__ __PRETTY_FUNCTION__))
;
2657 assert(llvm::is_sorted(Values) && "fragments are expected to be sorted")(static_cast <bool> (llvm::is_sorted(Values) &&
"fragments are expected to be sorted") ? void (0) : __assert_fail
("llvm::is_sorted(Values) && \"fragments are expected to be sorted\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2657, __extension__ __PRETTY_FUNCTION__))
;
2658
2659 for (const auto &Fragment : Values)
2660 DwarfDebug::emitDebugLocValue(AP, BT, Fragment, DwarfExpr);
2661
2662 } else {
2663 assert(Values.size() == 1 && "only fragments may have >1 value")(static_cast <bool> (Values.size() == 1 && "only fragments may have >1 value"
) ? void (0) : __assert_fail ("Values.size() == 1 && \"only fragments may have >1 value\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2663, __extension__ __PRETTY_FUNCTION__))
;
2664 DwarfDebug::emitDebugLocValue(AP, BT, Value, DwarfExpr);
2665 }
2666 DwarfExpr.finalize();
2667 if (DwarfExpr.TagOffset)
2668 List.setTagOffset(*DwarfExpr.TagOffset);
2669}
2670
2671void DwarfDebug::emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry,
2672 const DwarfCompileUnit *CU) {
2673 // Emit the size.
2674 Asm->OutStreamer->AddComment("Loc expr size");
2675 if (getDwarfVersion() >= 5)
2676 Asm->emitULEB128(DebugLocs.getBytes(Entry).size());
2677 else if (DebugLocs.getBytes(Entry).size() <= std::numeric_limits<uint16_t>::max())
2678 Asm->emitInt16(DebugLocs.getBytes(Entry).size());
2679 else {
2680 // The entry is too big to fit into 16 bit, drop it as there is nothing we
2681 // can do.
2682 Asm->emitInt16(0);
2683 return;
2684 }
2685 // Emit the entry.
2686 APByteStreamer Streamer(*Asm);
2687 emitDebugLocEntry(Streamer, Entry, CU);
2688}
2689
2690// Emit the header of a DWARF 5 range list table list table. Returns the symbol
2691// that designates the end of the table for the caller to emit when the table is
2692// complete.
2693static MCSymbol *emitRnglistsTableHeader(AsmPrinter *Asm,
2694 const DwarfFile &Holder) {
2695 MCSymbol *TableEnd = mcdwarf::emitListsTableHeaderStart(*Asm->OutStreamer);
2696
2697 Asm->OutStreamer->AddComment("Offset entry count");
2698 Asm->emitInt32(Holder.getRangeLists().size());
2699 Asm->OutStreamer->emitLabel(Holder.getRnglistsTableBaseSym());
2700
2701 for (const RangeSpanList &List : Holder.getRangeLists())
2702 Asm->emitLabelDifference(List.Label, Holder.getRnglistsTableBaseSym(),
2703 Asm->getDwarfOffsetByteSize());
2704
2705 return TableEnd;
2706}
2707
2708// Emit the header of a DWARF 5 locations list table. Returns the symbol that
2709// designates the end of the table for the caller to emit when the table is
2710// complete.
2711static MCSymbol *emitLoclistsTableHeader(AsmPrinter *Asm,
2712 const DwarfDebug &DD) {
2713 MCSymbol *TableEnd = mcdwarf::emitListsTableHeaderStart(*Asm->OutStreamer);
2714
2715 const auto &DebugLocs = DD.getDebugLocs();
2716
2717 Asm->OutStreamer->AddComment("Offset entry count");
2718 Asm->emitInt32(DebugLocs.getLists().size());
2719 Asm->OutStreamer->emitLabel(DebugLocs.getSym());
2720
2721 for (const auto &List : DebugLocs.getLists())
2722 Asm->emitLabelDifference(List.Label, DebugLocs.getSym(),
2723 Asm->getDwarfOffsetByteSize());
2724
2725 return TableEnd;
2726}
2727
2728template <typename Ranges, typename PayloadEmitter>
2729static void emitRangeList(
2730 DwarfDebug &DD, AsmPrinter *Asm, MCSymbol *Sym, const Ranges &R,
2731 const DwarfCompileUnit &CU, unsigned BaseAddressx, unsigned OffsetPair,
2732 unsigned StartxLength, unsigned EndOfList,
2733 StringRef (*StringifyEnum)(unsigned),
2734 bool ShouldUseBaseAddress,
2735 PayloadEmitter EmitPayload) {
2736
2737 auto Size = Asm->MAI->getCodePointerSize();
2738 bool UseDwarf5 = DD.getDwarfVersion() >= 5;
2739
2740 // Emit our symbol so we can find the beginning of the range.
2741 Asm->OutStreamer->emitLabel(Sym);
2742
2743 // Gather all the ranges that apply to the same section so they can share
2744 // a base address entry.
2745 MapVector<const MCSection *, std::vector<decltype(&*R.begin())>> SectionRanges;
2746
2747 for (const auto &Range : R)
2748 SectionRanges[&Range.Begin->getSection()].push_back(&Range);
2749
2750 const MCSymbol *CUBase = CU.getBaseAddress();
2751 bool BaseIsSet = false;
2752 for (const auto &P : SectionRanges) {
2753 auto *Base = CUBase;
2754 if (!Base && ShouldUseBaseAddress) {
2755 const MCSymbol *Begin = P.second.front()->Begin;
2756 const MCSymbol *NewBase = DD.getSectionLabel(&Begin->getSection());
2757 if (!UseDwarf5) {
2758 Base = NewBase;
2759 BaseIsSet = true;
2760 Asm->OutStreamer->emitIntValue(-1, Size);
2761 Asm->OutStreamer->AddComment(" base address");
2762 Asm->OutStreamer->emitSymbolValue(Base, Size);
2763 } else if (NewBase != Begin || P.second.size() > 1) {
2764 // Only use a base address if
2765 // * the existing pool address doesn't match (NewBase != Begin)
2766 // * or, there's more than one entry to share the base address
2767 Base = NewBase;
2768 BaseIsSet = true;
2769 Asm->OutStreamer->AddComment(StringifyEnum(BaseAddressx));
2770 Asm->emitInt8(BaseAddressx);
2771 Asm->OutStreamer->AddComment(" base address index");
2772 Asm->emitULEB128(DD.getAddressPool().getIndex(Base));
2773 }
2774 } else if (BaseIsSet && !UseDwarf5) {
2775 BaseIsSet = false;
2776 assert(!Base)(static_cast <bool> (!Base) ? void (0) : __assert_fail (
"!Base", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2776, __extension__ __PRETTY_FUNCTION__))
;
2777 Asm->OutStreamer->emitIntValue(-1, Size);
2778 Asm->OutStreamer->emitIntValue(0, Size);
2779 }
2780
2781 for (const auto *RS : P.second) {
2782 const MCSymbol *Begin = RS->Begin;
2783 const MCSymbol *End = RS->End;
2784 assert(Begin && "Range without a begin symbol?")(static_cast <bool> (Begin && "Range without a begin symbol?"
) ? void (0) : __assert_fail ("Begin && \"Range without a begin symbol?\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2784, __extension__ __PRETTY_FUNCTION__))
;
2785 assert(End && "Range without an end symbol?")(static_cast <bool> (End && "Range without an end symbol?"
) ? void (0) : __assert_fail ("End && \"Range without an end symbol?\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2785, __extension__ __PRETTY_FUNCTION__))
;
2786 if (Base) {
2787 if (UseDwarf5) {
2788 // Emit offset_pair when we have a base.
2789 Asm->OutStreamer->AddComment(StringifyEnum(OffsetPair));
2790 Asm->emitInt8(OffsetPair);
2791 Asm->OutStreamer->AddComment(" starting offset");
2792 Asm->emitLabelDifferenceAsULEB128(Begin, Base);
2793 Asm->OutStreamer->AddComment(" ending offset");
2794 Asm->emitLabelDifferenceAsULEB128(End, Base);
2795 } else {
2796 Asm->emitLabelDifference(Begin, Base, Size);
2797 Asm->emitLabelDifference(End, Base, Size);
2798 }
2799 } else if (UseDwarf5) {
2800 Asm->OutStreamer->AddComment(StringifyEnum(StartxLength));
2801 Asm->emitInt8(StartxLength);
2802 Asm->OutStreamer->AddComment(" start index");
2803 Asm->emitULEB128(DD.getAddressPool().getIndex(Begin));
2804 Asm->OutStreamer->AddComment(" length");
2805 Asm->emitLabelDifferenceAsULEB128(End, Begin);
2806 } else {
2807 Asm->OutStreamer->emitSymbolValue(Begin, Size);
2808 Asm->OutStreamer->emitSymbolValue(End, Size);
2809 }
2810 EmitPayload(*RS);
2811 }
2812 }
2813
2814 if (UseDwarf5) {
2815 Asm->OutStreamer->AddComment(StringifyEnum(EndOfList));
2816 Asm->emitInt8(EndOfList);
2817 } else {
2818 // Terminate the list with two 0 values.
2819 Asm->OutStreamer->emitIntValue(0, Size);
2820 Asm->OutStreamer->emitIntValue(0, Size);
2821 }
2822}
2823
2824// Handles emission of both debug_loclist / debug_loclist.dwo
2825static void emitLocList(DwarfDebug &DD, AsmPrinter *Asm, const DebugLocStream::List &List) {
2826 emitRangeList(DD, Asm, List.Label, DD.getDebugLocs().getEntries(List),
2827 *List.CU, dwarf::DW_LLE_base_addressx,
2828 dwarf::DW_LLE_offset_pair, dwarf::DW_LLE_startx_length,
2829 dwarf::DW_LLE_end_of_list, llvm::dwarf::LocListEncodingString,
2830 /* ShouldUseBaseAddress */ true,
2831 [&](const DebugLocStream::Entry &E) {
2832 DD.emitDebugLocEntryLocation(E, List.CU);
2833 });
2834}
2835
2836void DwarfDebug::emitDebugLocImpl(MCSection *Sec) {
2837 if (DebugLocs.getLists().empty())
2838 return;
2839
2840 Asm->OutStreamer->SwitchSection(Sec);
2841
2842 MCSymbol *TableEnd = nullptr;
2843 if (getDwarfVersion() >= 5)
2844 TableEnd = emitLoclistsTableHeader(Asm, *this);
2845
2846 for (const auto &List : DebugLocs.getLists())
2847 emitLocList(*this, Asm, List);
2848
2849 if (TableEnd)
2850 Asm->OutStreamer->emitLabel(TableEnd);
2851}
2852
2853// Emit locations into the .debug_loc/.debug_loclists section.
2854void DwarfDebug::emitDebugLoc() {
2855 emitDebugLocImpl(
2856 getDwarfVersion() >= 5
2857 ? Asm->getObjFileLowering().getDwarfLoclistsSection()
2858 : Asm->getObjFileLowering().getDwarfLocSection());
2859}
2860
2861// Emit locations into the .debug_loc.dwo/.debug_loclists.dwo section.
2862void DwarfDebug::emitDebugLocDWO() {
2863 if (getDwarfVersion() >= 5) {
2864 emitDebugLocImpl(
2865 Asm->getObjFileLowering().getDwarfLoclistsDWOSection());
2866
2867 return;
2868 }
2869
2870 for (const auto &List : DebugLocs.getLists()) {
2871 Asm->OutStreamer->SwitchSection(
2872 Asm->getObjFileLowering().getDwarfLocDWOSection());
2873 Asm->OutStreamer->emitLabel(List.Label);
2874
2875 for (const auto &Entry : DebugLocs.getEntries(List)) {
2876 // GDB only supports startx_length in pre-standard split-DWARF.
2877 // (in v5 standard loclists, it currently* /only/ supports base_address +
2878 // offset_pair, so the implementations can't really share much since they
2879 // need to use different representations)
2880 // * as of October 2018, at least
2881 //
2882 // In v5 (see emitLocList), this uses SectionLabels to reuse existing
2883 // addresses in the address pool to minimize object size/relocations.
2884 Asm->emitInt8(dwarf::DW_LLE_startx_length);
2885 unsigned idx = AddrPool.getIndex(Entry.Begin);
2886 Asm->emitULEB128(idx);
2887 // Also the pre-standard encoding is slightly different, emitting this as
2888 // an address-length entry here, but its a ULEB128 in DWARFv5 loclists.
2889 Asm->emitLabelDifference(Entry.End, Entry.Begin, 4);
2890 emitDebugLocEntryLocation(Entry, List.CU);
2891 }
2892 Asm->emitInt8(dwarf::DW_LLE_end_of_list);
2893 }
2894}
2895
2896struct ArangeSpan {
2897 const MCSymbol *Start, *End;
2898};
2899
2900// Emit a debug aranges section, containing a CU lookup for any
2901// address we can tie back to a CU.
2902void DwarfDebug::emitDebugARanges() {
2903 // Provides a unique id per text section.
2904 MapVector<MCSection *, SmallVector<SymbolCU, 8>> SectionMap;
2905
2906 // Filter labels by section.
2907 for (const SymbolCU &SCU : ArangeLabels) {
2908 if (SCU.Sym->isInSection()) {
2909 // Make a note of this symbol and it's section.
2910 MCSection *Section = &SCU.Sym->getSection();
2911 if (!Section->getKind().isMetadata())
2912 SectionMap[Section].push_back(SCU);
2913 } else {
2914 // Some symbols (e.g. common/bss on mach-o) can have no section but still
2915 // appear in the output. This sucks as we rely on sections to build
2916 // arange spans. We can do it without, but it's icky.
2917 SectionMap[nullptr].push_back(SCU);
2918 }
2919 }
2920
2921 DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan>> Spans;
2922
2923 for (auto &I : SectionMap) {
2924 MCSection *Section = I.first;
2925 SmallVector<SymbolCU, 8> &List = I.second;
2926 if (List.size() < 1)
2927 continue;
2928
2929 // If we have no section (e.g. common), just write out
2930 // individual spans for each symbol.
2931 if (!Section) {
2932 for (const SymbolCU &Cur : List) {
2933 ArangeSpan Span;
2934 Span.Start = Cur.Sym;
2935 Span.End = nullptr;
2936 assert(Cur.CU)(static_cast <bool> (Cur.CU) ? void (0) : __assert_fail
("Cur.CU", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2936, __extension__ __PRETTY_FUNCTION__))
;
2937 Spans[Cur.CU].push_back(Span);
2938 }
2939 continue;
2940 }
2941
2942 // Sort the symbols by offset within the section.
2943 llvm::stable_sort(List, [&](const SymbolCU &A, const SymbolCU &B) {
2944 unsigned IA = A.Sym ? Asm->OutStreamer->GetSymbolOrder(A.Sym) : 0;
2945 unsigned IB = B.Sym ? Asm->OutStreamer->GetSymbolOrder(B.Sym) : 0;
2946
2947 // Symbols with no order assigned should be placed at the end.
2948 // (e.g. section end labels)
2949 if (IA == 0)
2950 return false;
2951 if (IB == 0)
2952 return true;
2953 return IA < IB;
2954 });
2955
2956 // Insert a final terminator.
2957 List.push_back(SymbolCU(nullptr, Asm->OutStreamer->endSection(Section)));
2958
2959 // Build spans between each label.
2960 const MCSymbol *StartSym = List[0].Sym;
2961 for (size_t n = 1, e = List.size(); n < e; n++) {
2962 const SymbolCU &Prev = List[n - 1];
2963 const SymbolCU &Cur = List[n];
2964
2965 // Try and build the longest span we can within the same CU.
2966 if (Cur.CU != Prev.CU) {
2967 ArangeSpan Span;
2968 Span.Start = StartSym;
2969 Span.End = Cur.Sym;
2970 assert(Prev.CU)(static_cast <bool> (Prev.CU) ? void (0) : __assert_fail
("Prev.CU", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 2970, __extension__ __PRETTY_FUNCTION__))
;
2971 Spans[Prev.CU].push_back(Span);
2972 StartSym = Cur.Sym;
2973 }
2974 }
2975 }
2976
2977 // Start the dwarf aranges section.
2978 Asm->OutStreamer->SwitchSection(
2979 Asm->getObjFileLowering().getDwarfARangesSection());
2980
2981 unsigned PtrSize = Asm->MAI->getCodePointerSize();
2982
2983 // Build a list of CUs used.
2984 std::vector<DwarfCompileUnit *> CUs;
2985 for (const auto &it : Spans) {
2986 DwarfCompileUnit *CU = it.first;
2987 CUs.push_back(CU);
2988 }
2989
2990 // Sort the CU list (again, to ensure consistent output order).
2991 llvm::sort(CUs, [](const DwarfCompileUnit *A, const DwarfCompileUnit *B) {
2992 return A->getUniqueID() < B->getUniqueID();
2993 });
2994
2995 // Emit an arange table for each CU we used.
2996 for (DwarfCompileUnit *CU : CUs) {
2997 std::vector<ArangeSpan> &List = Spans[CU];
2998
2999 // Describe the skeleton CU's offset and length, not the dwo file's.
3000 if (auto *Skel = CU->getSkeleton())
3001 CU = Skel;
3002
3003 // Emit size of content not including length itself.
3004 unsigned ContentSize =
3005 sizeof(int16_t) + // DWARF ARange version number
3006 Asm->getDwarfOffsetByteSize() + // Offset of CU in the .debug_info
3007 // section
3008 sizeof(int8_t) + // Pointer Size (in bytes)
3009 sizeof(int8_t); // Segment Size (in bytes)
3010
3011 unsigned TupleSize = PtrSize * 2;
3012
3013 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
3014 unsigned Padding = offsetToAlignment(
3015 Asm->getUnitLengthFieldByteSize() + ContentSize, Align(TupleSize));
3016
3017 ContentSize += Padding;
3018 ContentSize += (List.size() + 1) * TupleSize;
3019
3020 // For each compile unit, write the list of spans it covers.
3021 Asm->emitDwarfUnitLength(ContentSize, "Length of ARange Set");
3022 Asm->OutStreamer->AddComment("DWARF Arange version number");
3023 Asm->emitInt16(dwarf::DW_ARANGES_VERSION);
3024 Asm->OutStreamer->AddComment("Offset Into Debug Info Section");
3025 emitSectionReference(*CU);
3026 Asm->OutStreamer->AddComment("Address Size (in bytes)");
3027 Asm->emitInt8(PtrSize);
3028 Asm->OutStreamer->AddComment("Segment Size (in bytes)");
3029 Asm->emitInt8(0);
3030
3031 Asm->OutStreamer->emitFill(Padding, 0xff);
3032
3033 for (const ArangeSpan &Span : List) {
3034 Asm->emitLabelReference(Span.Start, PtrSize);
3035
3036 // Calculate the size as being from the span start to it's end.
3037 if (Span.End) {
3038 Asm->emitLabelDifference(Span.End, Span.Start, PtrSize);
3039 } else {
3040 // For symbols without an end marker (e.g. common), we
3041 // write a single arange entry containing just that one symbol.
3042 uint64_t Size = SymSize[Span.Start];
3043 if (Size == 0)
3044 Size = 1;
3045
3046 Asm->OutStreamer->emitIntValue(Size, PtrSize);
3047 }
3048 }
3049
3050 Asm->OutStreamer->AddComment("ARange terminator");
3051 Asm->OutStreamer->emitIntValue(0, PtrSize);
3052 Asm->OutStreamer->emitIntValue(0, PtrSize);
3053 }
3054}
3055
3056/// Emit a single range list. We handle both DWARF v5 and earlier.
3057static void emitRangeList(DwarfDebug &DD, AsmPrinter *Asm,
3058 const RangeSpanList &List) {
3059 emitRangeList(DD, Asm, List.Label, List.Ranges, *List.CU,
3060 dwarf::DW_RLE_base_addressx, dwarf::DW_RLE_offset_pair,
3061 dwarf::DW_RLE_startx_length, dwarf::DW_RLE_end_of_list,
3062 llvm::dwarf::RangeListEncodingString,
3063 List.CU->getCUNode()->getRangesBaseAddress() ||
3064 DD.getDwarfVersion() >= 5,
3065 [](auto) {});
3066}
3067
3068void DwarfDebug::emitDebugRangesImpl(const DwarfFile &Holder, MCSection *Section) {
3069 if (Holder.getRangeLists().empty())
3070 return;
3071
3072 assert(useRangesSection())(static_cast <bool> (useRangesSection()) ? void (0) : __assert_fail
("useRangesSection()", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 3072, __extension__ __PRETTY_FUNCTION__))
;
3073 assert(!CUMap.empty())(static_cast <bool> (!CUMap.empty()) ? void (0) : __assert_fail
("!CUMap.empty()", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 3073, __extension__ __PRETTY_FUNCTION__))
;
3074 assert(llvm::any_of(CUMap, [](const decltype(CUMap)::value_type &Pair) {(static_cast <bool> (llvm::any_of(CUMap, [](const decltype
(CUMap)::value_type &Pair) { return !Pair.second->getCUNode
()->isDebugDirectivesOnly(); })) ? void (0) : __assert_fail
("llvm::any_of(CUMap, [](const decltype(CUMap)::value_type &Pair) { return !Pair.second->getCUNode()->isDebugDirectivesOnly(); })"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 3076, __extension__ __PRETTY_FUNCTION__))
3075 return !Pair.second->getCUNode()->isDebugDirectivesOnly();(static_cast <bool> (llvm::any_of(CUMap, [](const decltype
(CUMap)::value_type &Pair) { return !Pair.second->getCUNode
()->isDebugDirectivesOnly(); })) ? void (0) : __assert_fail
("llvm::any_of(CUMap, [](const decltype(CUMap)::value_type &Pair) { return !Pair.second->getCUNode()->isDebugDirectivesOnly(); })"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 3076, __extension__ __PRETTY_FUNCTION__))
3076 }))(static_cast <bool> (llvm::any_of(CUMap, [](const decltype
(CUMap)::value_type &Pair) { return !Pair.second->getCUNode
()->isDebugDirectivesOnly(); })) ? void (0) : __assert_fail
("llvm::any_of(CUMap, [](const decltype(CUMap)::value_type &Pair) { return !Pair.second->getCUNode()->isDebugDirectivesOnly(); })"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 3076, __extension__ __PRETTY_FUNCTION__))
;
3077
3078 Asm->OutStreamer->SwitchSection(Section);
3079
3080 MCSymbol *TableEnd = nullptr;
3081 if (getDwarfVersion() >= 5)
3082 TableEnd = emitRnglistsTableHeader(Asm, Holder);
3083
3084 for (const RangeSpanList &List : Holder.getRangeLists())
3085 emitRangeList(*this, Asm, List);
3086
3087 if (TableEnd)
3088 Asm->OutStreamer->emitLabel(TableEnd);
3089}
3090
3091/// Emit address ranges into the .debug_ranges section or into the DWARF v5
3092/// .debug_rnglists section.
3093void DwarfDebug::emitDebugRanges() {
3094 const auto &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
3095
3096 emitDebugRangesImpl(Holder,
3097 getDwarfVersion() >= 5
3098 ? Asm->getObjFileLowering().getDwarfRnglistsSection()
3099 : Asm->getObjFileLowering().getDwarfRangesSection());
3100}
3101
3102void DwarfDebug::emitDebugRangesDWO() {
3103 emitDebugRangesImpl(InfoHolder,
3104 Asm->getObjFileLowering().getDwarfRnglistsDWOSection());
3105}
3106
3107/// Emit the header of a DWARF 5 macro section, or the GNU extension for
3108/// DWARF 4.
3109static void emitMacroHeader(AsmPrinter *Asm, const DwarfDebug &DD,
3110 const DwarfCompileUnit &CU, uint16_t DwarfVersion) {
3111 enum HeaderFlagMask {
3112#define HANDLE_MACRO_FLAG(ID, NAME) MACRO_FLAG_##NAME = ID,
3113#include "llvm/BinaryFormat/Dwarf.def"
3114 };
3115 Asm->OutStreamer->AddComment("Macro information version");
3116 Asm->emitInt16(DwarfVersion >= 5 ? DwarfVersion : 4);
3117 // We emit the line offset flag unconditionally here, since line offset should
3118 // be mostly present.
3119 if (Asm->isDwarf64()) {
3120 Asm->OutStreamer->AddComment("Flags: 64 bit, debug_line_offset present");
3121 Asm->emitInt8(MACRO_FLAG_OFFSET_SIZE | MACRO_FLAG_DEBUG_LINE_OFFSET);
3122 } else {
3123 Asm->OutStreamer->AddComment("Flags: 32 bit, debug_line_offset present");
3124 Asm->emitInt8(MACRO_FLAG_DEBUG_LINE_OFFSET);
3125 }
3126 Asm->OutStreamer->AddComment("debug_line_offset");
3127 if (DD.useSplitDwarf())
3128 Asm->emitDwarfLengthOrOffset(0);
3129 else
3130 Asm->emitDwarfSymbolReference(CU.getLineTableStartSym());
3131}
3132
3133void DwarfDebug::handleMacroNodes(DIMacroNodeArray Nodes, DwarfCompileUnit &U) {
3134 for (auto *MN : Nodes) {
3135 if (auto *M = dyn_cast<DIMacro>(MN))
3136 emitMacro(*M);
3137 else if (auto *F = dyn_cast<DIMacroFile>(MN))
3138 emitMacroFile(*F, U);
3139 else
3140 llvm_unreachable("Unexpected DI type!")::llvm::llvm_unreachable_internal("Unexpected DI type!", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 3140)
;
3141 }
3142}
3143
3144void DwarfDebug::emitMacro(DIMacro &M) {
3145 StringRef Name = M.getName();
3146 StringRef Value = M.getValue();
3147
3148 // There should be one space between the macro name and the macro value in
3149 // define entries. In undef entries, only the macro name is emitted.
3150 std::string Str = Value.empty() ? Name.str() : (Name + " " + Value).str();
3151
3152 if (UseDebugMacroSection) {
3153 if (getDwarfVersion() >= 5) {
3154 unsigned Type = M.getMacinfoType() == dwarf::DW_MACINFO_define
3155 ? dwarf::DW_MACRO_define_strx
3156 : dwarf::DW_MACRO_undef_strx;
3157 Asm->OutStreamer->AddComment(dwarf::MacroString(Type));
3158 Asm->emitULEB128(Type);
3159 Asm->OutStreamer->AddComment("Line Number");
3160 Asm->emitULEB128(M.getLine());
3161 Asm->OutStreamer->AddComment("Macro String");
3162 Asm->emitULEB128(
3163 InfoHolder.getStringPool().getIndexedEntry(*Asm, Str).getIndex());
3164 } else {
3165 unsigned Type = M.getMacinfoType() == dwarf::DW_MACINFO_define
3166 ? dwarf::DW_MACRO_GNU_define_indirect
3167 : dwarf::DW_MACRO_GNU_undef_indirect;
3168 Asm->OutStreamer->AddComment(dwarf::GnuMacroString(Type));
3169 Asm->emitULEB128(Type);
3170 Asm->OutStreamer->AddComment("Line Number");
3171 Asm->emitULEB128(M.getLine());
3172 Asm->OutStreamer->AddComment("Macro String");
3173 Asm->emitDwarfSymbolReference(
3174 InfoHolder.getStringPool().getEntry(*Asm, Str).getSymbol());
3175 }
3176 } else {
3177 Asm->OutStreamer->AddComment(dwarf::MacinfoString(M.getMacinfoType()));
3178 Asm->emitULEB128(M.getMacinfoType());
3179 Asm->OutStreamer->AddComment("Line Number");
3180 Asm->emitULEB128(M.getLine());
3181 Asm->OutStreamer->AddComment("Macro String");
3182 Asm->OutStreamer->emitBytes(Str);
3183 Asm->emitInt8('\0');
3184 }
3185}
3186
3187void DwarfDebug::emitMacroFileImpl(
3188 DIMacroFile &MF, DwarfCompileUnit &U, unsigned StartFile, unsigned EndFile,
3189 StringRef (*MacroFormToString)(unsigned Form)) {
3190
3191 Asm->OutStreamer->AddComment(MacroFormToString(StartFile));
3192 Asm->emitULEB128(StartFile);
3193 Asm->OutStreamer->AddComment("Line Number");
3194 Asm->emitULEB128(MF.getLine());
3195 Asm->OutStreamer->AddComment("File Number");
3196 DIFile &F = *MF.getFile();
3197 if (useSplitDwarf())
3198 Asm->emitULEB128(getDwoLineTable(U)->getFile(
3199 F.getDirectory(), F.getFilename(), getMD5AsBytes(&F),
3200 Asm->OutContext.getDwarfVersion(), F.getSource()));
3201 else
3202 Asm->emitULEB128(U.getOrCreateSourceID(&F));
3203 handleMacroNodes(MF.getElements(), U);
3204 Asm->OutStreamer->AddComment(MacroFormToString(EndFile));
3205 Asm->emitULEB128(EndFile);
3206}
3207
3208void DwarfDebug::emitMacroFile(DIMacroFile &F, DwarfCompileUnit &U) {
3209 // DWARFv5 macro and DWARFv4 macinfo share some common encodings,
3210 // so for readibility/uniformity, We are explicitly emitting those.
3211 assert(F.getMacinfoType() == dwarf::DW_MACINFO_start_file)(static_cast <bool> (F.getMacinfoType() == dwarf::DW_MACINFO_start_file
) ? void (0) : __assert_fail ("F.getMacinfoType() == dwarf::DW_MACINFO_start_file"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 3211, __extension__ __PRETTY_FUNCTION__))
;
3212 if (UseDebugMacroSection)
3213 emitMacroFileImpl(
3214 F, U, dwarf::DW_MACRO_start_file, dwarf::DW_MACRO_end_file,
3215 (getDwarfVersion() >= 5) ? dwarf::MacroString : dwarf::GnuMacroString);
3216 else
3217 emitMacroFileImpl(F, U, dwarf::DW_MACINFO_start_file,
3218 dwarf::DW_MACINFO_end_file, dwarf::MacinfoString);
3219}
3220
3221void DwarfDebug::emitDebugMacinfoImpl(MCSection *Section) {
3222 for (const auto &P : CUMap) {
3223 auto &TheCU = *P.second;
3224 auto *SkCU = TheCU.getSkeleton();
3225 DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
3226 auto *CUNode = cast<DICompileUnit>(P.first);
3227 DIMacroNodeArray Macros = CUNode->getMacros();
3228 if (Macros.empty())
3229 continue;
3230 Asm->OutStreamer->SwitchSection(Section);
3231 Asm->OutStreamer->emitLabel(U.getMacroLabelBegin());
3232 if (UseDebugMacroSection)
3233 emitMacroHeader(Asm, *this, U, getDwarfVersion());
3234 handleMacroNodes(Macros, U);
3235 Asm->OutStreamer->AddComment("End Of Macro List Mark");
3236 Asm->emitInt8(0);
3237 }
3238}
3239
3240/// Emit macros into a debug macinfo/macro section.
3241void DwarfDebug::emitDebugMacinfo() {
3242 auto &ObjLower = Asm->getObjFileLowering();
3243 emitDebugMacinfoImpl(UseDebugMacroSection
3244 ? ObjLower.getDwarfMacroSection()
3245 : ObjLower.getDwarfMacinfoSection());
3246}
3247
3248void DwarfDebug::emitDebugMacinfoDWO() {
3249 auto &ObjLower = Asm->getObjFileLowering();
3250 emitDebugMacinfoImpl(UseDebugMacroSection
3251 ? ObjLower.getDwarfMacroDWOSection()
3252 : ObjLower.getDwarfMacinfoDWOSection());
3253}
3254
3255// DWARF5 Experimental Separate Dwarf emitters.
3256
3257void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
3258 std::unique_ptr<DwarfCompileUnit> NewU) {
3259
3260 if (!CompilationDir.empty())
3261 NewU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
3262 addGnuPubAttributes(*NewU, Die);
3263
3264 SkeletonHolder.addUnit(std::move(NewU));
3265}
3266
3267DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
3268
3269 auto OwnedUnit = std::make_unique<DwarfCompileUnit>(
3270 CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder,
3271 UnitKind::Skeleton);
3272 DwarfCompileUnit &NewCU = *OwnedUnit;
3273 NewCU.setSection(Asm->getObjFileLowering().getDwarfInfoSection());
3274
3275 NewCU.initStmtList();
3276
3277 if (useSegmentedStringOffsetsTable())
3278 NewCU.addStringOffsetsStart();
3279
3280 initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
3281
3282 return NewCU;
3283}
3284
3285// Emit the .debug_info.dwo section for separated dwarf. This contains the
3286// compile units that would normally be in debug_info.
3287void DwarfDebug::emitDebugInfoDWO() {
3288 assert(useSplitDwarf() && "No split dwarf debug info?")(static_cast <bool> (useSplitDwarf() && "No split dwarf debug info?"
) ? void (0) : __assert_fail ("useSplitDwarf() && \"No split dwarf debug info?\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 3288, __extension__ __PRETTY_FUNCTION__))
;
3289 // Don't emit relocations into the dwo file.
3290 InfoHolder.emitUnits(/* UseOffsets */ true);
3291}
3292
3293// Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
3294// abbreviations for the .debug_info.dwo section.
3295void DwarfDebug::emitDebugAbbrevDWO() {
3296 assert(useSplitDwarf() && "No split dwarf?")(static_cast <bool> (useSplitDwarf() && "No split dwarf?"
) ? void (0) : __assert_fail ("useSplitDwarf() && \"No split dwarf?\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 3296, __extension__ __PRETTY_FUNCTION__))
;
3297 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
3298}
3299
3300void DwarfDebug::emitDebugLineDWO() {
3301 assert(useSplitDwarf() && "No split dwarf?")(static_cast <bool> (useSplitDwarf() && "No split dwarf?"
) ? void (0) : __assert_fail ("useSplitDwarf() && \"No split dwarf?\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 3301, __extension__ __PRETTY_FUNCTION__))
;
3302 SplitTypeUnitFileTable.Emit(
3303 *Asm->OutStreamer, MCDwarfLineTableParams(),
3304 Asm->getObjFileLowering().getDwarfLineDWOSection());
3305}
3306
3307void DwarfDebug::emitStringOffsetsTableHeaderDWO() {
3308 assert(useSplitDwarf() && "No split dwarf?")(static_cast <bool> (useSplitDwarf() && "No split dwarf?"
) ? void (0) : __assert_fail ("useSplitDwarf() && \"No split dwarf?\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 3308, __extension__ __PRETTY_FUNCTION__))
;
3309 InfoHolder.getStringPool().emitStringOffsetsTableHeader(
3310 *Asm, Asm->getObjFileLowering().getDwarfStrOffDWOSection(),
3311 InfoHolder.getStringOffsetsStartSym());
3312}
3313
3314// Emit the .debug_str.dwo section for separated dwarf. This contains the
3315// string section and is identical in format to traditional .debug_str
3316// sections.
3317void DwarfDebug::emitDebugStrDWO() {
3318 if (useSegmentedStringOffsetsTable())
3319 emitStringOffsetsTableHeaderDWO();
3320 assert(useSplitDwarf() && "No split dwarf?")(static_cast <bool> (useSplitDwarf() && "No split dwarf?"
) ? void (0) : __assert_fail ("useSplitDwarf() && \"No split dwarf?\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 3320, __extension__ __PRETTY_FUNCTION__))
;
3321 MCSection *OffSec = Asm->getObjFileLowering().getDwarfStrOffDWOSection();
3322 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
3323 OffSec, /* UseRelativeOffsets = */ false);
3324}
3325
3326// Emit address pool.
3327void DwarfDebug::emitDebugAddr() {
3328 AddrPool.emit(*Asm, Asm->getObjFileLowering().getDwarfAddrSection());
3329}
3330
3331MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
3332 if (!useSplitDwarf())
3333 return nullptr;
3334 const DICompileUnit *DIUnit = CU.getCUNode();
3335 SplitTypeUnitFileTable.maybeSetRootFile(
3336 DIUnit->getDirectory(), DIUnit->getFilename(),
3337 getMD5AsBytes(DIUnit->getFile()), DIUnit->getSource());
3338 return &SplitTypeUnitFileTable;
3339}
3340
3341uint64_t DwarfDebug::makeTypeSignature(StringRef Identifier) {
3342 MD5 Hash;
3343 Hash.update(Identifier);
3344 // ... take the least significant 8 bytes and return those. Our MD5
3345 // implementation always returns its results in little endian, so we actually
3346 // need the "high" word.
3347 MD5::MD5Result Result;
3348 Hash.final(Result);
3349 return Result.high();
3350}
3351
3352void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
3353 StringRef Identifier, DIE &RefDie,
3354 const DICompositeType *CTy) {
3355 // Fast path if we're building some type units and one has already used the
3356 // address pool we know we're going to throw away all this work anyway, so
3357 // don't bother building dependent types.
3358 if (!TypeUnitsUnderConstruction.empty() && AddrPool.hasBeenUsed())
3359 return;
3360
3361 auto Ins = TypeSignatures.insert(std::make_pair(CTy, 0));
3362 if (!Ins.second) {
3363 CU.addDIETypeSignature(RefDie, Ins.first->second);
3364 return;
3365 }
3366
3367 bool TopLevelType = TypeUnitsUnderConstruction.empty();
3368 AddrPool.resetUsedFlag();
3369
3370 auto OwnedUnit = std::make_unique<DwarfTypeUnit>(CU, Asm, this, &InfoHolder,
3371 getDwoLineTable(CU));
3372 DwarfTypeUnit &NewTU = *OwnedUnit;
3373 DIE &UnitDie = NewTU.getUnitDie();
3374 TypeUnitsUnderConstruction.emplace_back(std::move(OwnedUnit), CTy);
3375
3376 NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
3377 CU.getLanguage());
3378
3379 uint64_t Signature = makeTypeSignature(Identifier);
3380 NewTU.setTypeSignature(Signature);
3381 Ins.first->second = Signature;
3382
3383 if (useSplitDwarf()) {
3384 MCSection *Section =
3385 getDwarfVersion() <= 4
3386 ? Asm->getObjFileLowering().getDwarfTypesDWOSection()
3387 : Asm->getObjFileLowering().getDwarfInfoDWOSection();
3388 NewTU.setSection(Section);
3389 } else {
3390 MCSection *Section =
3391 getDwarfVersion() <= 4
3392 ? Asm->getObjFileLowering().getDwarfTypesSection(Signature)
3393 : Asm->getObjFileLowering().getDwarfInfoSection(Signature);
3394 NewTU.setSection(Section);
3395 // Non-split type units reuse the compile unit's line table.
3396 CU.applyStmtList(UnitDie);
3397 }
3398
3399 // Add DW_AT_str_offsets_base to the type unit DIE, but not for split type
3400 // units.
3401 if (useSegmentedStringOffsetsTable() && !useSplitDwarf())
3402 NewTU.addStringOffsetsStart();
3403
3404 NewTU.setType(NewTU.createTypeDIE(CTy));
3405
3406 if (TopLevelType) {
3407 auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
3408 TypeUnitsUnderConstruction.clear();
3409
3410 // Types referencing entries in the address table cannot be placed in type
3411 // units.
3412 if (AddrPool.hasBeenUsed()) {
3413
3414 // Remove all the types built while building this type.
3415 // This is pessimistic as some of these types might not be dependent on
3416 // the type that used an address.
3417 for (const auto &TU : TypeUnitsToAdd)
3418 TypeSignatures.erase(TU.second);
3419
3420 // Construct this type in the CU directly.
3421 // This is inefficient because all the dependent types will be rebuilt
3422 // from scratch, including building them in type units, discovering that
3423 // they depend on addresses, throwing them out and rebuilding them.
3424 CU.constructTypeDIE(RefDie, cast<DICompositeType>(CTy));
3425 return;
3426 }
3427
3428 // If the type wasn't dependent on fission addresses, finish adding the type
3429 // and all its dependent types.
3430 for (auto &TU : TypeUnitsToAdd) {
3431 InfoHolder.computeSizeAndOffsetsForUnit(TU.first.get());
3432 InfoHolder.emitUnit(TU.first.get(), useSplitDwarf());
3433 }
3434 }
3435 CU.addDIETypeSignature(RefDie, Signature);
3436}
3437
3438DwarfDebug::NonTypeUnitContext::NonTypeUnitContext(DwarfDebug *DD)
3439 : DD(DD),
3440 TypeUnitsUnderConstruction(std::move(DD->TypeUnitsUnderConstruction)), AddrPoolUsed(DD->AddrPool.hasBeenUsed()) {
3441 DD->TypeUnitsUnderConstruction.clear();
3442 DD->AddrPool.resetUsedFlag();
3443}
3444
3445DwarfDebug::NonTypeUnitContext::~NonTypeUnitContext() {
3446 DD->TypeUnitsUnderConstruction = std::move(TypeUnitsUnderConstruction);
3447 DD->AddrPool.resetUsedFlag(AddrPoolUsed);
3448}
3449
3450DwarfDebug::NonTypeUnitContext DwarfDebug::enterNonTypeUnitContext() {
3451 return NonTypeUnitContext(this);
3452}
3453
3454// Add the Name along with its companion DIE to the appropriate accelerator
3455// table (for AccelTableKind::Dwarf it's always AccelDebugNames, for
3456// AccelTableKind::Apple, we use the table we got as an argument). If
3457// accelerator tables are disabled, this function does nothing.
3458template <typename DataT>
3459void DwarfDebug::addAccelNameImpl(const DICompileUnit &CU,
3460 AccelTable<DataT> &AppleAccel, StringRef Name,
3461 const DIE &Die) {
3462 if (getAccelTableKind() == AccelTableKind::None)
3463 return;
3464
3465 if (getAccelTableKind() != AccelTableKind::Apple &&
3466 CU.getNameTableKind() != DICompileUnit::DebugNameTableKind::Default)
3467 return;
3468
3469 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
3470 DwarfStringPoolEntryRef Ref = Holder.getStringPool().getEntry(*Asm, Name);
3471
3472 switch (getAccelTableKind()) {
3473 case AccelTableKind::Apple:
3474 AppleAccel.addName(Ref, Die);
3475 break;
3476 case AccelTableKind::Dwarf:
3477 AccelDebugNames.addName(Ref, Die);
3478 break;
3479 case AccelTableKind::Default:
3480 llvm_unreachable("Default should have already been resolved.")::llvm::llvm_unreachable_internal("Default should have already been resolved."
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 3480)
;
3481 case AccelTableKind::None:
3482 llvm_unreachable("None handled above")::llvm::llvm_unreachable_internal("None handled above", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 3482)
;
3483 }
3484}
3485
3486void DwarfDebug::addAccelName(const DICompileUnit &CU, StringRef Name,
3487 const DIE &Die) {
3488 addAccelNameImpl(CU, AccelNames, Name, Die);
3489}
3490
3491void DwarfDebug::addAccelObjC(const DICompileUnit &CU, StringRef Name,
3492 const DIE &Die) {
3493 // ObjC names go only into the Apple accelerator tables.
3494 if (getAccelTableKind() == AccelTableKind::Apple)
3495 addAccelNameImpl(CU, AccelObjC, Name, Die);
3496}
3497
3498void DwarfDebug::addAccelNamespace(const DICompileUnit &CU, StringRef Name,
3499 const DIE &Die) {
3500 addAccelNameImpl(CU, AccelNamespace, Name, Die);
3501}
3502
3503void DwarfDebug::addAccelType(const DICompileUnit &CU, StringRef Name,
3504 const DIE &Die, char Flags) {
3505 addAccelNameImpl(CU, AccelTypes, Name, Die);
3506}
3507
3508uint16_t DwarfDebug::getDwarfVersion() const {
3509 return Asm->OutStreamer->getContext().getDwarfVersion();
3510}
3511
3512dwarf::Form DwarfDebug::getDwarfSectionOffsetForm() const {
3513 if (Asm->getDwarfVersion() >= 4)
3514 return dwarf::Form::DW_FORM_sec_offset;
3515 assert((!Asm->isDwarf64() || (Asm->getDwarfVersion() == 3)) &&(static_cast <bool> ((!Asm->isDwarf64() || (Asm->
getDwarfVersion() == 3)) && "DWARF64 is not defined prior DWARFv3"
) ? void (0) : __assert_fail ("(!Asm->isDwarf64() || (Asm->getDwarfVersion() == 3)) && \"DWARF64 is not defined prior DWARFv3\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 3516, __extension__ __PRETTY_FUNCTION__))
3516 "DWARF64 is not defined prior DWARFv3")(static_cast <bool> ((!Asm->isDwarf64() || (Asm->
getDwarfVersion() == 3)) && "DWARF64 is not defined prior DWARFv3"
) ? void (0) : __assert_fail ("(!Asm->isDwarf64() || (Asm->getDwarfVersion() == 3)) && \"DWARF64 is not defined prior DWARFv3\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 3516, __extension__ __PRETTY_FUNCTION__))
;
3517 return Asm->isDwarf64() ? dwarf::Form::DW_FORM_data8
3518 : dwarf::Form::DW_FORM_data4;
3519}
3520
3521const MCSymbol *DwarfDebug::getSectionLabel(const MCSection *S) {
3522 auto I = SectionLabels.find(S);
3523 if (I == SectionLabels.end())
3524 return nullptr;
3525 return I->second;
3526}
3527void DwarfDebug::insertSectionLabel(const MCSymbol *S) {
3528 if (SectionLabels.insert(std::make_pair(&S->getSection(), S)).second)
3529 if (useSplitDwarf() || getDwarfVersion() >= 5)
3530 AddrPool.getIndex(S);
3531}
3532
3533Optional<MD5::MD5Result> DwarfDebug::getMD5AsBytes(const DIFile *File) const {
3534 assert(File)(static_cast <bool> (File) ? void (0) : __assert_fail (
"File", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp"
, 3534, __extension__ __PRETTY_FUNCTION__))
;
3535 if (getDwarfVersion() < 5)
3536 return None;
3537 Optional<DIFile::ChecksumInfo<StringRef>> Checksum = File->getChecksum();
3538 if (!Checksum || Checksum->Kind != DIFile::CSK_MD5)
3539 return None;
3540
3541 // Convert the string checksum to an MD5Result for the streamer.
3542 // The verifier validates the checksum so we assume it's okay.
3543 // An MD5 checksum is 16 bytes.
3544 std::string ChecksumString = fromHex(Checksum->Value);
3545 MD5::MD5Result CKMem;
3546 std::copy(ChecksumString.begin(), ChecksumString.end(), CKMem.Bytes.data());
3547 return CKMem;
3548}