blob: ea94067964ecd8b8c336d26796ea1f58e544ec50 [file] [log] [blame]
Eugene Zelenko6e07bfd2017-08-17 21:26:39 +00001//===- llvm/CodeGen/DwarfCompileUnit.cpp - Dwarf Compile Units ------------===//
Paul Robinson34435752017-03-01 00:14:42 +00002//
Chandler Carruth2946cd72019-01-19 08:50:56 +00003// 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
Paul Robinson34435752017-03-01 00:14:42 +00006//
7//===----------------------------------------------------------------------===//
8//
9// This file contains support for constructing a dwarf compile unit.
10//
11//===----------------------------------------------------------------------===//
12
David Blaikie37c52312014-10-04 15:49:50 +000013#include "DwarfCompileUnit.h"
Eugene Zelenko6e07bfd2017-08-17 21:26:39 +000014#include "AddressPool.h"
15#include "DwarfDebug.h"
Adrian Prantl7813d9c2015-01-14 01:01:30 +000016#include "DwarfExpression.h"
Eugene Zelenko6e07bfd2017-08-17 21:26:39 +000017#include "DwarfUnit.h"
18#include "llvm/ADT/None.h"
19#include "llvm/ADT/STLExtras.h"
Markus Lavinb86ce212019-03-19 13:16:28 +000020#include "llvm/ADT/SmallString.h"
Eugene Zelenko6e07bfd2017-08-17 21:26:39 +000021#include "llvm/ADT/SmallVector.h"
22#include "llvm/ADT/StringRef.h"
23#include "llvm/BinaryFormat/Dwarf.h"
24#include "llvm/CodeGen/AsmPrinter.h"
25#include "llvm/CodeGen/DIE.h"
26#include "llvm/CodeGen/LexicalScopes.h"
David Blaikiecda2aa82014-10-04 16:24:00 +000027#include "llvm/CodeGen/MachineFunction.h"
Eugene Zelenko6e07bfd2017-08-17 21:26:39 +000028#include "llvm/CodeGen/MachineInstr.h"
29#include "llvm/CodeGen/MachineOperand.h"
David Blaikieb3bde2e2017-11-17 01:07:10 +000030#include "llvm/CodeGen/TargetFrameLowering.h"
David Blaikieb3bde2e2017-11-17 01:07:10 +000031#include "llvm/CodeGen/TargetRegisterInfo.h"
32#include "llvm/CodeGen/TargetSubtargetInfo.h"
David Blaikie37c52312014-10-04 15:49:50 +000033#include "llvm/IR/DataLayout.h"
Eugene Zelenko6e07bfd2017-08-17 21:26:39 +000034#include "llvm/IR/DebugInfo.h"
35#include "llvm/IR/DebugInfoMetadata.h"
David Blaikie37c52312014-10-04 15:49:50 +000036#include "llvm/IR/GlobalVariable.h"
Eugene Zelenko6e07bfd2017-08-17 21:26:39 +000037#include "llvm/MC/MCSection.h"
David Blaikie37c52312014-10-04 15:49:50 +000038#include "llvm/MC/MCStreamer.h"
Eugene Zelenko6e07bfd2017-08-17 21:26:39 +000039#include "llvm/MC/MCSymbol.h"
David Blaikieb3bde2e2017-11-17 01:07:10 +000040#include "llvm/MC/MachineLocation.h"
Eugene Zelenko6e07bfd2017-08-17 21:26:39 +000041#include "llvm/Support/Casting.h"
David Blaikie6054e652018-03-23 23:58:19 +000042#include "llvm/Target/TargetLoweringObjectFile.h"
David Blaikiecda2aa82014-10-04 16:24:00 +000043#include "llvm/Target/TargetMachine.h"
Eugene Zelenko6e07bfd2017-08-17 21:26:39 +000044#include "llvm/Target/TargetOptions.h"
Eugene Zelenko6e07bfd2017-08-17 21:26:39 +000045#include <algorithm>
46#include <cassert>
47#include <cstdint>
48#include <iterator>
49#include <memory>
50#include <string>
51#include <utility>
David Blaikie37c52312014-10-04 15:49:50 +000052
Eugene Zelenko6e07bfd2017-08-17 21:26:39 +000053using namespace llvm;
David Blaikie37c52312014-10-04 15:49:50 +000054
Alexey Lapshin789e2572019-11-30 23:48:32 +030055static dwarf::Tag GetCompileUnitType(UnitKind Kind, DwarfDebug *DW) {
56
57 // According to DWARF Debugging Information Format Version 5,
58 // 3.1.2 Skeleton Compilation Unit Entries:
59 // "When generating a split DWARF object file (see Section 7.3.2
60 // on page 187), the compilation unit in the .debug_info section
61 // is a "skeleton" compilation unit with the tag DW_TAG_skeleton_unit"
62 if (DW->getDwarfVersion() >= 5 && Kind == UnitKind::Skeleton)
63 return dwarf::DW_TAG_skeleton_unit;
64
65 return dwarf::DW_TAG_compile_unit;
66}
67
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +000068DwarfCompileUnit::DwarfCompileUnit(unsigned UID, const DICompileUnit *Node,
David Blaikie37c52312014-10-04 15:49:50 +000069 AsmPrinter *A, DwarfDebug *DW,
Alexey Lapshin789e2572019-11-30 23:48:32 +030070 DwarfFile *DWU, UnitKind Kind)
71 : DwarfUnit(GetCompileUnitType(Kind, DW), Node, A, DW, DWU), UniqueID(UID) {
David Blaikie37c52312014-10-04 15:49:50 +000072 insertDIE(Node, &getUnitDie());
Amjad Aboud8bbce8a2016-02-01 14:09:41 +000073 MacroLabelBegin = Asm->createTempSymbol("cu_macro_begin");
David Blaikie37c52312014-10-04 15:49:50 +000074}
75
76/// addLabelAddress - Add a dwarf label attribute data and value using
77/// DW_FORM_addr or DW_FORM_GNU_addr_index.
David Blaikie37c52312014-10-04 15:49:50 +000078void DwarfCompileUnit::addLabelAddress(DIE &Die, dwarf::Attribute Attribute,
79 const MCSymbol *Label) {
David Blaikie37c52312014-10-04 15:49:50 +000080 // Don't use the address pool in non-fission or in the skeleton unit itself.
David Blaikie161dd3c2018-10-20 06:02:15 +000081 if ((!DD->useSplitDwarf() || !Skeleton) && DD->getDwarfVersion() < 5)
David Blaikie37c52312014-10-04 15:49:50 +000082 return addLocalLabelAddress(Die, Attribute, Label);
83
84 if (Label)
85 DD->addArangeLabel(SymbolCU(this, Label));
86
87 unsigned idx = DD->getAddressPool().getIndex(Label);
David Blaikie161dd3c2018-10-20 06:02:15 +000088 Die.addValue(DIEValueAllocator, Attribute,
89 DD->getDwarfVersion() >= 5 ? dwarf::DW_FORM_addrx
90 : dwarf::DW_FORM_GNU_addr_index,
Duncan P. N. Exon Smith4fb1f9c2015-06-25 23:46:41 +000091 DIEInteger(idx));
David Blaikie37c52312014-10-04 15:49:50 +000092}
93
94void DwarfCompileUnit::addLocalLabelAddress(DIE &Die,
95 dwarf::Attribute Attribute,
96 const MCSymbol *Label) {
97 if (Label)
98 DD->addArangeLabel(SymbolCU(this, Label));
99
Duncan P. N. Exon Smith815a6eb52015-05-27 22:31:41 +0000100 if (Label)
Duncan P. N. Exon Smith4fb1f9c2015-06-25 23:46:41 +0000101 Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr,
102 DIELabel(Label));
Duncan P. N. Exon Smith815a6eb52015-05-27 22:31:41 +0000103 else
Duncan P. N. Exon Smith4fb1f9c2015-06-25 23:46:41 +0000104 Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr,
105 DIEInteger(0));
David Blaikie37c52312014-10-04 15:49:50 +0000106}
107
Paul Robinson612e89d2018-01-12 19:17:50 +0000108unsigned DwarfCompileUnit::getOrCreateSourceID(const DIFile *File) {
David Blaikie37c52312014-10-04 15:49:50 +0000109 // If we print assembly, we can't separate .file entries according to
110 // compile units. Thus all files will belong to the default compile unit.
111
112 // FIXME: add a better feature test than hasRawTextSupport. Even better,
113 // extend .file to support this.
Paul Robinson612e89d2018-01-12 19:17:50 +0000114 unsigned CUID = Asm->OutStreamer->hasRawTextSupport() ? 0 : getUniqueID();
115 if (!File)
Fangrui Song0bc77a02020-02-13 13:26:21 -0800116 return Asm->OutStreamer->emitDwarfFileDirective(0, "", "", None, None,
117 CUID);
118 return Asm->OutStreamer->emitDwarfFileDirective(
Scott Linder16c7bda2018-02-23 23:01:06 +0000119 0, File->getDirectory(), File->getFilename(), getMD5AsBytes(File),
120 File->getSource(), CUID);
David Blaikie37c52312014-10-04 15:49:50 +0000121}
122
Duncan P. N. Exon Smith60635e32015-04-21 18:44:06 +0000123DIE *DwarfCompileUnit::getOrCreateGlobalVariableDIE(
Adrian Prantlbceaaa92016-12-20 02:09:43 +0000124 const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) {
David Blaikie37c52312014-10-04 15:49:50 +0000125 // Check for pre-existence.
126 if (DIE *Die = getDIE(GV))
127 return Die;
128
Duncan P. N. Exon Smithe686f152015-04-06 23:27:40 +0000129 assert(GV);
David Blaikie37c52312014-10-04 15:49:50 +0000130
Duncan P. N. Exon Smithbe9e4fe2015-04-20 18:32:29 +0000131 auto *GVContext = GV->getScope();
Fangrui Songda82ce92019-05-07 02:06:37 +0000132 const DIType *GTy = GV->getType();
David Blaikie37c52312014-10-04 15:49:50 +0000133
David Blaikie49cfc8c2014-10-23 19:12:43 +0000134 // Construct the context before querying for the existence of the DIE in
135 // case such construction creates the DIE.
Adrian Prantl6ed57062019-04-08 19:13:55 +0000136 auto *CB = GVContext ? dyn_cast<DICommonBlock>(GVContext) : nullptr;
137 DIE *ContextDIE = CB ? getOrCreateCommonBlock(CB, GlobalExprs)
138 : getOrCreateContextDIE(GVContext);
David Blaikie49cfc8c2014-10-23 19:12:43 +0000139
Amjad Aboud72da9392016-04-30 01:44:07 +0000140 // Add to map.
141 DIE *VariableDIE = &createAndAddDIE(GV->getTag(), *ContextDIE, GV);
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000142 DIScope *DeclContext;
Duncan P. N. Exon Smithb1055642015-04-16 01:01:28 +0000143 if (auto *SDMDecl = GV->getStaticDataMemberDeclaration()) {
Fangrui Songda82ce92019-05-07 02:06:37 +0000144 DeclContext = SDMDecl->getScope();
Duncan P. N. Exon Smithb1055642015-04-16 01:01:28 +0000145 assert(SDMDecl->isStaticMember() && "Expected static member decl");
Duncan P. N. Exon Smith7348dda2015-04-14 02:22:36 +0000146 assert(GV->isDefinition());
David Blaikie37c52312014-10-04 15:49:50 +0000147 // We need the declaration DIE that is in the static member's class.
David Blaikie49cfc8c2014-10-23 19:12:43 +0000148 DIE *VariableSpecDIE = getOrCreateStaticMemberDIE(SDMDecl);
149 addDIEEntry(*VariableDIE, dwarf::DW_AT_specification, *VariableSpecDIE);
Adrian Prantl3502f202016-11-08 22:11:38 +0000150 // If the global variable's type is different from the one in the class
151 // member type, assume that it's more specific and also emit it.
Fangrui Songda82ce92019-05-07 02:06:37 +0000152 if (GTy != SDMDecl->getBaseType())
Adrian Prantl3502f202016-11-08 22:11:38 +0000153 addType(*VariableDIE, GTy);
David Blaikie49cfc8c2014-10-23 19:12:43 +0000154 } else {
Duncan P. N. Exon Smith7348dda2015-04-14 02:22:36 +0000155 DeclContext = GV->getScope();
David Blaikie37c52312014-10-04 15:49:50 +0000156 // Add name and type.
Duncan P. N. Exon Smith7348dda2015-04-14 02:22:36 +0000157 addString(*VariableDIE, dwarf::DW_AT_name, GV->getDisplayName());
David Blaikie37c52312014-10-04 15:49:50 +0000158 addType(*VariableDIE, GTy);
159
160 // Add scoping info.
Duncan P. N. Exon Smith7348dda2015-04-14 02:22:36 +0000161 if (!GV->isLocalToUnit())
David Blaikie37c52312014-10-04 15:49:50 +0000162 addFlag(*VariableDIE, dwarf::DW_AT_external);
163
164 // Add line number info.
165 addSourceLine(*VariableDIE, GV);
166 }
167
Duncan P. N. Exon Smith7348dda2015-04-14 02:22:36 +0000168 if (!GV->isDefinition())
David Blaikie49cfc8c2014-10-23 19:12:43 +0000169 addFlag(*VariableDIE, dwarf::DW_AT_declaration);
David Blaikie877354a2015-04-14 18:08:25 +0000170 else
171 addGlobalName(GV->getName(), *VariableDIE, DeclContext);
David Blaikie49cfc8c2014-10-23 19:12:43 +0000172
Victor Leschuk3c989982016-10-26 11:59:03 +0000173 if (uint32_t AlignInBytes = GV->getAlignInBytes())
174 addUInt(*VariableDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
175 AlignInBytes);
176
Matthew Vossf8ab35a2018-10-03 18:44:53 +0000177 if (MDTuple *TP = GV->getTemplateParams())
178 addTemplateParams(*VariableDIE, DINodeArray(TP));
179
David Blaikie37c52312014-10-04 15:49:50 +0000180 // Add location.
Adrian Prantl6ed57062019-04-08 19:13:55 +0000181 addLocationAttribute(VariableDIE, GV, GlobalExprs);
182
183 return VariableDIE;
184}
185
186void DwarfCompileUnit::addLocationAttribute(
187 DIE *VariableDIE, const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) {
David Blaikie37c52312014-10-04 15:49:50 +0000188 bool addToAccelTable = false;
Adrian Prantlbceaaa92016-12-20 02:09:43 +0000189 DIELoc *Loc = nullptr;
Alexey Bataevf3a91502019-02-05 19:33:47 +0000190 Optional<unsigned> NVPTXAddressSpace;
Adrian Prantlbceaaa92016-12-20 02:09:43 +0000191 std::unique_ptr<DIEDwarfExpression> DwarfExpr;
Adrian Prantlbceaaa92016-12-20 02:09:43 +0000192 for (const auto &GE : GlobalExprs) {
193 const GlobalVariable *Global = GE.Var;
194 const DIExpression *Expr = GE.Expr;
Adrian Prantlb216e3e2017-03-23 23:35:09 +0000195
Adrian Prantlbceaaa92016-12-20 02:09:43 +0000196 // For compatibility with DWARF 3 and earlier,
197 // DW_AT_location(DW_OP_constu, X, DW_OP_stack_value) becomes
198 // DW_AT_const_value(X).
199 if (GlobalExprs.size() == 1 && Expr && Expr->isConstant()) {
Adrian Prantlbceaaa92016-12-20 02:09:43 +0000200 addToAccelTable = true;
Adrian Prantlb216e3e2017-03-23 23:35:09 +0000201 addConstantValue(*VariableDIE, /*Unsigned=*/true, Expr->getElement(1));
202 break;
203 }
204
205 // We cannot describe the location of dllimport'd variables: the
206 // computation of their address requires loads from the IAT.
207 if (Global && Global->hasDLLImportStorageClass())
208 continue;
209
210 // Nothing to describe without address or constant.
211 if (!Global && (!Expr || !Expr->isConstant()))
212 continue;
213
Lei Liu8e422b82018-08-01 23:46:49 +0000214 if (Global && Global->isThreadLocal() &&
215 !Asm->getObjFileLowering().supportDebugThreadLocalLocation())
216 continue;
217
Adrian Prantlb216e3e2017-03-23 23:35:09 +0000218 if (!Loc) {
219 addToAccelTable = true;
220 Loc = new (DIEValueAllocator) DIELoc;
Jonas Devlieghere0eaee542019-08-15 15:54:37 +0000221 DwarfExpr = std::make_unique<DIEDwarfExpression>(*Asm, *this, *Loc);
Adrian Prantlb216e3e2017-03-23 23:35:09 +0000222 }
223
Alexey Bataevf3a91502019-02-05 19:33:47 +0000224 if (Expr) {
225 // According to
226 // https://docs.nvidia.com/cuda/archive/10.0/ptx-writers-guide-to-interoperability/index.html#cuda-specific-dwarf
227 // cuda-gdb requires DW_AT_address_class for all variables to be able to
228 // correctly interpret address space of the variable address.
229 // Decode DW_OP_constu <DWARF Address Space> DW_OP_swap DW_OP_xderef
230 // sequence for the NVPTX + gdb target.
231 unsigned LocalNVPTXAddressSpace;
232 if (Asm->TM.getTargetTriple().isNVPTX() && DD->tuneForGDB()) {
233 const DIExpression *NewExpr =
234 DIExpression::extractAddressClass(Expr, LocalNVPTXAddressSpace);
235 if (NewExpr != Expr) {
236 Expr = NewExpr;
237 NVPTXAddressSpace = LocalNVPTXAddressSpace;
238 }
239 }
Mikael Holmena9e31532018-01-29 12:37:30 +0000240 DwarfExpr->addFragmentOffset(Expr);
Alexey Bataevf3a91502019-02-05 19:33:47 +0000241 }
Mikael Holmena9e31532018-01-29 12:37:30 +0000242
Adrian Prantlb216e3e2017-03-23 23:35:09 +0000243 if (Global) {
244 const MCSymbol *Sym = Asm->getSymbol(Global);
245 if (Global->isThreadLocal()) {
Chih-Hung Hsieh9f9e4682018-02-28 17:48:55 +0000246 if (Asm->TM.useEmulatedTLS()) {
Adrian Prantlb216e3e2017-03-23 23:35:09 +0000247 // TODO: add debug info for emulated thread local mode.
Adrian Prantlbceaaa92016-12-20 02:09:43 +0000248 } else {
Adrian Prantlb216e3e2017-03-23 23:35:09 +0000249 // FIXME: Make this work with -gsplit-dwarf.
250 unsigned PointerSize = Asm->getDataLayout().getPointerSize();
251 assert((PointerSize == 4 || PointerSize == 8) &&
252 "Add support for other sizes if necessary");
253 // Based on GCC's support for TLS:
254 if (!DD->useSplitDwarf()) {
255 // 1) Start with a constNu of the appropriate pointer size
256 addUInt(*Loc, dwarf::DW_FORM_data1,
257 PointerSize == 4 ? dwarf::DW_OP_const4u
258 : dwarf::DW_OP_const8u);
259 // 2) containing the (relocated) offset of the TLS variable
260 // within the module's TLS block.
261 addExpr(*Loc, dwarf::DW_FORM_udata,
262 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym));
263 } else {
264 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
265 addUInt(*Loc, dwarf::DW_FORM_udata,
266 DD->getAddressPool().getIndex(Sym, /* TLS */ true));
267 }
268 // 3) followed by an OP to make the debugger do a TLS lookup.
269 addUInt(*Loc, dwarf::DW_FORM_data1,
270 DD->useGNUTLSOpcode() ? dwarf::DW_OP_GNU_push_tls_address
271 : dwarf::DW_OP_form_tls_address);
Adrian Prantlbceaaa92016-12-20 02:09:43 +0000272 }
Adrian Prantlb216e3e2017-03-23 23:35:09 +0000273 } else {
274 DD->addArangeLabel(SymbolCU(this, Sym));
275 addOpAddress(*Loc, Sym);
Adrian Prantlbceaaa92016-12-20 02:09:43 +0000276 }
Adrian Prantlb216e3e2017-03-23 23:35:09 +0000277 }
Adrian Prantl4b542c62018-04-27 22:05:31 +0000278 // Global variables attached to symbols are memory locations.
279 // It would be better if this were unconditional, but malformed input that
280 // mixes non-fragments and fragments for the same variable is too expensive
281 // to detect in the verifier.
Adrian Prantl3edc63a2018-05-04 16:10:43 +0000282 if (DwarfExpr->isUnknownLocation())
Adrian Prantl4b542c62018-04-27 22:05:31 +0000283 DwarfExpr->setMemoryLocationKind();
284 DwarfExpr->addExpression(Expr);
Adrian Prantl73ec0652016-12-16 19:39:01 +0000285 }
Alexey Bataevf3a91502019-02-05 19:33:47 +0000286 if (Asm->TM.getTargetTriple().isNVPTX() && DD->tuneForGDB()) {
287 // According to
288 // https://docs.nvidia.com/cuda/archive/10.0/ptx-writers-guide-to-interoperability/index.html#cuda-specific-dwarf
289 // cuda-gdb requires DW_AT_address_class for all variables to be able to
290 // correctly interpret address space of the variable address.
291 const unsigned NVPTX_ADDR_global_space = 5;
292 addUInt(*VariableDIE, dwarf::DW_AT_address_class, dwarf::DW_FORM_data1,
293 NVPTXAddressSpace ? *NVPTXAddressSpace : NVPTX_ADDR_global_space);
294 }
Adrian Prantlbceaaa92016-12-20 02:09:43 +0000295 if (Loc)
296 addBlock(*VariableDIE, dwarf::DW_AT_location, DwarfExpr->finalize());
297
298 if (DD->useAllLinkageNames())
299 addLinkageName(*VariableDIE, GV->getLinkageName());
David Blaikie37c52312014-10-04 15:49:50 +0000300
David Blaikie37c52312014-10-04 15:49:50 +0000301 if (addToAccelTable) {
David Blaikie66cf14d2018-08-16 21:29:55 +0000302 DD->addAccelName(*CUNode, GV->getName(), *VariableDIE);
David Blaikie37c52312014-10-04 15:49:50 +0000303
304 // If the linkage name is different than the name, go ahead and output
305 // that as well into the name table.
Pavel Labath2a6afe52018-05-14 14:13:20 +0000306 if (GV->getLinkageName() != "" && GV->getName() != GV->getLinkageName() &&
307 DD->useAllLinkageNames())
David Blaikie66cf14d2018-08-16 21:29:55 +0000308 DD->addAccelName(*CUNode, GV->getLinkageName(), *VariableDIE);
David Blaikie37c52312014-10-04 15:49:50 +0000309 }
Adrian Prantl6ed57062019-04-08 19:13:55 +0000310}
David Blaikie37c52312014-10-04 15:49:50 +0000311
Adrian Prantl6ed57062019-04-08 19:13:55 +0000312DIE *DwarfCompileUnit::getOrCreateCommonBlock(
313 const DICommonBlock *CB, ArrayRef<GlobalExpr> GlobalExprs) {
314 // Construct the context before querying for the existence of the DIE in case
315 // such construction creates the DIE.
316 DIE *ContextDIE = getOrCreateContextDIE(CB->getScope());
317
318 if (DIE *NDie = getDIE(CB))
319 return NDie;
320 DIE &NDie = createAndAddDIE(dwarf::DW_TAG_common_block, *ContextDIE, CB);
321 StringRef Name = CB->getName().empty() ? "_BLNK_" : CB->getName();
322 addString(NDie, dwarf::DW_AT_name, Name);
323 addGlobalName(Name, NDie, CB->getScope());
324 if (CB->getFile())
325 addSourceLine(NDie, CB->getLineNo(), CB->getFile());
326 if (DIGlobalVariable *V = CB->getDecl())
327 getCU().addLocationAttribute(&NDie, V, GlobalExprs);
328 return &NDie;
David Blaikie37c52312014-10-04 15:49:50 +0000329}
330
331void DwarfCompileUnit::addRange(RangeSpan Range) {
David Blaikie58b10df2020-01-17 18:12:34 -0800332 DD->insertSectionLabel(Range.Begin);
333
David Blaikie37c52312014-10-04 15:49:50 +0000334 bool SameAsPrevCU = this == DD->getPrevCU();
335 DD->setPrevCU(this);
336 // If we have no current ranges just add the range and return, otherwise,
337 // check the current section and CU against the previous section and CU we
338 // emitted into and the subprogram was contained within. If these are the
339 // same then extend our current range, otherwise add this as a new range.
340 if (CURanges.empty() || !SameAsPrevCU ||
David Blaikieb677cb8d2019-10-02 22:27:24 +0000341 (&CURanges.back().End->getSection() !=
342 &Range.End->getSection())) {
David Blaikie37c52312014-10-04 15:49:50 +0000343 CURanges.push_back(Range);
344 return;
345 }
346
David Blaikieb677cb8d2019-10-02 22:27:24 +0000347 CURanges.back().End = Range.End;
David Blaikie37c52312014-10-04 15:49:50 +0000348}
349
Rafael Espindola063d7252015-03-10 16:58:10 +0000350void DwarfCompileUnit::initStmtList() {
Alexey Bataevd4dd7212018-08-01 19:38:20 +0000351 if (CUNode->isDebugDirectivesOnly())
352 return;
353
David Blaikie37c52312014-10-04 15:49:50 +0000354 // Define start line table label for each Compile Unit.
Alexey Bataevbff36082018-03-23 13:35:54 +0000355 MCSymbol *LineTableStartSym;
356 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
357 if (DD->useSectionsAsReferences()) {
358 LineTableStartSym = TLOF.getDwarfLineSection()->getBeginSymbol();
359 } else {
360 LineTableStartSym =
361 Asm->OutStreamer->getDwarfLineTableSymbol(getUniqueID());
362 }
David Blaikie37c52312014-10-04 15:49:50 +0000363
David Blaikie37c52312014-10-04 15:49:50 +0000364 // DW_AT_stmt_list is a offset of line number information for this
365 // compile unit in debug_line section. For split dwarf this is
366 // left in the skeleton CU and so not included.
367 // The line table entries are not always emitted in assembly, so it
368 // is not okay to use line_table_start here.
Duncan P. N. Exon Smith4fb1f9c2015-06-25 23:46:41 +0000369 StmtListValue =
Greg Clayton35630c32016-12-01 18:56:29 +0000370 addSectionLabel(getUnitDie(), dwarf::DW_AT_stmt_list, LineTableStartSym,
Duncan P. N. Exon Smith4fb1f9c2015-06-25 23:46:41 +0000371 TLOF.getDwarfLineSection()->getBeginSymbol());
David Blaikie37c52312014-10-04 15:49:50 +0000372}
373
374void DwarfCompileUnit::applyStmtList(DIE &D) {
Duncan P. N. Exon Smith4fb1f9c2015-06-25 23:46:41 +0000375 D.addValue(DIEValueAllocator, *StmtListValue);
David Blaikie37c52312014-10-04 15:49:50 +0000376}
377
David Blaikie14499a72014-10-04 15:58:47 +0000378void DwarfCompileUnit::attachLowHighPC(DIE &D, const MCSymbol *Begin,
379 const MCSymbol *End) {
380 assert(Begin && "Begin label should not be null!");
381 assert(End && "End label should not be null!");
382 assert(Begin->isDefined() && "Invalid starting label");
383 assert(End->isDefined() && "Invalid end label");
384
385 addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
386 if (DD->getDwarfVersion() < 4)
387 addLabelAddress(D, dwarf::DW_AT_high_pc, End);
388 else
389 addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);
390}
391
David Blaikiecda2aa82014-10-04 16:24:00 +0000392// Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
393// and DW_AT_high_pc attributes. If there are global variables in this
394// scope then create and insert DIEs for these variables.
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000395DIE &DwarfCompileUnit::updateSubprogramScopeDIE(const DISubprogram *SP) {
David Blaikie3a443c22014-11-04 22:12:25 +0000396 DIE *SPDie = getOrCreateSubprogramDIE(SP, includeMinimalInlineScopes());
David Blaikiecda2aa82014-10-04 16:24:00 +0000397
Rafael Espindola07c03d32015-03-05 02:05:42 +0000398 attachLowHighPC(*SPDie, Asm->getFunctionBegin(), Asm->getFunctionEnd());
David Blaikiec53e18d2016-05-24 21:19:28 +0000399 if (DD->useAppleExtensionAttributes() &&
400 !DD->getCurrentFunction()->getTarget().Options.DisableFramePointerElim(
David Blaikiecda2aa82014-10-04 16:24:00 +0000401 *DD->getCurrentFunction()))
402 addFlag(*SPDie, dwarf::DW_AT_APPLE_omit_frame_ptr);
403
404 // Only include DW_AT_frame_base in full debug info
David Blaikie3a443c22014-11-04 22:12:25 +0000405 if (!includeMinimalInlineScopes()) {
Derek Schuffff171ac2019-12-18 14:50:19 -0800406 const TargetFrameLowering *TFI = Asm->MF->getSubtarget().getFrameLowering();
407 TargetFrameLowering::DwarfFrameBase FrameBase =
408 TFI->getDwarfFrameBase(*Asm->MF);
409 switch (FrameBase.Kind) {
410 case TargetFrameLowering::DwarfFrameBase::Register: {
411 if (Register::isPhysicalRegister(FrameBase.Location.Reg)) {
412 MachineLocation Location(FrameBase.Location.Reg);
413 addAddress(*SPDie, dwarf::DW_AT_frame_base, Location);
414 }
415 break;
416 }
417 case TargetFrameLowering::DwarfFrameBase::CFA: {
Alexey Bataev7ae86fe2018-07-26 16:10:05 +0000418 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
419 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_call_frame_cfa);
420 addBlock(*SPDie, dwarf::DW_AT_frame_base, Loc);
Derek Schuffff171ac2019-12-18 14:50:19 -0800421 break;
422 }
423 case TargetFrameLowering::DwarfFrameBase::WasmFrameBase: {
424 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
425 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
426 DIExpressionCursor Cursor({});
427 DwarfExpr.addWasmLocation(FrameBase.Location.WasmLoc.Kind,
428 FrameBase.Location.WasmLoc.Index);
429 DwarfExpr.addExpression(std::move(Cursor));
430 addBlock(*SPDie, dwarf::DW_AT_frame_base, DwarfExpr.finalize());
431 break;
432 }
Alexey Bataev7ae86fe2018-07-26 16:10:05 +0000433 }
David Blaikiecda2aa82014-10-04 16:24:00 +0000434 }
435
436 // Add name to the name table, we do this here because we're guaranteed
437 // to have concrete versions of our DW_TAG_subprogram nodes.
David Blaikie66cf14d2018-08-16 21:29:55 +0000438 DD->addSubprogramNames(*CUNode, SP, *SPDie);
David Blaikiecda2aa82014-10-04 16:24:00 +0000439
440 return *SPDie;
441}
442
David Blaikie9c65b132014-10-08 22:20:02 +0000443// Construct a DIE for this scope.
444void DwarfCompileUnit::constructScopeDIE(
Duncan P. N. Exon Smith827200c2015-06-25 23:52:10 +0000445 LexicalScope *Scope, SmallVectorImpl<DIE *> &FinalChildren) {
David Blaikie9c65b132014-10-08 22:20:02 +0000446 if (!Scope || !Scope->getScopeNode())
447 return;
448
Duncan P. N. Exon Smithbe9e4fe2015-04-20 18:32:29 +0000449 auto *DS = Scope->getScopeNode();
David Blaikie9c65b132014-10-08 22:20:02 +0000450
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000451 assert((Scope->getInlinedAt() || !isa<DISubprogram>(DS)) &&
David Blaikie9c65b132014-10-08 22:20:02 +0000452 "Only handle inlined subprograms here, use "
453 "constructSubprogramScopeDIE for non-inlined "
454 "subprograms");
455
Duncan P. N. Exon Smith827200c2015-06-25 23:52:10 +0000456 SmallVector<DIE *, 8> Children;
David Blaikie9c65b132014-10-08 22:20:02 +0000457
458 // We try to create the scope DIE first, then the children DIEs. This will
459 // avoid creating un-used children then removing them later when we find out
460 // the scope DIE is null.
Duncan P. N. Exon Smith827200c2015-06-25 23:52:10 +0000461 DIE *ScopeDIE;
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000462 if (Scope->getParent() && isa<DISubprogram>(DS)) {
David Blaikie01b48a82014-10-09 16:50:53 +0000463 ScopeDIE = constructInlinedScopeDIE(Scope);
David Blaikie9c65b132014-10-08 22:20:02 +0000464 if (!ScopeDIE)
465 return;
466 // We create children when the scope DIE is not null.
David Blaikie8b2fdb82014-10-09 18:24:28 +0000467 createScopeChildrenDIE(Scope, Children);
David Blaikie9c65b132014-10-08 22:20:02 +0000468 } else {
469 // Early exit when we know the scope DIE is going to be null.
470 if (DD->isLexicalScopeDIENull(Scope))
471 return;
472
David Blaikie2195e132017-07-27 00:06:53 +0000473 bool HasNonScopeChildren = false;
David Blaikie9c65b132014-10-08 22:20:02 +0000474
475 // We create children here when we know the scope DIE is not going to be
476 // null and the children will be added to the scope DIE.
David Blaikie2195e132017-07-27 00:06:53 +0000477 createScopeChildrenDIE(Scope, Children, &HasNonScopeChildren);
David Blaikie3a443c22014-11-04 22:12:25 +0000478
David Blaikie9c65b132014-10-08 22:20:02 +0000479 // If there are only other scopes as children, put them directly in the
480 // parent instead, as this scope would serve no purpose.
David Blaikie2195e132017-07-27 00:06:53 +0000481 if (!HasNonScopeChildren) {
David Blaikie9c65b132014-10-08 22:20:02 +0000482 FinalChildren.insert(FinalChildren.end(),
483 std::make_move_iterator(Children.begin()),
484 std::make_move_iterator(Children.end()));
485 return;
486 }
David Blaikie0fbf8bd2014-10-09 17:08:42 +0000487 ScopeDIE = constructLexicalScopeDIE(Scope);
David Blaikie9c65b132014-10-08 22:20:02 +0000488 assert(ScopeDIE && "Scope DIE should not be null.");
489 }
490
491 // Add children
492 for (auto &I : Children)
493 ScopeDIE->addChild(std::move(I));
494
495 FinalChildren.push_back(std::move(ScopeDIE));
496}
497
David Blaikie5b02a192014-11-03 23:10:59 +0000498void DwarfCompileUnit::addScopeRangeList(DIE &ScopeDIE,
499 SmallVector<RangeSpan, 2> Range) {
David Blaikie52400202014-10-09 00:11:39 +0000500
David Blaikiec4af8bf2018-10-20 07:36:39 +0000501 HasRangeLists = true;
502
503 // Add the range list to the set of ranges to be emitted.
504 auto IndexAndList =
505 (DD->getDwarfVersion() < 5 && Skeleton ? Skeleton->DU : DU)
David Blaikiec8f7e6c2018-11-08 00:35:54 +0000506 ->addRange(*(Skeleton ? Skeleton : this), std::move(Range));
David Blaikiec4af8bf2018-10-20 07:36:39 +0000507
508 uint32_t Index = IndexAndList.first;
509 auto &List = *IndexAndList.second;
David Blaikie5b02a192014-11-03 23:10:59 +0000510
David Blaikie52400202014-10-09 00:11:39 +0000511 // Under fission, ranges are specified by constant offsets relative to the
512 // CU's DW_AT_GNU_ranges_base.
Wolfgang Piebfcf38102018-07-12 18:18:21 +0000513 // FIXME: For DWARF v5, do not generate the DW_AT_ranges attribute under
514 // fission until we support the forms using the .debug_addr section
515 // (DW_RLE_startx_endx etc.).
David Blaikie32e09de2018-10-20 08:12:36 +0000516 if (DD->getDwarfVersion() >= 5)
517 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_rnglistx, Index);
David Blaikiede9aa372019-10-11 23:51:24 +0000518 else {
519 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
520 const MCSymbol *RangeSectionSym =
521 TLOF.getDwarfRangesSection()->getBeginSymbol();
522 if (isDwoUnit())
David Blaikie64fa76e2019-12-16 15:19:25 -0800523 addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, List.Label,
David Blaikiede9aa372019-10-11 23:51:24 +0000524 RangeSectionSym);
525 else
David Blaikie64fa76e2019-12-16 15:19:25 -0800526 addSectionLabel(ScopeDIE, dwarf::DW_AT_ranges, List.Label,
David Blaikiede9aa372019-10-11 23:51:24 +0000527 RangeSectionSym);
528 }
David Blaikie52400202014-10-09 00:11:39 +0000529}
530
David Blaikiede123752014-10-09 00:21:42 +0000531void DwarfCompileUnit::attachRangesOrLowHighPC(
David Blaikie5b02a192014-11-03 23:10:59 +0000532 DIE &Die, SmallVector<RangeSpan, 2> Ranges) {
Alexey Bataev858a7dd2018-03-20 20:21:38 +0000533 if (Ranges.size() == 1 || !DD->useRangesSection()) {
534 const RangeSpan &Front = Ranges.front();
535 const RangeSpan &Back = Ranges.back();
David Blaikieb677cb8d2019-10-02 22:27:24 +0000536 attachLowHighPC(Die, Front.Begin, Back.End);
David Blaikie5b02a192014-11-03 23:10:59 +0000537 } else
538 addScopeRangeList(Die, std::move(Ranges));
539}
540
541void DwarfCompileUnit::attachRangesOrLowHighPC(
David Blaikiede123752014-10-09 00:21:42 +0000542 DIE &Die, const SmallVectorImpl<InsnRange> &Ranges) {
David Blaikie5b02a192014-11-03 23:10:59 +0000543 SmallVector<RangeSpan, 2> List;
544 List.reserve(Ranges.size());
545 for (const InsnRange &R : Ranges)
David Blaikieb677cb8d2019-10-02 22:27:24 +0000546 List.push_back(
547 {DD->getLabelBeforeInsn(R.first), DD->getLabelAfterInsn(R.second)});
David Blaikie5b02a192014-11-03 23:10:59 +0000548 attachRangesOrLowHighPC(Die, std::move(List));
David Blaikiede123752014-10-09 00:21:42 +0000549}
550
David Blaikie01b48a82014-10-09 16:50:53 +0000551// This scope represents inlined body of a function. Construct DIE to
552// represent this concrete inlined copy of the function.
Duncan P. N. Exon Smith827200c2015-06-25 23:52:10 +0000553DIE *DwarfCompileUnit::constructInlinedScopeDIE(LexicalScope *Scope) {
David Blaikie01b48a82014-10-09 16:50:53 +0000554 assert(Scope->getScopeNode());
Duncan P. N. Exon Smithbe9e4fe2015-04-20 18:32:29 +0000555 auto *DS = Scope->getScopeNode();
556 auto *InlinedSP = getDISubprogram(DS);
David Blaikie01b48a82014-10-09 16:50:53 +0000557 // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
558 // was inlined from another compile unit.
David Blaikie488393f2017-05-12 01:13:45 +0000559 DIE *OriginDIE = getAbstractSPDies()[InlinedSP];
David Blaikie01b48a82014-10-09 16:50:53 +0000560 assert(OriginDIE && "Unable to find original DIE for an inlined subprogram.");
561
Duncan P. N. Exon Smith827200c2015-06-25 23:52:10 +0000562 auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_inlined_subroutine);
David Blaikie01b48a82014-10-09 16:50:53 +0000563 addDIEEntry(*ScopeDIE, dwarf::DW_AT_abstract_origin, *OriginDIE);
564
565 attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges());
566
567 // Add the call site information to the DIE.
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000568 const DILocation *IA = Scope->getInlinedAt();
David Blaikie01b48a82014-10-09 16:50:53 +0000569 addUInt(*ScopeDIE, dwarf::DW_AT_call_file, None,
Paul Robinson612e89d2018-01-12 19:17:50 +0000570 getOrCreateSourceID(IA->getFile()));
Duncan P. N. Exon Smithb7e221b2015-04-14 01:35:55 +0000571 addUInt(*ScopeDIE, dwarf::DW_AT_call_line, None, IA->getLine());
David Blaikie40580d32019-07-16 21:15:19 +0000572 if (IA->getColumn())
573 addUInt(*ScopeDIE, dwarf::DW_AT_call_column, None, IA->getColumn());
Dehao Chen6e0c8442016-10-07 15:21:31 +0000574 if (IA->getDiscriminator() && DD->getDwarfVersion() >= 4)
Dehao Chen54511352015-11-11 18:09:47 +0000575 addUInt(*ScopeDIE, dwarf::DW_AT_GNU_discriminator, None,
576 IA->getDiscriminator());
David Blaikie01b48a82014-10-09 16:50:53 +0000577
578 // Add name to the name table, we do this here because we're guaranteed
579 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
David Blaikie66cf14d2018-08-16 21:29:55 +0000580 DD->addSubprogramNames(*CUNode, InlinedSP, *ScopeDIE);
David Blaikie01b48a82014-10-09 16:50:53 +0000581
582 return ScopeDIE;
583}
584
David Blaikie0fbf8bd2014-10-09 17:08:42 +0000585// Construct new DW_TAG_lexical_block for this scope and attach
586// DW_AT_low_pc/DW_AT_high_pc labels.
Duncan P. N. Exon Smith827200c2015-06-25 23:52:10 +0000587DIE *DwarfCompileUnit::constructLexicalScopeDIE(LexicalScope *Scope) {
David Blaikie0fbf8bd2014-10-09 17:08:42 +0000588 if (DD->isLexicalScopeDIENull(Scope))
589 return nullptr;
590
Duncan P. N. Exon Smith827200c2015-06-25 23:52:10 +0000591 auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_lexical_block);
David Blaikie0fbf8bd2014-10-09 17:08:42 +0000592 if (Scope->isAbstractScope())
593 return ScopeDIE;
594
595 attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges());
596
597 return ScopeDIE;
598}
599
David Blaikieee7df552014-10-09 17:56:36 +0000600/// constructVariableDIE - Construct a DIE for the given DbgVariable.
Duncan P. N. Exon Smith827200c2015-06-25 23:52:10 +0000601DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV, bool Abstract) {
David Blaikieee7df552014-10-09 17:56:36 +0000602 auto D = constructVariableDIEImpl(DV, Abstract);
603 DV.setDIE(*D);
604 return D;
605}
606
Hsiangkai Wang2532ac82018-08-17 15:22:04 +0000607DIE *DwarfCompileUnit::constructLabelDIE(DbgLabel &DL,
608 const LexicalScope &Scope) {
609 auto LabelDie = DIE::get(DIEValueAllocator, DL.getTag());
610 insertDIE(DL.getLabel(), LabelDie);
611 DL.setDIE(*LabelDie);
612
613 if (Scope.isAbstractScope())
614 applyLabelAttributes(DL, *LabelDie);
615
616 return LabelDie;
617}
618
Duncan P. N. Exon Smith827200c2015-06-25 23:52:10 +0000619DIE *DwarfCompileUnit::constructVariableDIEImpl(const DbgVariable &DV,
620 bool Abstract) {
David Blaikieee7df552014-10-09 17:56:36 +0000621 // Define variable debug information entry.
Duncan P. N. Exon Smith827200c2015-06-25 23:52:10 +0000622 auto VariableDie = DIE::get(DIEValueAllocator, DV.getTag());
Sander de Smalendc00bec2018-01-24 13:35:54 +0000623 insertDIE(DV.getVariable(), VariableDie);
David Blaikieee7df552014-10-09 17:56:36 +0000624
625 if (Abstract) {
626 applyVariableAttributes(DV, *VariableDie);
627 return VariableDie;
628 }
629
630 // Add variable address.
631
Duncan P. N. Exon Smith364a3002015-04-17 21:34:47 +0000632 unsigned Offset = DV.getDebugLocListIndex();
David Blaikieee7df552014-10-09 17:56:36 +0000633 if (Offset != ~0U) {
634 addLocationList(*VariableDie, dwarf::DW_AT_location, Offset);
Evgenii Stepanovdabd2622019-11-25 17:47:30 -0800635 auto TagOffset = DV.getDebugLocListTagOffset();
636 if (TagOffset)
637 addUInt(*VariableDie, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1,
638 *TagOffset);
David Blaikieee7df552014-10-09 17:56:36 +0000639 return VariableDie;
640 }
641
Nikola Pricaabc1dff2019-06-10 08:41:06 +0000642 // Check if variable has a single location description.
643 if (auto *DVal = DV.getValueLoc()) {
644 if (DVal->isLocation())
645 addVariableAddress(DV, *VariableDie, DVal->getLoc());
646 else if (DVal->isInt()) {
Adrian Prantl3b89e662016-02-17 22:20:08 +0000647 auto *Expr = DV.getSingleExpression();
648 if (Expr && Expr->getNumElements()) {
649 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
650 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
651 // If there is an expression, emit raw unsigned bytes.
Adrian Prantl8fafb8d2016-12-09 20:43:40 +0000652 DwarfExpr.addFragmentOffset(Expr);
Nikola Pricaabc1dff2019-06-10 08:41:06 +0000653 DwarfExpr.addUnsignedConstant(DVal->getInt());
Adrian Prantla63b8e82017-03-16 17:42:45 +0000654 DwarfExpr.addExpression(Expr);
Adrian Prantlbceaaa92016-12-20 02:09:43 +0000655 addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize());
Evgenii Stepanovdabd2622019-11-25 17:47:30 -0800656 if (DwarfExpr.TagOffset)
657 addUInt(*VariableDie, dwarf::DW_AT_LLVM_tag_offset,
658 dwarf::DW_FORM_data1, *DwarfExpr.TagOffset);
659
Adrian Prantl3b89e662016-02-17 22:20:08 +0000660 } else
Nikola Pricaabc1dff2019-06-10 08:41:06 +0000661 addConstantValue(*VariableDie, DVal->getInt(), DV.getType());
662 } else if (DVal->isConstantFP()) {
663 addConstantFPValue(*VariableDie, DVal->getConstantFP());
664 } else if (DVal->isConstantInt()) {
665 addConstantValue(*VariableDie, DVal->getConstantInt(), DV.getType());
666 }
David Blaikieee7df552014-10-09 17:56:36 +0000667 return VariableDie;
668 }
669
670 // .. else use frame index.
Adrian Prantl67c24422017-02-17 19:42:32 +0000671 if (!DV.hasFrameIndexExprs())
Adrian Prantlca7e4702015-02-10 23:18:28 +0000672 return VariableDie;
673
Alexey Bataevf3a91502019-02-05 19:33:47 +0000674 Optional<unsigned> NVPTXAddressSpace;
Duncan P. N. Exon Smithe7e1d0c2015-05-27 22:14:58 +0000675 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
Adrian Prantlca7e4702015-02-10 23:18:28 +0000676 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
Adrian Prantl67c24422017-02-17 19:42:32 +0000677 for (auto &Fragment : DV.getFrameIndexExprs()) {
David Blaikieee7df552014-10-09 17:56:36 +0000678 unsigned FrameReg = 0;
Adrian Prantl6825fb62017-04-18 01:21:53 +0000679 const DIExpression *Expr = Fragment.Expr;
Eric Christopherd4e723f2015-02-20 22:36:11 +0000680 const TargetFrameLowering *TFI = Asm->MF->getSubtarget().getFrameLowering();
Adrian Prantl67c24422017-02-17 19:42:32 +0000681 int Offset = TFI->getFrameIndexReference(*Asm->MF, Fragment.FI, FrameReg);
Adrian Prantl6825fb62017-04-18 01:21:53 +0000682 DwarfExpr.addFragmentOffset(Expr);
Adrian Prantl956484b2017-03-20 21:35:09 +0000683 SmallVector<uint64_t, 8> Ops;
Bjorn Pettersson2b698a12019-09-07 11:40:10 +0000684 DIExpression::appendOffset(Ops, Offset);
Alexey Bataevf3a91502019-02-05 19:33:47 +0000685 // According to
686 // https://docs.nvidia.com/cuda/archive/10.0/ptx-writers-guide-to-interoperability/index.html#cuda-specific-dwarf
687 // cuda-gdb requires DW_AT_address_class for all variables to be able to
688 // correctly interpret address space of the variable address.
689 // Decode DW_OP_constu <DWARF Address Space> DW_OP_swap DW_OP_xderef
690 // sequence for the NVPTX + gdb target.
691 unsigned LocalNVPTXAddressSpace;
692 if (Asm->TM.getTargetTriple().isNVPTX() && DD->tuneForGDB()) {
693 const DIExpression *NewExpr =
694 DIExpression::extractAddressClass(Expr, LocalNVPTXAddressSpace);
695 if (NewExpr != Expr) {
696 Expr = NewExpr;
697 NVPTXAddressSpace = LocalNVPTXAddressSpace;
698 }
699 }
700 if (Expr)
701 Ops.append(Expr->elements_begin(), Expr->elements_end());
Adrian Prantl6825fb62017-04-18 01:21:53 +0000702 DIExpressionCursor Cursor(Ops);
Adrian Prantlc12cee32017-04-19 23:42:25 +0000703 DwarfExpr.setMemoryLocationKind();
Alexey Bataev4dd75582018-07-26 16:29:52 +0000704 if (const MCSymbol *FrameSymbol = Asm->getFunctionFrameSymbol())
705 addOpAddress(*Loc, FrameSymbol);
706 else
707 DwarfExpr.addMachineRegExpression(
708 *Asm->MF->getSubtarget().getRegisterInfo(), Cursor, FrameReg);
Adrian Prantl6825fb62017-04-18 01:21:53 +0000709 DwarfExpr.addExpression(std::move(Cursor));
David Blaikieee7df552014-10-09 17:56:36 +0000710 }
Alexey Bataevf3a91502019-02-05 19:33:47 +0000711 if (Asm->TM.getTargetTriple().isNVPTX() && DD->tuneForGDB()) {
712 // According to
713 // https://docs.nvidia.com/cuda/archive/10.0/ptx-writers-guide-to-interoperability/index.html#cuda-specific-dwarf
714 // cuda-gdb requires DW_AT_address_class for all variables to be able to
715 // correctly interpret address space of the variable address.
716 const unsigned NVPTX_ADDR_local_space = 6;
717 addUInt(*VariableDie, dwarf::DW_AT_address_class, dwarf::DW_FORM_data1,
718 NVPTXAddressSpace ? *NVPTXAddressSpace : NVPTX_ADDR_local_space);
719 }
Adrian Prantlbceaaa92016-12-20 02:09:43 +0000720 addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize());
Peter Collingbournefb9ce102019-06-17 23:39:41 +0000721 if (DwarfExpr.TagOffset)
722 addUInt(*VariableDie, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1,
723 *DwarfExpr.TagOffset);
David Blaikieee7df552014-10-09 17:56:36 +0000724
725 return VariableDie;
726}
727
Duncan P. N. Exon Smith827200c2015-06-25 23:52:10 +0000728DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV,
729 const LexicalScope &Scope,
730 DIE *&ObjectPointer) {
David Blaikie4a1a44e2014-10-09 17:56:39 +0000731 auto Var = constructVariableDIE(DV, Scope.isAbstractScope());
732 if (DV.isObjectPointer())
Duncan P. N. Exon Smith827200c2015-06-25 23:52:10 +0000733 ObjectPointer = Var;
David Blaikie4a1a44e2014-10-09 17:56:39 +0000734 return Var;
735}
736
Adrian Prantl03dd6f52018-02-08 23:21:15 +0000737/// Return all DIVariables that appear in count: expressions.
738static SmallVector<const DIVariable *, 2> dependencies(DbgVariable *Var) {
739 SmallVector<const DIVariable *, 2> Result;
740 auto *Array = dyn_cast<DICompositeType>(Var->getType());
Adrian Prantlc929f7a2018-02-06 22:17:45 +0000741 if (!Array || Array->getTag() != dwarf::DW_TAG_array_type)
Adrian Prantl03dd6f52018-02-08 23:21:15 +0000742 return Result;
743 for (auto *El : Array->getElements()) {
Adrian Prantlc929f7a2018-02-06 22:17:45 +0000744 if (auto *Subrange = dyn_cast<DISubrange>(El)) {
745 auto Count = Subrange->getCount();
Adrian Prantl03dd6f52018-02-08 23:21:15 +0000746 if (auto *Dependency = Count.dyn_cast<DIVariable *>())
747 Result.push_back(Dependency);
Adrian Prantlc929f7a2018-02-06 22:17:45 +0000748 }
Adrian Prantl03dd6f52018-02-08 23:21:15 +0000749 }
750 return Result;
Adrian Prantlc929f7a2018-02-06 22:17:45 +0000751}
752
753/// Sort local variables so that variables appearing inside of helper
754/// expressions come first.
Adrian Prantl03dd6f52018-02-08 23:21:15 +0000755static SmallVector<DbgVariable *, 8>
756sortLocalVars(SmallVectorImpl<DbgVariable *> &Input) {
757 SmallVector<DbgVariable *, 8> Result;
758 SmallVector<PointerIntPair<DbgVariable *, 1>, 8> WorkList;
759 // Map back from a DIVariable to its containing DbgVariable.
760 SmallDenseMap<const DILocalVariable *, DbgVariable *> DbgVar;
761 // Set of DbgVariables in Result.
762 SmallDenseSet<DbgVariable *, 8> Visited;
763 // For cycle detection.
764 SmallDenseSet<DbgVariable *, 8> Visiting;
765
766 // Initialize the worklist and the DIVariable lookup table.
767 for (auto Var : reverse(Input)) {
768 DbgVar.insert({Var->getVariable(), Var});
769 WorkList.push_back({Var, 0});
770 }
771
772 // Perform a stable topological sort by doing a DFS.
773 while (!WorkList.empty()) {
774 auto Item = WorkList.back();
775 DbgVariable *Var = Item.getPointer();
776 bool visitedAllDependencies = Item.getInt();
777 WorkList.pop_back();
778
779 // Dependency is in a different lexical scope or a global.
780 if (!Var)
781 continue;
782
783 // Already handled.
784 if (Visited.count(Var))
785 continue;
786
787 // Add to Result if all dependencies are visited.
788 if (visitedAllDependencies) {
789 Visited.insert(Var);
790 Result.push_back(Var);
791 continue;
792 }
793
794 // Detect cycles.
795 auto Res = Visiting.insert(Var);
796 if (!Res.second) {
797 assert(false && "dependency cycle in local variables");
798 return Result;
799 }
800
801 // Push dependencies and this node onto the worklist, so that this node is
802 // visited again after all of its dependencies are handled.
803 WorkList.push_back({Var, 1});
804 for (auto *Dependency : dependencies(Var)) {
805 auto Dep = dyn_cast_or_null<const DILocalVariable>(Dependency);
806 WorkList.push_back({DbgVar[Dep], 0});
807 }
808 }
809 return Result;
Adrian Prantlc929f7a2018-02-06 22:17:45 +0000810}
811
Duncan P. N. Exon Smith827200c2015-06-25 23:52:10 +0000812DIE *DwarfCompileUnit::createScopeChildrenDIE(LexicalScope *Scope,
813 SmallVectorImpl<DIE *> &Children,
David Blaikie2195e132017-07-27 00:06:53 +0000814 bool *HasNonScopeChildren) {
815 assert(Children.empty());
David Blaikie8b2fdb82014-10-09 18:24:28 +0000816 DIE *ObjectPointer = nullptr;
817
Adrian Prantlc929f7a2018-02-06 22:17:45 +0000818 // Emit function arguments (order is significant).
819 auto Vars = DU->getScopeVariables().lookup(Scope);
820 for (auto &DV : Vars.Args)
821 Children.push_back(constructVariableDIE(*DV.second, *Scope, ObjectPointer));
822
823 // Emit local variables.
Adrian Prantl03dd6f52018-02-08 23:21:15 +0000824 auto Locals = sortLocalVars(Vars.Locals);
825 for (DbgVariable *DV : Locals)
David Blaikie8b2fdb82014-10-09 18:24:28 +0000826 Children.push_back(constructVariableDIE(*DV, *Scope, ObjectPointer));
827
David Blaikie2195e132017-07-27 00:06:53 +0000828 // Skip imported directives in gmlt-like data.
829 if (!includeMinimalInlineScopes()) {
830 // There is no need to emit empty lexical block DIE.
831 for (const auto *IE : ImportedEntities[Scope->getScopeNode()])
832 Children.push_back(
833 constructImportedEntityDIE(cast<DIImportedEntity>(IE)));
834 }
835
836 if (HasNonScopeChildren)
837 *HasNonScopeChildren = !Children.empty();
David Blaikie8b2fdb82014-10-09 18:24:28 +0000838
Hsiangkai Wang2532ac82018-08-17 15:22:04 +0000839 for (DbgLabel *DL : DU->getScopeLabels().lookup(Scope))
840 Children.push_back(constructLabelDIE(*DL, *Scope));
841
David Blaikie8b2fdb82014-10-09 18:24:28 +0000842 for (LexicalScope *LS : Scope->getChildren())
843 constructScopeDIE(LS, Children);
844
David Blaikie8b2fdb82014-10-09 18:24:28 +0000845 return ObjectPointer;
846}
847
Vedant Kumar5931b4e2018-10-05 20:37:17 +0000848DIE &DwarfCompileUnit::constructSubprogramScopeDIE(const DISubprogram *Sub,
849 LexicalScope *Scope) {
David Blaikie1d072342014-10-09 20:21:36 +0000850 DIE &ScopeDIE = updateSubprogramScopeDIE(Sub);
851
David Blaikie3e3eb332016-12-15 23:17:52 +0000852 if (Scope) {
853 assert(!Scope->getInlinedAt());
854 assert(!Scope->isAbstractScope());
855 // Collect lexical scope children first.
856 // ObjectPointer might be a local (non-argument) local variable if it's a
857 // block's synthetic this pointer.
858 if (DIE *ObjectPointer = createAndAddScopeChildren(Scope, ScopeDIE))
859 addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer);
860 }
861
David Blaikie1d072342014-10-09 20:21:36 +0000862 // If this is a variadic function, add an unspecified parameter.
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000863 DITypeRefArray FnArgs = Sub->getType()->getTypeArray();
David Blaikie1dd573d2014-10-23 22:27:50 +0000864
David Blaikie1d072342014-10-09 20:21:36 +0000865 // If we have a single element of null, it is a function that returns void.
866 // If we have more than one elements and the last one is null, it is a
867 // variadic function.
Duncan P. N. Exon Smith000fa2c2015-04-07 04:14:33 +0000868 if (FnArgs.size() > 1 && !FnArgs[FnArgs.size() - 1] &&
David Blaikie3a443c22014-11-04 22:12:25 +0000869 !includeMinimalInlineScopes())
Duncan P. N. Exon Smith827200c2015-06-25 23:52:10 +0000870 ScopeDIE.addChild(
871 DIE::get(DIEValueAllocator, dwarf::DW_TAG_unspecified_parameters));
Vedant Kumar5931b4e2018-10-05 20:37:17 +0000872
873 return ScopeDIE;
David Blaikie1d072342014-10-09 20:21:36 +0000874}
875
David Blaikie78b65b62014-10-09 20:26:15 +0000876DIE *DwarfCompileUnit::createAndAddScopeChildren(LexicalScope *Scope,
877 DIE &ScopeDIE) {
878 // We create children when the scope DIE is not null.
Duncan P. N. Exon Smith827200c2015-06-25 23:52:10 +0000879 SmallVector<DIE *, 8> Children;
David Blaikie78b65b62014-10-09 20:26:15 +0000880 DIE *ObjectPointer = createScopeChildrenDIE(Scope, Children);
881
882 // Add children
883 for (auto &I : Children)
884 ScopeDIE.addChild(std::move(I));
885
886 return ObjectPointer;
887}
888
Dehao Chen54511352015-11-11 18:09:47 +0000889void DwarfCompileUnit::constructAbstractSubprogramScopeDIE(
890 LexicalScope *Scope) {
David Blaikie488393f2017-05-12 01:13:45 +0000891 DIE *&AbsDef = getAbstractSPDies()[Scope->getScopeNode()];
David Blaikie49be5b32014-10-31 21:57:02 +0000892 if (AbsDef)
893 return;
894
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000895 auto *SP = cast<DISubprogram>(Scope->getScopeNode());
David Blaikie58410f22014-10-10 06:39:26 +0000896
897 DIE *ContextDIE;
Jonas Devlieghere294e6892017-11-15 10:57:05 +0000898 DwarfCompileUnit *ContextCU = this;
David Blaikie58410f22014-10-10 06:39:26 +0000899
David Blaikie3a443c22014-11-04 22:12:25 +0000900 if (includeMinimalInlineScopes())
901 ContextDIE = &getUnitDie();
David Blaikie58410f22014-10-10 06:39:26 +0000902 // Some of this is duplicated from DwarfUnit::getOrCreateSubprogramDIE, with
Duncan P. N. Exon Smith7c60f202015-04-18 00:35:36 +0000903 // the important distinction that the debug node is not associated with the
904 // DIE (since the debug node will be associated with the concrete DIE, if
David Blaikie58410f22014-10-10 06:39:26 +0000905 // any). It could be refactored to some common utility function.
Duncan P. N. Exon Smith537b4a82015-04-14 03:40:37 +0000906 else if (auto *SPDecl = SP->getDeclaration()) {
David Blaikie58410f22014-10-10 06:39:26 +0000907 ContextDIE = &getUnitDie();
908 getOrCreateSubprogramDIE(SPDecl);
Jonas Devlieghere294e6892017-11-15 10:57:05 +0000909 } else {
Fangrui Songda82ce92019-05-07 02:06:37 +0000910 ContextDIE = getOrCreateContextDIE(SP->getScope());
Jonas Devlieghere294e6892017-11-15 10:57:05 +0000911 // The scope may be shared with a subprogram that has already been
912 // constructed in another CU, in which case we need to construct this
913 // subprogram in the same CU.
914 ContextCU = DD->lookupCU(ContextDIE->getUnitDie());
915 }
David Blaikie58410f22014-10-10 06:39:26 +0000916
Duncan P. N. Exon Smith7c60f202015-04-18 00:35:36 +0000917 // Passing null as the associated node because the abstract definition
David Blaikie58410f22014-10-10 06:39:26 +0000918 // shouldn't be found by lookup.
Jonas Devlieghere294e6892017-11-15 10:57:05 +0000919 AbsDef = &ContextCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, nullptr);
920 ContextCU->applySubprogramAttributesToDefinition(SP, *AbsDef);
David Blaikie58410f22014-10-10 06:39:26 +0000921
Jonas Devlieghere294e6892017-11-15 10:57:05 +0000922 if (!ContextCU->includeMinimalInlineScopes())
923 ContextCU->addUInt(*AbsDef, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
924 if (DIE *ObjectPointer = ContextCU->createAndAddScopeChildren(Scope, *AbsDef))
925 ContextCU->addDIEEntry(*AbsDef, dwarf::DW_AT_object_pointer, *ObjectPointer);
David Blaikie58410f22014-10-10 06:39:26 +0000926}
927
Vedant Kumar533dd022019-08-26 20:53:12 +0000928/// Whether to use the GNU analog for a DWARF5 tag, attribute, or location atom.
929static bool useGNUAnalogForDwarf5Feature(DwarfDebug *DD) {
930 return DD->getDwarfVersion() == 4 && DD->tuneForGDB();
931}
932
Vedant Kumar58a07142019-08-26 20:53:34 +0000933dwarf::Tag DwarfCompileUnit::getDwarf5OrGNUTag(dwarf::Tag Tag) const {
Vedant Kumar533dd022019-08-26 20:53:12 +0000934 if (!useGNUAnalogForDwarf5Feature(DD))
Djordje Todorovicb9973f82019-07-31 16:51:28 +0000935 return Tag;
936 switch (Tag) {
937 case dwarf::DW_TAG_call_site:
938 return dwarf::DW_TAG_GNU_call_site;
939 case dwarf::DW_TAG_call_site_parameter:
940 return dwarf::DW_TAG_GNU_call_site_parameter;
941 default:
Vedant Kumar58a07142019-08-26 20:53:34 +0000942 llvm_unreachable("DWARF5 tag with no GNU analog");
Djordje Todorovicb9973f82019-07-31 16:51:28 +0000943 }
944}
945
946dwarf::Attribute
Vedant Kumar58a07142019-08-26 20:53:34 +0000947DwarfCompileUnit::getDwarf5OrGNUAttr(dwarf::Attribute Attr) const {
Vedant Kumar533dd022019-08-26 20:53:12 +0000948 if (!useGNUAnalogForDwarf5Feature(DD))
Djordje Todorovicb9973f82019-07-31 16:51:28 +0000949 return Attr;
950 switch (Attr) {
951 case dwarf::DW_AT_call_all_calls:
952 return dwarf::DW_AT_GNU_all_call_sites;
953 case dwarf::DW_AT_call_target:
954 return dwarf::DW_AT_GNU_call_site_target;
955 case dwarf::DW_AT_call_origin:
956 return dwarf::DW_AT_abstract_origin;
Vedant Kumar43464502020-01-15 14:15:45 -0800957 case dwarf::DW_AT_call_return_pc:
Djordje Todorovicb9973f82019-07-31 16:51:28 +0000958 return dwarf::DW_AT_low_pc;
959 case dwarf::DW_AT_call_value:
960 return dwarf::DW_AT_GNU_call_site_value;
961 case dwarf::DW_AT_call_tail_call:
962 return dwarf::DW_AT_GNU_tail_call;
963 default:
Vedant Kumar58a07142019-08-26 20:53:34 +0000964 llvm_unreachable("DWARF5 attribute with no GNU analog");
Djordje Todorovicb9973f82019-07-31 16:51:28 +0000965 }
966}
967
Vedant Kumar533dd022019-08-26 20:53:12 +0000968dwarf::LocationAtom
969DwarfCompileUnit::getDwarf5OrGNULocationAtom(dwarf::LocationAtom Loc) const {
970 if (!useGNUAnalogForDwarf5Feature(DD))
971 return Loc;
972 switch (Loc) {
973 case dwarf::DW_OP_entry_value:
974 return dwarf::DW_OP_GNU_entry_value;
975 default:
976 llvm_unreachable("DWARF5 location atom with no GNU analog");
977 }
978}
979
Vedant Kumarf0120552020-01-09 18:00:33 -0800980DIE &DwarfCompileUnit::constructCallSiteEntryDIE(DIE &ScopeDIE,
Vedant Kumare08f2052020-01-25 12:52:47 -0800981 DIE *CalleeDIE,
Vedant Kumarf0120552020-01-09 18:00:33 -0800982 bool IsTail,
983 const MCSymbol *PCAddr,
984 unsigned CallReg) {
Vedant Kumar5931b4e2018-10-05 20:37:17 +0000985 // Insert a call site entry DIE within ScopeDIE.
Vedant Kumar58a07142019-08-26 20:53:34 +0000986 DIE &CallSiteDIE = createAndAddDIE(getDwarf5OrGNUTag(dwarf::DW_TAG_call_site),
987 ScopeDIE, nullptr);
Vedant Kumar5931b4e2018-10-05 20:37:17 +0000988
Djordje Todorovicb9973f82019-07-31 16:51:28 +0000989 if (CallReg) {
990 // Indirect call.
Vedant Kumar58a07142019-08-26 20:53:34 +0000991 addAddress(CallSiteDIE, getDwarf5OrGNUAttr(dwarf::DW_AT_call_target),
Djordje Todorovicb9973f82019-07-31 16:51:28 +0000992 MachineLocation(CallReg));
Djordje Todorovic0739ccd2019-07-12 09:45:12 +0000993 } else {
Vedant Kumare08f2052020-01-25 12:52:47 -0800994 assert(CalleeDIE && "No DIE for call site entry origin");
Vedant Kumar58a07142019-08-26 20:53:34 +0000995 addDIEEntry(CallSiteDIE, getDwarf5OrGNUAttr(dwarf::DW_AT_call_origin),
Djordje Todorovicb9973f82019-07-31 16:51:28 +0000996 *CalleeDIE);
997 }
998
999 if (IsTail)
1000 // Attach DW_AT_call_tail_call to tail calls for standards compliance.
Vedant Kumar58a07142019-08-26 20:53:34 +00001001 addFlag(CallSiteDIE, getDwarf5OrGNUAttr(dwarf::DW_AT_call_tail_call));
Djordje Todorovicb9973f82019-07-31 16:51:28 +00001002
1003 // Attach the return PC to allow the debugger to disambiguate call paths
1004 // from one function to another.
Vedant Kumar43464502020-01-15 14:15:45 -08001005 //
1006 // The return PC is only really needed when the call /isn't/ a tail call, but
1007 // for some reason GDB always expects it.
1008 if (!IsTail || DD->tuneForGDB()) {
Vedant Kumarf0120552020-01-09 18:00:33 -08001009 assert(PCAddr && "Missing return PC information for a call");
Vedant Kumar43464502020-01-15 14:15:45 -08001010 addLabelAddress(CallSiteDIE,
1011 getDwarf5OrGNUAttr(dwarf::DW_AT_call_return_pc), PCAddr);
Vedant Kumar5931b4e2018-10-05 20:37:17 +00001012 }
Djordje Todorovicb9973f82019-07-31 16:51:28 +00001013
Vedant Kumar5931b4e2018-10-05 20:37:17 +00001014 return CallSiteDIE;
1015}
1016
Djordje Todorovicb9973f82019-07-31 16:51:28 +00001017void DwarfCompileUnit::constructCallSiteParmEntryDIEs(
1018 DIE &CallSiteDIE, SmallVector<DbgCallSiteParam, 4> &Params) {
1019 for (const auto &Param : Params) {
1020 unsigned Register = Param.getRegister();
1021 auto CallSiteDieParam =
1022 DIE::get(DIEValueAllocator,
Vedant Kumar58a07142019-08-26 20:53:34 +00001023 getDwarf5OrGNUTag(dwarf::DW_TAG_call_site_parameter));
Djordje Todorovicb9973f82019-07-31 16:51:28 +00001024 insertDIE(CallSiteDieParam);
1025 addAddress(*CallSiteDieParam, dwarf::DW_AT_location,
1026 MachineLocation(Register));
1027
1028 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1029 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
1030 DwarfExpr.setCallSiteParamValueFlag();
1031
1032 DwarfDebug::emitDebugLocValue(*Asm, nullptr, Param.getValue(), DwarfExpr);
1033
Vedant Kumar58a07142019-08-26 20:53:34 +00001034 addBlock(*CallSiteDieParam, getDwarf5OrGNUAttr(dwarf::DW_AT_call_value),
Djordje Todorovicb9973f82019-07-31 16:51:28 +00001035 DwarfExpr.finalize());
1036
1037 CallSiteDIE.addChild(CallSiteDieParam);
1038 }
1039}
1040
Duncan P. N. Exon Smith827200c2015-06-25 23:52:10 +00001041DIE *DwarfCompileUnit::constructImportedEntityDIE(
1042 const DIImportedEntity *Module) {
Amjad Aboud72da9392016-04-30 01:44:07 +00001043 DIE *IMDie = DIE::get(DIEValueAllocator, (dwarf::Tag)Module->getTag());
1044 insertDIE(Module, IMDie);
Frederic Riss987fe222014-10-24 21:31:09 +00001045 DIE *EntityDie;
Fangrui Songda82ce92019-05-07 02:06:37 +00001046 auto *Entity = Module->getEntity();
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +00001047 if (auto *NS = dyn_cast<DINamespace>(Entity))
Duncan P. N. Exon Smithe686f152015-04-06 23:27:40 +00001048 EntityDie = getOrCreateNameSpace(NS);
Adrian Prantl08a388b2015-06-30 02:13:04 +00001049 else if (auto *M = dyn_cast<DIModule>(Entity))
1050 EntityDie = getOrCreateModule(M);
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +00001051 else if (auto *SP = dyn_cast<DISubprogram>(Entity))
Duncan P. N. Exon Smithe686f152015-04-06 23:27:40 +00001052 EntityDie = getOrCreateSubprogramDIE(SP);
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +00001053 else if (auto *T = dyn_cast<DIType>(Entity))
Duncan P. N. Exon Smithe686f152015-04-06 23:27:40 +00001054 EntityDie = getOrCreateTypeDIE(T);
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +00001055 else if (auto *GV = dyn_cast<DIGlobalVariable>(Entity))
Adrian Prantlbceaaa92016-12-20 02:09:43 +00001056 EntityDie = getOrCreateGlobalVariableDIE(GV, {});
Frederic Riss987fe222014-10-24 21:31:09 +00001057 else
1058 EntityDie = getDIE(Entity);
1059 assert(EntityDie);
Paul Robinson612e89d2018-01-12 19:17:50 +00001060 addSourceLine(*IMDie, Module->getLine(), Module->getFile());
Frederic Riss987fe222014-10-24 21:31:09 +00001061 addDIEEntry(*IMDie, dwarf::DW_AT_import, *EntityDie);
Duncan P. N. Exon Smithde8e4272015-04-14 01:46:44 +00001062 StringRef Name = Module->getName();
Frederic Riss987fe222014-10-24 21:31:09 +00001063 if (!Name.empty())
1064 addString(*IMDie, dwarf::DW_AT_name, Name);
1065
1066 return IMDie;
1067}
1068
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +00001069void DwarfCompileUnit::finishSubprogramDefinition(const DISubprogram *SP) {
Amjad Aboud72da9392016-04-30 01:44:07 +00001070 DIE *D = getDIE(SP);
David Blaikie488393f2017-05-12 01:13:45 +00001071 if (DIE *AbsSPDIE = getAbstractSPDies().lookup(SP)) {
Amjad Aboud72da9392016-04-30 01:44:07 +00001072 if (D)
David Blaikie4191cbc2014-10-10 06:39:29 +00001073 // If this subprogram has an abstract definition, reference that
1074 addDIEEntry(*D, dwarf::DW_AT_abstract_origin, *AbsSPDIE);
Amjad Aboud72da9392016-04-30 01:44:07 +00001075 } else {
David Blaikie3e3eb332016-12-15 23:17:52 +00001076 assert(D || includeMinimalInlineScopes());
Amjad Aboud72da9392016-04-30 01:44:07 +00001077 if (D)
David Blaikie4191cbc2014-10-10 06:39:29 +00001078 // And attach the attributes
1079 applySubprogramAttributesToDefinition(SP, *D);
1080 }
1081}
1082
Hsiangkai Wang2532ac82018-08-17 15:22:04 +00001083void DwarfCompileUnit::finishEntityDefinition(const DbgEntity *Entity) {
1084 DbgEntity *AbsEntity = getExistingAbstractEntity(Entity->getEntity());
1085
1086 auto *Die = Entity->getDIE();
1087 /// Label may be used to generate DW_AT_low_pc, so put it outside
1088 /// if/else block.
1089 const DbgLabel *Label = nullptr;
1090 if (AbsEntity && AbsEntity->getDIE()) {
1091 addDIEEntry(*Die, dwarf::DW_AT_abstract_origin, *AbsEntity->getDIE());
1092 Label = dyn_cast<const DbgLabel>(Entity);
1093 } else {
1094 if (const DbgVariable *Var = dyn_cast<const DbgVariable>(Entity))
1095 applyVariableAttributes(*Var, *Die);
1096 else if ((Label = dyn_cast<const DbgLabel>(Entity)))
1097 applyLabelAttributes(*Label, *Die);
1098 else
1099 llvm_unreachable("DbgEntity must be DbgVariable or DbgLabel.");
1100 }
1101
Hsiangkai Wang55321d82018-09-26 04:19:23 +00001102 if (Label)
1103 if (const auto *Sym = Label->getSymbol())
1104 addLabelAddress(*Die, dwarf::DW_AT_low_pc, Sym);
David Blaikie488393f2017-05-12 01:13:45 +00001105}
1106
Hsiangkai Wang2532ac82018-08-17 15:22:04 +00001107DbgEntity *DwarfCompileUnit::getExistingAbstractEntity(const DINode *Node) {
1108 auto &AbstractEntities = getAbstractEntities();
1109 auto I = AbstractEntities.find(Node);
1110 if (I != AbstractEntities.end())
David Blaikie488393f2017-05-12 01:13:45 +00001111 return I->second.get();
1112 return nullptr;
1113}
1114
Hsiangkai Wang2532ac82018-08-17 15:22:04 +00001115void DwarfCompileUnit::createAbstractEntity(const DINode *Node,
1116 LexicalScope *Scope) {
David Blaikie488393f2017-05-12 01:13:45 +00001117 assert(Scope && Scope->isAbstractScope());
Hsiangkai Wang2532ac82018-08-17 15:22:04 +00001118 auto &Entity = getAbstractEntities()[Node];
1119 if (isa<const DILocalVariable>(Node)) {
Jonas Devlieghere0eaee542019-08-15 15:54:37 +00001120 Entity = std::make_unique<DbgVariable>(
Hsiangkai Wang2532ac82018-08-17 15:22:04 +00001121 cast<const DILocalVariable>(Node), nullptr /* IA */);;
1122 DU->addScopeVariable(Scope, cast<DbgVariable>(Entity.get()));
1123 } else if (isa<const DILabel>(Node)) {
Jonas Devlieghere0eaee542019-08-15 15:54:37 +00001124 Entity = std::make_unique<DbgLabel>(
Hsiangkai Wang2532ac82018-08-17 15:22:04 +00001125 cast<const DILabel>(Node), nullptr /* IA */);
1126 DU->addScopeLabel(Scope, cast<DbgLabel>(Entity.get()));
1127 }
David Blaikie488393f2017-05-12 01:13:45 +00001128}
1129
Rafael Espindola063d7252015-03-10 16:58:10 +00001130void DwarfCompileUnit::emitHeader(bool UseOffsets) {
David Blaikieb6726a92014-11-02 02:26:24 +00001131 // Don't bother labeling the .dwo unit, as its offset isn't used.
Alexey Bataevbff36082018-03-23 13:35:54 +00001132 if (!Skeleton && !DD->useSectionsAsReferences()) {
Rafael Espindola9ab09232015-03-17 20:07:06 +00001133 LabelBegin = Asm->createTempSymbol("cu_begin");
Lang Hames9ff69c82015-04-24 19:11:51 +00001134 Asm->OutStreamer->EmitLabel(LabelBegin);
Rafael Espindola3c311142015-03-10 03:11:11 +00001135 }
David Blaikieae57e662014-11-01 23:59:23 +00001136
Paul Robinsoncddd6042017-02-28 20:24:55 +00001137 dwarf::UnitType UT = Skeleton ? dwarf::DW_UT_split_compile
1138 : DD->useSplitDwarf() ? dwarf::DW_UT_skeleton
1139 : dwarf::DW_UT_compile;
1140 DwarfUnit::emitCommonHeader(UseOffsets, UT);
Paul Robinson543c0e12018-05-22 17:27:31 +00001141 if (DD->getDwarfVersion() >= 5 && UT != dwarf::DW_UT_compile)
1142 Asm->emitInt64(getDWOId());
David Blaikieae57e662014-11-01 23:59:23 +00001143}
1144
Peter Collingbourneb52e2362017-09-12 21:50:41 +00001145bool DwarfCompileUnit::hasDwarfPubSections() const {
David Blaikie66cf14d2018-08-16 21:29:55 +00001146 switch (CUNode->getNameTableKind()) {
1147 case DICompileUnit::DebugNameTableKind::None:
1148 return false;
1149 // Opting in to GNU Pubnames/types overrides the default to ensure these are
1150 // generated for things like Gold's gdb_index generation.
1151 case DICompileUnit::DebugNameTableKind::GNU:
Peter Collingbourneb52e2362017-09-12 21:50:41 +00001152 return true;
David Blaikie66cf14d2018-08-16 21:29:55 +00001153 case DICompileUnit::DebugNameTableKind::Default:
David Blaikie0e030472018-08-16 23:57:15 +00001154 return DD->tuneForGDB() && !includeMinimalInlineScopes() &&
David Blaikie2f511762019-04-23 19:00:45 +00001155 !CUNode->isDebugDirectivesOnly() &&
1156 DD->getAccelTableKind() != AccelTableKind::Apple &&
1157 DD->getDwarfVersion() < 5;
David Blaikie66cf14d2018-08-16 21:29:55 +00001158 }
Simon Pilgrim22d580f22018-08-17 09:47:52 +00001159 llvm_unreachable("Unhandled DICompileUnit::DebugNameTableKind enum");
Peter Collingbourneb52e2362017-09-12 21:50:41 +00001160}
1161
David Blaikie192b45c2014-11-02 06:16:39 +00001162/// addGlobalName - Add a new global name to the compile unit.
David Blaikiea0e3c752017-02-03 00:44:18 +00001163void DwarfCompileUnit::addGlobalName(StringRef Name, const DIE &Die,
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +00001164 const DIScope *Context) {
Peter Collingbourneb52e2362017-09-12 21:50:41 +00001165 if (!hasDwarfPubSections())
David Blaikie192b45c2014-11-02 06:16:39 +00001166 return;
1167 std::string FullName = getParentContextString(Context) + Name.str();
1168 GlobalNames[FullName] = &Die;
1169}
1170
David Blaikiea0e3c752017-02-03 00:44:18 +00001171void DwarfCompileUnit::addGlobalNameForTypeUnit(StringRef Name,
1172 const DIScope *Context) {
Peter Collingbourneb52e2362017-09-12 21:50:41 +00001173 if (!hasDwarfPubSections())
David Blaikiea0e3c752017-02-03 00:44:18 +00001174 return;
1175 std::string FullName = getParentContextString(Context) + Name.str();
1176 // Insert, allowing the entry to remain as-is if it's already present
1177 // This way the CU-level type DIE is preferred over the "can't describe this
1178 // type as a unit offset because it's not really in the CU at all, it's only
1179 // in a type unit"
1180 GlobalNames.insert(std::make_pair(std::move(FullName), &getUnitDie()));
1181}
1182
David Blaikie192b45c2014-11-02 06:16:39 +00001183/// Add a new global type to the unit.
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +00001184void DwarfCompileUnit::addGlobalType(const DIType *Ty, const DIE &Die,
1185 const DIScope *Context) {
Peter Collingbourneb52e2362017-09-12 21:50:41 +00001186 if (!hasDwarfPubSections())
David Blaikie192b45c2014-11-02 06:16:39 +00001187 return;
Duncan P. N. Exon Smithb1055642015-04-16 01:01:28 +00001188 std::string FullName = getParentContextString(Context) + Ty->getName().str();
David Blaikie192b45c2014-11-02 06:16:39 +00001189 GlobalTypes[FullName] = &Die;
1190}
David Blaikieae57e662014-11-01 23:59:23 +00001191
David Blaikiea0e3c752017-02-03 00:44:18 +00001192void DwarfCompileUnit::addGlobalTypeUnitType(const DIType *Ty,
1193 const DIScope *Context) {
Peter Collingbourneb52e2362017-09-12 21:50:41 +00001194 if (!hasDwarfPubSections())
David Blaikiea0e3c752017-02-03 00:44:18 +00001195 return;
1196 std::string FullName = getParentContextString(Context) + Ty->getName().str();
1197 // Insert, allowing the entry to remain as-is if it's already present
1198 // This way the CU-level type DIE is preferred over the "can't describe this
1199 // type as a unit offset because it's not really in the CU at all, it's only
1200 // in a type unit"
1201 GlobalTypes.insert(std::make_pair(std::move(FullName), &getUnitDie()));
1202}
1203
David Blaikie7d48be22014-11-02 06:37:23 +00001204void DwarfCompileUnit::addVariableAddress(const DbgVariable &DV, DIE &Die,
1205 MachineLocation Location) {
Duncan P. N. Exon Smithe6cc5312015-06-21 16:50:43 +00001206 if (DV.hasComplexAddress())
David Blaikie7d48be22014-11-02 06:37:23 +00001207 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
David Blaikie7d48be22014-11-02 06:37:23 +00001208 else
Adrian Prantl5883af32015-01-19 17:57:29 +00001209 addAddress(Die, dwarf::DW_AT_location, Location);
David Blaikie7d48be22014-11-02 06:37:23 +00001210}
David Blaikief7435ee2014-11-02 06:46:40 +00001211
1212/// Add an address attribute to a die based on the location provided.
1213void DwarfCompileUnit::addAddress(DIE &Die, dwarf::Attribute Attribute,
Adrian Prantl5883af32015-01-19 17:57:29 +00001214 const MachineLocation &Location) {
Duncan P. N. Exon Smithe7e1d0c2015-05-27 22:14:58 +00001215 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
Adrian Prantl956484b2017-03-20 21:35:09 +00001216 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
Adrian Prantlc12cee32017-04-19 23:42:25 +00001217 if (Location.isIndirect())
1218 DwarfExpr.setMemoryLocationKind();
David Blaikief7435ee2014-11-02 06:46:40 +00001219
Adrian Prantl2049c0d2017-08-02 15:22:17 +00001220 DIExpressionCursor Cursor({});
Adrian Prantl956484b2017-03-20 21:35:09 +00001221 const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo();
Adrian Prantlc12cee32017-04-19 23:42:25 +00001222 if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
Adrian Prantlab255fc2014-12-05 01:02:46 +00001223 return;
Adrian Prantl956484b2017-03-20 21:35:09 +00001224 DwarfExpr.addExpression(std::move(Cursor));
Adrian Prantlab255fc2014-12-05 01:02:46 +00001225
David Blaikief7435ee2014-11-02 06:46:40 +00001226 // Now attach the location information to the DIE.
Adrian Prantl956484b2017-03-20 21:35:09 +00001227 addBlock(Die, Attribute, DwarfExpr.finalize());
Evgenii Stepanovdabd2622019-11-25 17:47:30 -08001228
1229 if (DwarfExpr.TagOffset)
1230 addUInt(Die, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1,
1231 *DwarfExpr.TagOffset);
David Blaikief7435ee2014-11-02 06:46:40 +00001232}
David Blaikie77895fb2014-11-02 06:58:44 +00001233
1234/// Start with the address based on the location provided, and generate the
1235/// DWARF information necessary to find the actual variable given the extra
1236/// address information encoded in the DbgVariable, starting from the starting
1237/// location. Add the DWARF information to the die.
1238void DwarfCompileUnit::addComplexAddress(const DbgVariable &DV, DIE &Die,
1239 dwarf::Attribute Attribute,
1240 const MachineLocation &Location) {
Duncan P. N. Exon Smithe7e1d0c2015-05-27 22:14:58 +00001241 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
Adrian Prantl7813d9c2015-01-14 01:01:30 +00001242 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
Adrian Prantl956484b2017-03-20 21:35:09 +00001243 const DIExpression *DIExpr = DV.getSingleExpression();
1244 DwarfExpr.addFragmentOffset(DIExpr);
Adrian Prantlc12cee32017-04-19 23:42:25 +00001245 if (Location.isIndirect())
1246 DwarfExpr.setMemoryLocationKind();
Adrian Prantl956484b2017-03-20 21:35:09 +00001247
Adrian Prantl2049c0d2017-08-02 15:22:17 +00001248 DIExpressionCursor Cursor(DIExpr);
Djordje Todorovic12aca5d2019-07-09 08:36:34 +00001249
1250 if (DIExpr->isEntryValue()) {
1251 DwarfExpr.setEntryValueFlag();
David Stenberg1ae2d9a2019-10-15 11:31:21 +00001252 DwarfExpr.beginEntryValueExpression(Cursor);
Djordje Todorovic12aca5d2019-07-09 08:36:34 +00001253 }
1254
Peter Collingbourne96c9ae62016-05-20 19:35:17 +00001255 const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo();
Adrian Prantlc12cee32017-04-19 23:42:25 +00001256 if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
Adrian Prantl54286bd2016-11-02 16:12:20 +00001257 return;
Adrian Prantl956484b2017-03-20 21:35:09 +00001258 DwarfExpr.addExpression(std::move(Cursor));
David Blaikie77895fb2014-11-02 06:58:44 +00001259
1260 // Now attach the location information to the DIE.
Adrian Prantl956484b2017-03-20 21:35:09 +00001261 addBlock(Die, Attribute, DwarfExpr.finalize());
Evgenii Stepanovdabd2622019-11-25 17:47:30 -08001262
1263 if (DwarfExpr.TagOffset)
1264 addUInt(Die, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1,
1265 *DwarfExpr.TagOffset);
David Blaikie77895fb2014-11-02 06:58:44 +00001266}
David Blaikie4bc08812014-11-02 07:03:19 +00001267
1268/// Add a Dwarf loclistptr attribute data and value.
1269void DwarfCompileUnit::addLocationList(DIE &Die, dwarf::Attribute Attribute,
1270 unsigned Index) {
David Blaikie77cfcd72019-11-12 14:15:37 -08001271 dwarf::Form Form = dwarf::DW_FORM_data4;
1272 if (DD->getDwarfVersion() == 4)
1273 Form =dwarf::DW_FORM_sec_offset;
1274 if (DD->getDwarfVersion() >= 5)
1275 Form =dwarf::DW_FORM_loclistx;
Duncan P. N. Exon Smith4fb1f9c2015-06-25 23:46:41 +00001276 Die.addValue(DIEValueAllocator, Attribute, Form, DIELocList(Index));
David Blaikie4bc08812014-11-02 07:03:19 +00001277}
David Blaikie02a63332014-11-02 07:06:51 +00001278
David Blaikie8c485b52014-11-02 07:08:12 +00001279void DwarfCompileUnit::applyVariableAttributes(const DbgVariable &Var,
1280 DIE &VariableDie) {
David Blaikie02a63332014-11-02 07:06:51 +00001281 StringRef Name = Var.getName();
1282 if (!Name.empty())
1283 addString(VariableDie, dwarf::DW_AT_name, Name);
Victor Leschuk3c989982016-10-26 11:59:03 +00001284 const auto *DIVar = Var.getVariable();
1285 if (DIVar)
1286 if (uint32_t AlignInBytes = DIVar->getAlignInBytes())
1287 addUInt(VariableDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1288 AlignInBytes);
1289
1290 addSourceLine(VariableDie, DIVar);
David Blaikie02a63332014-11-02 07:06:51 +00001291 addType(VariableDie, Var.getType());
1292 if (Var.isArtificial())
1293 addFlag(VariableDie, dwarf::DW_AT_artificial);
1294}
David Blaikie97802082014-11-02 07:11:55 +00001295
Hsiangkai Wang2532ac82018-08-17 15:22:04 +00001296void DwarfCompileUnit::applyLabelAttributes(const DbgLabel &Label,
1297 DIE &LabelDie) {
1298 StringRef Name = Label.getName();
1299 if (!Name.empty())
1300 addString(LabelDie, dwarf::DW_AT_name, Name);
1301 const auto *DILabel = Label.getLabel();
1302 addSourceLine(LabelDie, DILabel);
1303}
1304
David Blaikie97802082014-11-02 07:11:55 +00001305/// Add a Dwarf expression attribute data and value.
1306void DwarfCompileUnit::addExpr(DIELoc &Die, dwarf::Form Form,
1307 const MCExpr *Expr) {
Duncan P. N. Exon Smith4fb1f9c2015-06-25 23:46:41 +00001308 Die.addValue(DIEValueAllocator, (dwarf::Attribute)0, Form, DIEExpr(Expr));
David Blaikie97802082014-11-02 07:11:55 +00001309}
David Blaikie3363a572014-11-02 08:09:09 +00001310
Duncan P. N. Exon Smith2fbe1352015-04-20 22:10:08 +00001311void DwarfCompileUnit::applySubprogramAttributesToDefinition(
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +00001312 const DISubprogram *SP, DIE &SPDie) {
Duncan P. N. Exon Smith537b4a82015-04-14 03:40:37 +00001313 auto *SPDecl = SP->getDeclaration();
Fangrui Songda82ce92019-05-07 02:06:37 +00001314 auto *Context = SPDecl ? SPDecl->getScope() : SP->getScope();
David Blaikie3a443c22014-11-04 22:12:25 +00001315 applySubprogramAttributes(SP, SPDie, includeMinimalInlineScopes());
Duncan P. N. Exon Smith537b4a82015-04-14 03:40:37 +00001316 addGlobalName(SP->getName(), SPDie, Context);
David Blaikie3363a572014-11-02 08:09:09 +00001317}
David Blaikiecafd9622014-11-02 08:51:37 +00001318
1319bool DwarfCompileUnit::isDwoUnit() const {
1320 return DD->useSplitDwarf() && Skeleton;
1321}
David Blaikie3a443c22014-11-04 22:12:25 +00001322
David Blaikie832c7d92019-04-24 18:09:44 +00001323void DwarfCompileUnit::finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) {
1324 constructTypeDIE(D, CTy);
1325}
1326
David Blaikie3a443c22014-11-04 22:12:25 +00001327bool DwarfCompileUnit::includeMinimalInlineScopes() const {
Adrian Prantlb939a252016-03-31 23:56:58 +00001328 return getCUNode()->getEmissionKind() == DICompileUnit::LineTablesOnly ||
David Blaikie3a443c22014-11-04 22:12:25 +00001329 (DD->useSplitDwarf() && !Skeleton);
1330}
David Blaikie61c127c2018-12-14 22:34:03 +00001331
1332void DwarfCompileUnit::addAddrTableBase() {
1333 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1334 MCSymbol *Label = DD->getAddressPool().getLabel();
1335 addSectionLabel(getUnitDie(),
1336 getDwarfVersion() >= 5 ? dwarf::DW_AT_addr_base
1337 : dwarf::DW_AT_GNU_addr_base,
1338 Label, TLOF.getDwarfAddrSection()->getBeginSymbol());
1339}
Markus Lavinb86ce212019-03-19 13:16:28 +00001340
1341void DwarfCompileUnit::addBaseTypeRef(DIEValueList &Die, int64_t Idx) {
1342 Die.addValue(DIEValueAllocator, (dwarf::Attribute)0, dwarf::DW_FORM_udata,
1343 new (DIEValueAllocator) DIEBaseTypeRef(this, Idx));
1344}
1345
1346void DwarfCompileUnit::createBaseTypeDIEs() {
1347 // Insert the base_type DIEs directly after the CU so that their offsets will
1348 // fit in the fixed size ULEB128 used inside the location expressions.
1349 // Maintain order by iterating backwards and inserting to the front of CU
1350 // child list.
1351 for (auto &Btr : reverse(ExprRefedBaseTypes)) {
1352 DIE &Die = getUnitDie().addChildFront(
1353 DIE::get(DIEValueAllocator, dwarf::DW_TAG_base_type));
1354 SmallString<32> Str;
1355 addString(Die, dwarf::DW_AT_name,
1356 Twine(dwarf::AttributeEncodingString(Btr.Encoding) +
1357 "_" + Twine(Btr.BitSize)).toStringRef(Str));
1358 addUInt(Die, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, Btr.Encoding);
1359 addUInt(Die, dwarf::DW_AT_byte_size, None, Btr.BitSize / 8);
1360
1361 Btr.Die = &Die;
1362 }
1363}