LLVM  7.0.0svn
DwarfUnit.cpp
Go to the documentation of this file.
1 //===-- llvm/CodeGen/DwarfUnit.cpp - Dwarf Type and Compile Units ---------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains support for constructing a dwarf compile unit.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "DwarfUnit.h"
15 #include "AddressPool.h"
16 #include "DwarfCompileUnit.h"
17 #include "DwarfDebug.h"
18 #include "DwarfExpression.h"
19 #include "llvm/ADT/APFloat.h"
20 #include "llvm/ADT/APInt.h"
21 #include "llvm/ADT/None.h"
22 #include "llvm/ADT/StringExtras.h"
29 #include "llvm/IR/Constants.h"
30 #include "llvm/IR/DataLayout.h"
31 #include "llvm/IR/GlobalValue.h"
32 #include "llvm/IR/Metadata.h"
33 #include "llvm/MC/MCAsmInfo.h"
34 #include "llvm/MC/MCContext.h"
35 #include "llvm/MC/MCDwarf.h"
36 #include "llvm/MC/MCSection.h"
37 #include "llvm/MC/MCStreamer.h"
39 #include "llvm/Support/Casting.h"
41 #include <cassert>
42 #include <cstdint>
43 #include <string>
44 #include <utility>
45 
46 using namespace llvm;
47 
48 #define DEBUG_TYPE "dwarfdebug"
49 
50 static cl::opt<bool>
51 GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
52  cl::desc("Generate DWARF4 type units."),
53  cl::init(false));
54 
56  DIELoc &DIE)
57  : DwarfExpression(AP.getDwarfVersion()), AP(AP), DU(DU),
58  DIE(DIE) {}
59 
60 void DIEDwarfExpression::emitOp(uint8_t Op, const char* Comment) {
61  DU.addUInt(DIE, dwarf::DW_FORM_data1, Op);
62 }
63 
64 void DIEDwarfExpression::emitSigned(int64_t Value) {
65  DU.addSInt(DIE, dwarf::DW_FORM_sdata, Value);
66 }
67 
68 void DIEDwarfExpression::emitUnsigned(uint64_t Value) {
69  DU.addUInt(DIE, dwarf::DW_FORM_udata, Value);
70 }
71 
72 bool DIEDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
73  unsigned MachineReg) {
74  return MachineReg == TRI.getFrameRegister(*AP.MF);
75 }
76 
78  AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
79  : DIEUnit(A->getDwarfVersion(), A->MAI->getCodePointerSize(), UnitTag),
80  CUNode(Node), Asm(A), DD(DW), DU(DWU), IndexTyDie(nullptr) {
81 }
82 
84  DwarfDebug *DW, DwarfFile *DWU,
85  MCDwarfDwoLineTable *SplitLineTable)
86  : DwarfUnit(dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU), CU(CU),
87  SplitLineTable(SplitLineTable) {
88  if (SplitLineTable)
89  addSectionOffset(getUnitDie(), dwarf::DW_AT_stmt_list, 0);
90 }
91 
93  for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
94  DIEBlocks[j]->~DIEBlock();
95  for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
96  DIELocs[j]->~DIELoc();
97 }
98 
99 int64_t DwarfUnit::getDefaultLowerBound() const {
100  switch (getLanguage()) {
101  default:
102  break;
103 
104  // The languages below have valid values in all DWARF versions.
105  case dwarf::DW_LANG_C:
106  case dwarf::DW_LANG_C89:
107  case dwarf::DW_LANG_C_plus_plus:
108  return 0;
109 
110  case dwarf::DW_LANG_Fortran77:
111  case dwarf::DW_LANG_Fortran90:
112  return 1;
113 
114  // The languages below have valid values only if the DWARF version >= 3.
115  case dwarf::DW_LANG_C99:
116  case dwarf::DW_LANG_ObjC:
117  case dwarf::DW_LANG_ObjC_plus_plus:
118  if (DD->getDwarfVersion() >= 3)
119  return 0;
120  break;
121 
122  case dwarf::DW_LANG_Fortran95:
123  if (DD->getDwarfVersion() >= 3)
124  return 1;
125  break;
126 
127  // Starting with DWARF v4, all defined languages have valid values.
128  case dwarf::DW_LANG_D:
129  case dwarf::DW_LANG_Java:
130  case dwarf::DW_LANG_Python:
131  case dwarf::DW_LANG_UPC:
132  if (DD->getDwarfVersion() >= 4)
133  return 0;
134  break;
135 
136  case dwarf::DW_LANG_Ada83:
137  case dwarf::DW_LANG_Ada95:
138  case dwarf::DW_LANG_Cobol74:
139  case dwarf::DW_LANG_Cobol85:
140  case dwarf::DW_LANG_Modula2:
141  case dwarf::DW_LANG_Pascal83:
142  case dwarf::DW_LANG_PLI:
143  if (DD->getDwarfVersion() >= 4)
144  return 1;
145  break;
146 
147  // The languages below are new in DWARF v5.
148  case dwarf::DW_LANG_BLISS:
149  case dwarf::DW_LANG_C11:
150  case dwarf::DW_LANG_C_plus_plus_03:
151  case dwarf::DW_LANG_C_plus_plus_11:
152  case dwarf::DW_LANG_C_plus_plus_14:
153  case dwarf::DW_LANG_Dylan:
154  case dwarf::DW_LANG_Go:
155  case dwarf::DW_LANG_Haskell:
156  case dwarf::DW_LANG_OCaml:
157  case dwarf::DW_LANG_OpenCL:
158  case dwarf::DW_LANG_RenderScript:
159  case dwarf::DW_LANG_Rust:
160  case dwarf::DW_LANG_Swift:
161  if (DD->getDwarfVersion() >= 5)
162  return 0;
163  break;
164 
165  case dwarf::DW_LANG_Fortran03:
166  case dwarf::DW_LANG_Fortran08:
167  case dwarf::DW_LANG_Julia:
168  case dwarf::DW_LANG_Modula3:
169  if (DD->getDwarfVersion() >= 5)
170  return 1;
171  break;
172  }
173 
174  return -1;
175 }
176 
177 /// Check whether the DIE for this MDNode can be shared across CUs.
179  // When the MDNode can be part of the type system, the DIE can be shared
180  // across CUs.
181  // Combining type units and cross-CU DIE sharing is lower value (since
182  // cross-CU DIE sharing is used in LTO and removes type redundancy at that
183  // level already) but may be implementable for some value in projects
184  // building multiple independent libraries with LTO and then linking those
185  // together.
186  if (isDwoUnit() && !DD->shareAcrossDWOCUs())
187  return false;
188  return (isa<DIType>(D) ||
189  (isa<DISubprogram>(D) && !cast<DISubprogram>(D)->isDefinition())) &&
191 }
192 
193 DIE *DwarfUnit::getDIE(const DINode *D) const {
194  if (isShareableAcrossCUs(D))
195  return DU->getDIE(D);
196  return MDNodeToDieMap.lookup(D);
197 }
198 
199 void DwarfUnit::insertDIE(const DINode *Desc, DIE *D) {
200  if (isShareableAcrossCUs(Desc)) {
201  DU->insertDIE(Desc, D);
202  return;
203  }
204  MDNodeToDieMap.insert(std::make_pair(Desc, D));
205 }
206 
208  if (DD->getDwarfVersion() >= 4)
209  Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag_present,
210  DIEInteger(1));
211  else
212  Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag,
213  DIEInteger(1));
214 }
215 
217  Optional<dwarf::Form> Form, uint64_t Integer) {
218  if (!Form)
219  Form = DIEInteger::BestForm(false, Integer);
220  assert(Form != dwarf::DW_FORM_implicit_const &&
221  "DW_FORM_implicit_const is used only for signed integers");
222  Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
223 }
224 
226  uint64_t Integer) {
227  addUInt(Block, (dwarf::Attribute)0, Form, Integer);
228 }
229 
232  if (!Form)
233  Form = DIEInteger::BestForm(true, Integer);
234  Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
235 }
236 
238  int64_t Integer) {
239  addSInt(Die, (dwarf::Attribute)0, Form, Integer);
240 }
241 
243  StringRef String) {
244  auto StringPoolEntry = DU->getStringPool().getEntry(*Asm, String);
245  dwarf::Form IxForm =
246  isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp;
247  // For DWARF v5 and beyond, use the smallest strx? form possible.
249  IxForm = dwarf::DW_FORM_strx1;
250  unsigned Index = StringPoolEntry.getIndex();
251  if (Index > 0xffffff)
252  IxForm = dwarf::DW_FORM_strx4;
253  else if (Index > 0xffff)
254  IxForm = dwarf::DW_FORM_strx3;
255  else if (Index > 0xff)
256  IxForm = dwarf::DW_FORM_strx2;
257  }
258  Die.addValue(DIEValueAllocator, Attribute, IxForm,
259  DIEString(StringPoolEntry));
260 }
261 
265  const MCSymbol *Label) {
266  return Die.addValue(DIEValueAllocator, Attribute, Form, DIELabel(Label));
267 }
268 
270  addLabel(Die, (dwarf::Attribute)0, Form, Label);
271 }
272 
274  uint64_t Integer) {
275  if (DD->getDwarfVersion() >= 4)
276  addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
277  else
278  addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
279 }
280 
282  assert(File);
283  Optional<DIFile::ChecksumInfo<StringRef>> Checksum = File->getChecksum();
284  if (!Checksum || Checksum->Kind != DIFile::CSK_MD5)
285  return nullptr;
286 
287  // Convert the string checksum to an MD5Result for the streamer.
288  // The verifier validates the checksum so we assume it's okay.
289  // An MD5 checksum is 16 bytes.
290  std::string ChecksumString = fromHex(Checksum->Value);
291  void *CKMem = Asm->OutStreamer->getContext().allocate(16, 1);
292  memcpy(CKMem, ChecksumString.data(), 16);
293  return reinterpret_cast<MD5::MD5Result *>(CKMem);
294 }
295 
296 unsigned DwarfTypeUnit::getOrCreateSourceID(const DIFile *File) {
297  return SplitLineTable
298  ? SplitLineTable->getFile(File->getDirectory(),
299  File->getFilename(), getMD5AsBytes(File))
300  : getCU().getOrCreateSourceID(File);
301 }
302 
303 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
304  if (!DD->useSplitDwarf()) {
305  addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
306  addLabel(Die, dwarf::DW_FORM_udata, Sym);
307  } else {
308  addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
309  addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
310  DD->getAddressPool().getIndex(Sym));
311  }
312 }
313 
315  const MCSymbol *Hi, const MCSymbol *Lo) {
316  Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_data4,
317  new (DIEValueAllocator) DIEDelta(Hi, Lo));
318 }
319 
321  addDIEEntry(Die, Attribute, DIEEntry(Entry));
322 }
323 
324 void DwarfUnit::addDIETypeSignature(DIE &Die, uint64_t Signature) {
325  // Flag the type unit reference as a declaration so that if it contains
326  // members (implicit special members, static data member definitions, member
327  // declarations for definitions in this CU, etc) consumers don't get confused
328  // and think this is a full definition.
329  addFlag(Die, dwarf::DW_AT_declaration);
330 
331  Die.addValue(DIEValueAllocator, dwarf::DW_AT_signature,
332  dwarf::DW_FORM_ref_sig8, DIEInteger(Signature));
333 }
334 
336  DIEEntry Entry) {
337  const DIEUnit *CU = Die.getUnit();
338  const DIEUnit *EntryCU = Entry.getEntry().getUnit();
339  if (!CU)
340  // We assume that Die belongs to this CU, if it is not linked to any CU yet.
341  CU = getUnitDie().getUnit();
342  if (!EntryCU)
343  EntryCU = getUnitDie().getUnit();
344  Die.addValue(DIEValueAllocator, Attribute,
345  EntryCU == CU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
346  Entry);
347 }
348 
349 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N) {
350  DIE &Die = Parent.addChild(DIE::get(DIEValueAllocator, (dwarf::Tag)Tag));
351  if (N)
352  insertDIE(N, &Die);
353  return Die;
354 }
355 
357  Loc->ComputeSize(Asm);
358  DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
359  Die.addValue(DIEValueAllocator, Attribute,
360  Loc->BestForm(DD->getDwarfVersion()), Loc);
361 }
362 
364  DIEBlock *Block) {
365  Block->ComputeSize(Asm);
366  DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
367  Die.addValue(DIEValueAllocator, Attribute, Block->BestForm(), Block);
368 }
369 
370 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, const DIFile *File) {
371  if (Line == 0)
372  return;
373 
374  unsigned FileID = getOrCreateSourceID(File);
375  assert(FileID && "Invalid file id");
376  addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
377  addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
378 }
379 
381  assert(V);
382 
383  addSourceLine(Die, V->getLine(), V->getFile());
384 }
385 
387  assert(G);
388 
389  addSourceLine(Die, G->getLine(), G->getFile());
390 }
391 
393  assert(SP);
394 
395  addSourceLine(Die, SP->getLine(), SP->getFile());
396 }
397 
398 void DwarfUnit::addSourceLine(DIE &Die, const DIType *Ty) {
399  assert(Ty);
400 
401  addSourceLine(Die, Ty->getLine(), Ty->getFile());
402 }
403 
405  assert(Ty);
406 
407  addSourceLine(Die, Ty->getLine(), Ty->getFile());
408 }
409 
410 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
411  VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
412  gives the variable VarName either the struct, or a pointer to the struct, as
413  its type. This is necessary for various behind-the-scenes things the
414  compiler needs to do with by-reference variables in Blocks.
415 
416  However, as far as the original *programmer* is concerned, the variable
417  should still have type 'SomeType', as originally declared.
418 
419  The function getBlockByrefType dives into the __Block_byref_x_VarName
420  struct to find the original type of the variable, which is then assigned to
421  the variable's Debug Information Entry as its real type. So far, so good.
422  However now the debugger will expect the variable VarName to have the type
423  SomeType. So we need the location attribute for the variable to be an
424  expression that explains to the debugger how to navigate through the
425  pointers and struct to find the actual variable of type SomeType.
426 
427  The following function does just that. We start by getting
428  the "normal" location for the variable. This will be the location
429  of either the struct __Block_byref_x_VarName or the pointer to the
430  struct __Block_byref_x_VarName.
431 
432  The struct will look something like:
433 
434  struct __Block_byref_x_VarName {
435  ... <various fields>
436  struct __Block_byref_x_VarName *forwarding;
437  ... <various other fields>
438  SomeType VarName;
439  ... <maybe more fields>
440  };
441 
442  If we are given the struct directly (as our starting point) we
443  need to tell the debugger to:
444 
445  1). Add the offset of the forwarding field.
446 
447  2). Follow that pointer to get the real __Block_byref_x_VarName
448  struct to use (the real one may have been copied onto the heap).
449 
450  3). Add the offset for the field VarName, to find the actual variable.
451 
452  If we started with a pointer to the struct, then we need to
453  dereference that pointer first, before the other steps.
454  Translating this into DWARF ops, we will need to append the following
455  to the current location description for the variable:
456 
457  DW_OP_deref -- optional, if we start with a pointer
458  DW_OP_plus_uconst <forward_fld_offset>
459  DW_OP_deref
460  DW_OP_plus_uconst <varName_fld_offset>
461 
462  That is what this function does. */
463 
466  const MachineLocation &Location) {
467  const DIType *Ty = DV.getType();
468  const DIType *TmpTy = Ty;
469  uint16_t Tag = Ty->getTag();
470  bool isPointer = false;
471 
472  StringRef varName = DV.getName();
473 
474  if (Tag == dwarf::DW_TAG_pointer_type) {
475  auto *DTy = cast<DIDerivedType>(Ty);
476  TmpTy = resolve(DTy->getBaseType());
477  isPointer = true;
478  }
479 
480  // Find the __forwarding field and the variable field in the __Block_byref
481  // struct.
482  DINodeArray Fields = cast<DICompositeType>(TmpTy)->getElements();
483  const DIDerivedType *varField = nullptr;
484  const DIDerivedType *forwardingField = nullptr;
485 
486  for (unsigned i = 0, N = Fields.size(); i < N; ++i) {
487  auto *DT = cast<DIDerivedType>(Fields[i]);
488  StringRef fieldName = DT->getName();
489  if (fieldName == "__forwarding")
490  forwardingField = DT;
491  else if (fieldName == varName)
492  varField = DT;
493  }
494 
495  // Get the offsets for the forwarding field and the variable field.
496  unsigned forwardingFieldOffset = forwardingField->getOffsetInBits() >> 3;
497  unsigned varFieldOffset = varField->getOffsetInBits() >> 2;
498 
499  // Decode the original location, and use that as the start of the byref
500  // variable's location.
501  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
502  DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
503  if (Location.isIndirect())
504  DwarfExpr.setMemoryLocationKind();
505 
507  // If we started with a pointer to the __Block_byref... struct, then
508  // the first thing we need to do is dereference the pointer (DW_OP_deref).
509  if (isPointer)
510  Ops.push_back(dwarf::DW_OP_deref);
511 
512  // Next add the offset for the '__forwarding' field:
513  // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
514  // adding the offset if it's 0.
515  if (forwardingFieldOffset > 0) {
516  Ops.push_back(dwarf::DW_OP_plus_uconst);
517  Ops.push_back(forwardingFieldOffset);
518  }
519 
520  // Now dereference the __forwarding field to get to the real __Block_byref
521  // struct: DW_OP_deref.
522  Ops.push_back(dwarf::DW_OP_deref);
523 
524  // Now that we've got the real __Block_byref... struct, add the offset
525  // for the variable's field to get to the location of the actual variable:
526  // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
527  if (varFieldOffset > 0) {
528  Ops.push_back(dwarf::DW_OP_plus_uconst);
529  Ops.push_back(varFieldOffset);
530  }
531 
532  DIExpressionCursor Cursor(Ops);
534  if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
535  return;
536  DwarfExpr.addExpression(std::move(Cursor));
537 
538  // Now attach the location information to the DIE.
539  addBlock(Die, Attribute, DwarfExpr.finalize());
540 }
541 
542 /// Return true if type encoding is unsigned.
543 static bool isUnsignedDIType(DwarfDebug *DD, const DIType *Ty) {
544  if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
545  // FIXME: Enums without a fixed underlying type have unknown signedness
546  // here, leading to incorrectly emitted constants.
547  if (CTy->getTag() == dwarf::DW_TAG_enumeration_type)
548  return false;
549 
550  // (Pieces of) aggregate types that get hacked apart by SROA may be
551  // represented by a constant. Encode them as unsigned bytes.
552  return true;
553  }
554 
555  if (auto *DTy = dyn_cast<DIDerivedType>(Ty)) {
556  dwarf::Tag T = (dwarf::Tag)Ty->getTag();
557  // Encode pointer constants as unsigned bytes. This is used at least for
558  // null pointer constant emission.
559  // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
560  // here, but accept them for now due to a bug in SROA producing bogus
561  // dbg.values.
562  if (T == dwarf::DW_TAG_pointer_type ||
563  T == dwarf::DW_TAG_ptr_to_member_type ||
564  T == dwarf::DW_TAG_reference_type ||
565  T == dwarf::DW_TAG_rvalue_reference_type)
566  return true;
567  assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
568  T == dwarf::DW_TAG_volatile_type ||
569  T == dwarf::DW_TAG_restrict_type || T == dwarf::DW_TAG_atomic_type);
570  DITypeRef Deriv = DTy->getBaseType();
571  assert(Deriv && "Expected valid base type");
572  return isUnsignedDIType(DD, DD->resolve(Deriv));
573  }
574 
575  auto *BTy = cast<DIBasicType>(Ty);
576  unsigned Encoding = BTy->getEncoding();
577  assert((Encoding == dwarf::DW_ATE_unsigned ||
578  Encoding == dwarf::DW_ATE_unsigned_char ||
579  Encoding == dwarf::DW_ATE_signed ||
580  Encoding == dwarf::DW_ATE_signed_char ||
581  Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF ||
582  Encoding == dwarf::DW_ATE_boolean ||
583  (Ty->getTag() == dwarf::DW_TAG_unspecified_type &&
584  Ty->getName() == "decltype(nullptr)")) &&
585  "Unsupported encoding");
586  return Encoding == dwarf::DW_ATE_unsigned ||
587  Encoding == dwarf::DW_ATE_unsigned_char ||
588  Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
589  Ty->getTag() == dwarf::DW_TAG_unspecified_type;
590 }
591 
593  assert(MO.isFPImm() && "Invalid machine operand!");
594  DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
595  APFloat FPImm = MO.getFPImm()->getValueAPF();
596 
597  // Get the raw data form of the floating point.
598  const APInt FltVal = FPImm.bitcastToAPInt();
599  const char *FltPtr = (const char *)FltVal.getRawData();
600 
601  int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
602  bool LittleEndian = Asm->getDataLayout().isLittleEndian();
603  int Incr = (LittleEndian ? 1 : -1);
604  int Start = (LittleEndian ? 0 : NumBytes - 1);
605  int Stop = (LittleEndian ? NumBytes : -1);
606 
607  // Output the constant to DWARF one byte at a time.
608  for (; Start != Stop; Start += Incr)
609  addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
610 
611  addBlock(Die, dwarf::DW_AT_const_value, Block);
612 }
613 
615  // Pass this down to addConstantValue as an unsigned bag of bits.
616  addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
617 }
618 
620  const DIType *Ty) {
621  addConstantValue(Die, CI->getValue(), Ty);
622 }
623 
625  const DIType *Ty) {
626  assert(MO.isImm() && "Invalid machine operand!");
627 
628  addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
629 }
630 
631 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
632  // FIXME: This is a bit conservative/simple - it emits negative values always
633  // sign extended to 64 bits rather than minimizing the number of bytes.
634  addUInt(Die, dwarf::DW_AT_const_value,
635  Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
636 }
637 
638 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty) {
639  addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
640 }
641 
642 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
643  unsigned CIBitWidth = Val.getBitWidth();
644  if (CIBitWidth <= 64) {
645  addConstantValue(Die, Unsigned,
646  Unsigned ? Val.getZExtValue() : Val.getSExtValue());
647  return;
648  }
649 
650  DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
651 
652  // Get the raw data form of the large APInt.
653  const uint64_t *Ptr64 = Val.getRawData();
654 
655  int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
656  bool LittleEndian = Asm->getDataLayout().isLittleEndian();
657 
658  // Output the constant to DWARF one byte at a time.
659  for (int i = 0; i < NumBytes; i++) {
660  uint8_t c;
661  if (LittleEndian)
662  c = Ptr64[i / 8] >> (8 * (i & 7));
663  else
664  c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
665  addUInt(*Block, dwarf::DW_FORM_data1, c);
666  }
667 
668  addBlock(Die, dwarf::DW_AT_const_value, Block);
669 }
670 
672  if (!LinkageName.empty())
673  addString(Die,
674  DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
675  : dwarf::DW_AT_MIPS_linkage_name,
677 }
678 
679 void DwarfUnit::addTemplateParams(DIE &Buffer, DINodeArray TParams) {
680  // Add template parameters.
681  for (const auto *Element : TParams) {
682  if (auto *TTP = dyn_cast<DITemplateTypeParameter>(Element))
683  constructTemplateTypeParameterDIE(Buffer, TTP);
684  else if (auto *TVP = dyn_cast<DITemplateValueParameter>(Element))
685  constructTemplateValueParameterDIE(Buffer, TVP);
686  }
687 }
688 
689 /// Add thrown types.
690 void DwarfUnit::addThrownTypes(DIE &Die, DINodeArray ThrownTypes) {
691  for (const auto *Ty : ThrownTypes) {
692  DIE &TT = createAndAddDIE(dwarf::DW_TAG_thrown_type, Die);
693  addType(TT, cast<DIType>(Ty));
694  }
695 }
696 
698  if (!Context || isa<DIFile>(Context))
699  return &getUnitDie();
700  if (auto *T = dyn_cast<DIType>(Context))
701  return getOrCreateTypeDIE(T);
702  if (auto *NS = dyn_cast<DINamespace>(Context))
703  return getOrCreateNameSpace(NS);
704  if (auto *SP = dyn_cast<DISubprogram>(Context))
706  if (auto *M = dyn_cast<DIModule>(Context))
707  return getOrCreateModule(M);
708  return getDIE(Context);
709 }
710 
712  auto *Context = resolve(Ty->getScope());
713  DIE *ContextDIE = getOrCreateContextDIE(Context);
714 
715  if (DIE *TyDIE = getDIE(Ty))
716  return TyDIE;
717 
718  // Create new type.
719  DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
720 
721  constructTypeDIE(TyDIE, cast<DICompositeType>(Ty));
722 
723  updateAcceleratorTables(Context, Ty, TyDIE);
724  return &TyDIE;
725 }
726 
728  if (!TyNode)
729  return nullptr;
730 
731  auto *Ty = cast<DIType>(TyNode);
732 
733  // DW_TAG_restrict_type is not supported in DWARF2
734  if (Ty->getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
735  return getOrCreateTypeDIE(resolve(cast<DIDerivedType>(Ty)->getBaseType()));
736 
737  // DW_TAG_atomic_type is not supported in DWARF < 5
738  if (Ty->getTag() == dwarf::DW_TAG_atomic_type && DD->getDwarfVersion() < 5)
739  return getOrCreateTypeDIE(resolve(cast<DIDerivedType>(Ty)->getBaseType()));
740 
741  // Construct the context before querying for the existence of the DIE in case
742  // such construction creates the DIE.
743  auto *Context = resolve(Ty->getScope());
744  DIE *ContextDIE = getOrCreateContextDIE(Context);
745  assert(ContextDIE);
746 
747  if (DIE *TyDIE = getDIE(Ty))
748  return TyDIE;
749 
750  // Create new type.
751  DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
752 
753  updateAcceleratorTables(Context, Ty, TyDIE);
754 
755  if (auto *BT = dyn_cast<DIBasicType>(Ty))
756  constructTypeDIE(TyDIE, BT);
757  else if (auto *STy = dyn_cast<DISubroutineType>(Ty))
758  constructTypeDIE(TyDIE, STy);
759  else if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
760  if (GenerateDwarfTypeUnits && !Ty->isForwardDecl())
761  if (MDString *TypeId = CTy->getRawIdentifier()) {
762  DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
763  // Skip updating the accelerator tables since this is not the full type.
764  return &TyDIE;
765  }
766  constructTypeDIE(TyDIE, CTy);
767  } else {
768  constructTypeDIE(TyDIE, cast<DIDerivedType>(Ty));
769  }
770 
771  return &TyDIE;
772 }
773 
775  const DIType *Ty, const DIE &TyDIE) {
776  if (!Ty->getName().empty() && !Ty->isForwardDecl()) {
777  bool IsImplementation = false;
778  if (auto *CT = dyn_cast<DICompositeType>(Ty)) {
779  // A runtime language of 0 actually means C/C++ and that any
780  // non-negative value is some version of Objective-C/C++.
781  IsImplementation = CT->getRuntimeLang() == 0 || CT->isObjcClassComplete();
782  }
783  unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
784  DD->addAccelType(Ty->getName(), TyDIE, Flags);
785 
786  if (!Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
787  isa<DINamespace>(Context))
788  addGlobalType(Ty, TyDIE, Context);
789  }
790 }
791 
792 void DwarfUnit::addType(DIE &Entity, const DIType *Ty,
794  assert(Ty && "Trying to add a type that doesn't exist?");
795  addDIEEntry(Entity, Attribute, DIEEntry(*getOrCreateTypeDIE(Ty)));
796 }
797 
799  if (!Context)
800  return "";
801 
802  // FIXME: Decide whether to implement this for non-C++ languages.
803  if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
804  return "";
805 
806  std::string CS;
808  while (!isa<DICompileUnit>(Context)) {
809  Parents.push_back(Context);
810  if (Context->getScope())
811  Context = resolve(Context->getScope());
812  else
813  // Structure, etc types will have a NULL context if they're at the top
814  // level.
815  break;
816  }
817 
818  // Reverse iterate over our list to go from the outermost construct to the
819  // innermost.
820  for (const DIScope *Ctx : make_range(Parents.rbegin(), Parents.rend())) {
821  StringRef Name = Ctx->getName();
822  if (Name.empty() && isa<DINamespace>(Ctx))
823  Name = "(anonymous namespace)";
824  if (!Name.empty()) {
825  CS += Name;
826  CS += "::";
827  }
828  }
829  return CS;
830 }
831 
832 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
833  // Get core information.
834  StringRef Name = BTy->getName();
835  // Add name if not anonymous or intermediate type.
836  if (!Name.empty())
837  addString(Buffer, dwarf::DW_AT_name, Name);
838 
839  // An unspecified type only has a name attribute.
840  if (BTy->getTag() == dwarf::DW_TAG_unspecified_type)
841  return;
842 
843  addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
844  BTy->getEncoding());
845 
846  uint64_t Size = BTy->getSizeInBits() >> 3;
847  addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
848 }
849 
850 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy) {
851  // Get core information.
852  StringRef Name = DTy->getName();
853  uint64_t Size = DTy->getSizeInBits() >> 3;
854  uint16_t Tag = Buffer.getTag();
855 
856  // Map to main type, void will not have a type.
857  const DIType *FromTy = resolve(DTy->getBaseType());
858  if (FromTy)
859  addType(Buffer, FromTy);
860 
861  // Add name if not anonymous or intermediate type.
862  if (!Name.empty())
863  addString(Buffer, dwarf::DW_AT_name, Name);
864 
865  // Add size if non-zero (derived types might be zero-sized.)
866  if (Size && Tag != dwarf::DW_TAG_pointer_type
867  && Tag != dwarf::DW_TAG_ptr_to_member_type
868  && Tag != dwarf::DW_TAG_reference_type
869  && Tag != dwarf::DW_TAG_rvalue_reference_type)
870  addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
871 
872  if (Tag == dwarf::DW_TAG_ptr_to_member_type)
873  addDIEEntry(
874  Buffer, dwarf::DW_AT_containing_type,
875  *getOrCreateTypeDIE(resolve(cast<DIDerivedType>(DTy)->getClassType())));
876  // Add source line info if available and TyDesc is not a forward declaration.
877  if (!DTy->isForwardDecl())
878  addSourceLine(Buffer, DTy);
879 
880  // If DWARF address space value is other than None, add it for pointer and
881  // reference types as DW_AT_address_class.
882  if (DTy->getDWARFAddressSpace() && (Tag == dwarf::DW_TAG_pointer_type ||
883  Tag == dwarf::DW_TAG_reference_type))
884  addUInt(Buffer, dwarf::DW_AT_address_class, dwarf::DW_FORM_data4,
885  DTy->getDWARFAddressSpace().getValue());
886 }
887 
889  for (unsigned i = 1, N = Args.size(); i < N; ++i) {
890  const DIType *Ty = resolve(Args[i]);
891  if (!Ty) {
892  assert(i == N-1 && "Unspecified parameter must be the last argument");
893  createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
894  } else {
895  DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
896  addType(Arg, Ty);
897  if (Ty->isArtificial())
898  addFlag(Arg, dwarf::DW_AT_artificial);
899  }
900  }
901 }
902 
903 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DISubroutineType *CTy) {
904  // Add return type. A void return won't have a type.
905  auto Elements = cast<DISubroutineType>(CTy)->getTypeArray();
906  if (Elements.size())
907  if (auto RTy = resolve(Elements[0]))
908  addType(Buffer, RTy);
909 
910  bool isPrototyped = true;
911  if (Elements.size() == 2 && !Elements[1])
912  isPrototyped = false;
913 
914  constructSubprogramArguments(Buffer, Elements);
915 
916  // Add prototype flag if we're dealing with a C language and the function has
917  // been prototyped.
918  uint16_t Language = getLanguage();
919  if (isPrototyped &&
920  (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
921  Language == dwarf::DW_LANG_ObjC))
922  addFlag(Buffer, dwarf::DW_AT_prototyped);
923 
924  // Add a DW_AT_calling_convention if this has an explicit convention.
925  if (CTy->getCC() && CTy->getCC() != dwarf::DW_CC_normal)
926  addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
927  CTy->getCC());
928 
929  if (CTy->isLValueReference())
930  addFlag(Buffer, dwarf::DW_AT_reference);
931 
932  if (CTy->isRValueReference())
933  addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
934 }
935 
937  // Add name if not anonymous or intermediate type.
938  StringRef Name = CTy->getName();
939 
940  uint64_t Size = CTy->getSizeInBits() >> 3;
941  uint16_t Tag = Buffer.getTag();
942 
943  switch (Tag) {
944  case dwarf::DW_TAG_array_type:
945  constructArrayTypeDIE(Buffer, CTy);
946  break;
947  case dwarf::DW_TAG_enumeration_type:
948  constructEnumTypeDIE(Buffer, CTy);
949  break;
950  case dwarf::DW_TAG_variant_part:
951  case dwarf::DW_TAG_structure_type:
952  case dwarf::DW_TAG_union_type:
953  case dwarf::DW_TAG_class_type: {
954  // Emit the discriminator for a variant part.
955  DIDerivedType *Discriminator = nullptr;
956  if (Tag == dwarf::DW_TAG_variant_part) {
957  Discriminator = CTy->getDiscriminator();
958  if (Discriminator) {
959  // DWARF says:
960  // If the variant part has a discriminant, the discriminant is
961  // represented by a separate debugging information entry which is
962  // a child of the variant part entry.
963  DIE &DiscMember = constructMemberDIE(Buffer, Discriminator);
964  addDIEEntry(Buffer, dwarf::DW_AT_discr, DiscMember);
965  }
966  }
967 
968  // Add elements to structure type.
969  DINodeArray Elements = CTy->getElements();
970  for (const auto *Element : Elements) {
971  if (!Element)
972  continue;
973  if (auto *SP = dyn_cast<DISubprogram>(Element))
975  else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
976  if (DDTy->getTag() == dwarf::DW_TAG_friend) {
977  DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
978  addType(ElemDie, resolve(DDTy->getBaseType()), dwarf::DW_AT_friend);
979  } else if (DDTy->isStaticMember()) {
981  } else if (Tag == dwarf::DW_TAG_variant_part) {
982  // When emitting a variant part, wrap each member in
983  // DW_TAG_variant.
984  DIE &Variant = createAndAddDIE(dwarf::DW_TAG_variant, Buffer);
985  if (const ConstantInt *CI =
986  dyn_cast_or_null<ConstantInt>(DDTy->getDiscriminantValue())) {
987  if (isUnsignedDIType(DD, resolve(Discriminator->getBaseType())))
988  addUInt(Variant, dwarf::DW_AT_discr_value, None, CI->getZExtValue());
989  else
990  addSInt(Variant, dwarf::DW_AT_discr_value, None, CI->getSExtValue());
991  }
992  constructMemberDIE(Variant, DDTy);
993  } else {
994  constructMemberDIE(Buffer, DDTy);
995  }
996  } else if (auto *Property = dyn_cast<DIObjCProperty>(Element)) {
997  DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer);
998  StringRef PropertyName = Property->getName();
999  addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1000  if (Property->getType())
1001  addType(ElemDie, resolve(Property->getType()));
1002  addSourceLine(ElemDie, Property);
1003  StringRef GetterName = Property->getGetterName();
1004  if (!GetterName.empty())
1005  addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1006  StringRef SetterName = Property->getSetterName();
1007  if (!SetterName.empty())
1008  addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1009  if (unsigned PropertyAttributes = Property->getAttributes())
1010  addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1011  PropertyAttributes);
1012  } else if (auto *Composite = dyn_cast<DICompositeType>(Element)) {
1013  if (Composite->getTag() == dwarf::DW_TAG_variant_part) {
1014  DIE &VariantPart = createAndAddDIE(Composite->getTag(), Buffer);
1015  constructTypeDIE(VariantPart, Composite);
1016  }
1017  }
1018  }
1019 
1020  if (CTy->isAppleBlockExtension())
1021  addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1022 
1023  // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
1024  // inside C++ composite types to point to the base class with the vtable.
1025  // Rust uses DW_AT_containing_type to link a vtable to the type
1026  // for which it was created.
1027  if (auto *ContainingType = resolve(CTy->getVTableHolder()))
1028  addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1029  *getOrCreateTypeDIE(ContainingType));
1030 
1031  if (CTy->isObjcClassComplete())
1032  addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1033 
1034  // Add template parameters to a class, structure or union types.
1035  // FIXME: The support isn't in the metadata for this yet.
1036  if (Tag == dwarf::DW_TAG_class_type ||
1037  Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1038  addTemplateParams(Buffer, CTy->getTemplateParams());
1039 
1040  // Add the type's non-standard calling convention.
1041  uint8_t CC = 0;
1042  if (CTy->isTypePassByValue())
1043  CC = dwarf::DW_CC_pass_by_value;
1044  else if (CTy->isTypePassByReference())
1045  CC = dwarf::DW_CC_pass_by_reference;
1046  if (CC)
1047  addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
1048  CC);
1049  break;
1050  }
1051  default:
1052  break;
1053  }
1054 
1055  // Add name if not anonymous or intermediate type.
1056  if (!Name.empty())
1057  addString(Buffer, dwarf::DW_AT_name, Name);
1058 
1059  if (Tag == dwarf::DW_TAG_enumeration_type ||
1060  Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1061  Tag == dwarf::DW_TAG_union_type) {
1062  // Add size if non-zero (derived types might be zero-sized.)
1063  // TODO: Do we care about size for enum forward declarations?
1064  if (Size)
1065  addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1066  else if (!CTy->isForwardDecl())
1067  // Add zero size if it is not a forward declaration.
1068  addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1069 
1070  // If we're a forward decl, say so.
1071  if (CTy->isForwardDecl())
1072  addFlag(Buffer, dwarf::DW_AT_declaration);
1073 
1074  // Add source line info if available.
1075  if (!CTy->isForwardDecl())
1076  addSourceLine(Buffer, CTy);
1077 
1078  // No harm in adding the runtime language to the declaration.
1079  unsigned RLang = CTy->getRuntimeLang();
1080  if (RLang)
1081  addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1082  RLang);
1083 
1084  // Add align info if available.
1085  if (uint32_t AlignInBytes = CTy->getAlignInBytes())
1086  addUInt(Buffer, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1087  AlignInBytes);
1088  }
1089 }
1090 
1091 void DwarfUnit::constructTemplateTypeParameterDIE(
1092  DIE &Buffer, const DITemplateTypeParameter *TP) {
1093  DIE &ParamDIE =
1094  createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1095  // Add the type if it exists, it could be void and therefore no type.
1096  if (TP->getType())
1097  addType(ParamDIE, resolve(TP->getType()));
1098  if (!TP->getName().empty())
1099  addString(ParamDIE, dwarf::DW_AT_name, TP->getName());
1100 }
1101 
1102 void DwarfUnit::constructTemplateValueParameterDIE(
1103  DIE &Buffer, const DITemplateValueParameter *VP) {
1104  DIE &ParamDIE = createAndAddDIE(VP->getTag(), Buffer);
1105 
1106  // Add the type if there is one, template template and template parameter
1107  // packs will not have a type.
1108  if (VP->getTag() == dwarf::DW_TAG_template_value_parameter)
1109  addType(ParamDIE, resolve(VP->getType()));
1110  if (!VP->getName().empty())
1111  addString(ParamDIE, dwarf::DW_AT_name, VP->getName());
1112  if (Metadata *Val = VP->getValue()) {
1113  if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1114  addConstantValue(ParamDIE, CI, resolve(VP->getType()));
1115  else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1116  // We cannot describe the location of dllimport'd entities: the
1117  // computation of their address requires loads from the IAT.
1118  if (!GV->hasDLLImportStorageClass()) {
1119  // For declaration non-type template parameters (such as global values
1120  // and functions)
1121  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1122  addOpAddress(*Loc, Asm->getSymbol(GV));
1123  // Emit DW_OP_stack_value to use the address as the immediate value of
1124  // the parameter, rather than a pointer to it.
1125  addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1126  addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1127  }
1128  } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1129  assert(isa<MDString>(Val));
1130  addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1131  cast<MDString>(Val)->getString());
1132  } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1133  addTemplateParams(ParamDIE, cast<MDTuple>(Val));
1134  }
1135  }
1136 }
1137 
1139  // Construct the context before querying for the existence of the DIE in case
1140  // such construction creates the DIE.
1141  DIE *ContextDIE = getOrCreateContextDIE(NS->getScope());
1142 
1143  if (DIE *NDie = getDIE(NS))
1144  return NDie;
1145  DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1146 
1147  StringRef Name = NS->getName();
1148  if (!Name.empty())
1149  addString(NDie, dwarf::DW_AT_name, NS->getName());
1150  else
1151  Name = "(anonymous namespace)";
1152  DD->addAccelNamespace(Name, NDie);
1153  addGlobalName(Name, NDie, NS->getScope());
1154  if (NS->getExportSymbols())
1155  addFlag(NDie, dwarf::DW_AT_export_symbols);
1156  return &NDie;
1157 }
1158 
1160  // Construct the context before querying for the existence of the DIE in case
1161  // such construction creates the DIE.
1162  DIE *ContextDIE = getOrCreateContextDIE(M->getScope());
1163 
1164  if (DIE *MDie = getDIE(M))
1165  return MDie;
1166  DIE &MDie = createAndAddDIE(dwarf::DW_TAG_module, *ContextDIE, M);
1167 
1168  if (!M->getName().empty()) {
1169  addString(MDie, dwarf::DW_AT_name, M->getName());
1170  addGlobalName(M->getName(), MDie, M->getScope());
1171  }
1172  if (!M->getConfigurationMacros().empty())
1173  addString(MDie, dwarf::DW_AT_LLVM_config_macros,
1174  M->getConfigurationMacros());
1175  if (!M->getIncludePath().empty())
1176  addString(MDie, dwarf::DW_AT_LLVM_include_path, M->getIncludePath());
1177  if (!M->getISysRoot().empty())
1178  addString(MDie, dwarf::DW_AT_LLVM_isysroot, M->getISysRoot());
1179 
1180  return &MDie;
1181 }
1182 
1184  // Construct the context before querying for the existence of the DIE in case
1185  // such construction creates the DIE (as is the case for member function
1186  // declarations).
1187  DIE *ContextDIE =
1188  Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP->getScope()));
1189 
1190  if (DIE *SPDie = getDIE(SP))
1191  return SPDie;
1192 
1193  if (auto *SPDecl = SP->getDeclaration()) {
1194  if (!Minimal) {
1195  // Add subprogram definitions to the CU die directly.
1196  ContextDIE = &getUnitDie();
1197  // Build the decl now to ensure it precedes the definition.
1198  getOrCreateSubprogramDIE(SPDecl);
1199  }
1200  }
1201 
1202  // DW_TAG_inlined_subroutine may refer to this DIE.
1203  DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1204 
1205  // Stop here and fill this in later, depending on whether or not this
1206  // subprogram turns out to have inlined instances or not.
1207  if (SP->isDefinition())
1208  return &SPDie;
1209 
1210  applySubprogramAttributes(SP, SPDie);
1211  return &SPDie;
1212 }
1213 
1215  DIE &SPDie) {
1216  DIE *DeclDie = nullptr;
1217  StringRef DeclLinkageName;
1218  if (auto *SPDecl = SP->getDeclaration()) {
1219  DeclDie = getDIE(SPDecl);
1220  assert(DeclDie && "This DIE should've already been constructed when the "
1221  "definition DIE was created in "
1222  "getOrCreateSubprogramDIE");
1223  // Look at the Decl's linkage name only if we emitted it.
1224  if (DD->useAllLinkageNames())
1225  DeclLinkageName = SPDecl->getLinkageName();
1226  unsigned DeclID = getOrCreateSourceID(SPDecl->getFile());
1227  unsigned DefID = getOrCreateSourceID(SP->getFile());
1228  if (DeclID != DefID)
1229  addUInt(SPDie, dwarf::DW_AT_decl_file, None, DefID);
1230 
1231  if (SP->getLine() != SPDecl->getLine())
1232  addUInt(SPDie, dwarf::DW_AT_decl_line, None, SP->getLine());
1233  }
1234 
1235  // Add function template parameters.
1236  addTemplateParams(SPDie, SP->getTemplateParams());
1237 
1238  // Add the linkage name if we have one and it isn't in the Decl.
1239  StringRef LinkageName = SP->getLinkageName();
1240  assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1241  LinkageName == DeclLinkageName) &&
1242  "decl has a linkage name and it is different");
1243  if (DeclLinkageName.empty() &&
1244  // Always emit it for abstract subprograms.
1245  (DD->useAllLinkageNames() || DU->getAbstractSPDies().lookup(SP)))
1246  addLinkageName(SPDie, LinkageName);
1247 
1248  if (!DeclDie)
1249  return false;
1250 
1251  // Refer to the function declaration where all the other attributes will be
1252  // found.
1253  addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1254  return true;
1255 }
1256 
1258  bool SkipSPAttributes) {
1259  // If -fdebug-info-for-profiling is enabled, need to emit the subprogram
1260  // and its source location.
1261  bool SkipSPSourceLocation = SkipSPAttributes &&
1263  if (!SkipSPSourceLocation)
1264  if (applySubprogramDefinitionAttributes(SP, SPDie))
1265  return;
1266 
1267  // Constructors and operators for anonymous aggregates do not have names.
1268  if (!SP->getName().empty())
1269  addString(SPDie, dwarf::DW_AT_name, SP->getName());
1270 
1271  if (!SkipSPSourceLocation)
1272  addSourceLine(SPDie, SP);
1273 
1274  // Skip the rest of the attributes under -gmlt to save space.
1275  if (SkipSPAttributes)
1276  return;
1277 
1278  // Add the prototype if we have a prototype and we have a C like
1279  // language.
1280  uint16_t Language = getLanguage();
1281  if (SP->isPrototyped() &&
1282  (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1283  Language == dwarf::DW_LANG_ObjC))
1284  addFlag(SPDie, dwarf::DW_AT_prototyped);
1285 
1286  unsigned CC = 0;
1288  if (const DISubroutineType *SPTy = SP->getType()) {
1289  Args = SPTy->getTypeArray();
1290  CC = SPTy->getCC();
1291  }
1292 
1293  // Add a DW_AT_calling_convention if this has an explicit convention.
1294  if (CC && CC != dwarf::DW_CC_normal)
1295  addUInt(SPDie, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1, CC);
1296 
1297  // Add a return type. If this is a type like a C/C++ void type we don't add a
1298  // return type.
1299  if (Args.size())
1300  if (auto Ty = resolve(Args[0]))
1301  addType(SPDie, Ty);
1302 
1303  unsigned VK = SP->getVirtuality();
1304  if (VK) {
1305  addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1306  if (SP->getVirtualIndex() != -1u) {
1307  DIELoc *Block = getDIELoc();
1308  addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1309  addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex());
1310  addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1311  }
1312  ContainingTypeMap.insert(
1313  std::make_pair(&SPDie, resolve(SP->getContainingType())));
1314  }
1315 
1316  if (!SP->isDefinition()) {
1317  addFlag(SPDie, dwarf::DW_AT_declaration);
1318 
1319  // Add arguments. Do not add arguments for subprogram definition. They will
1320  // be handled while processing variables.
1321  constructSubprogramArguments(SPDie, Args);
1322  }
1323 
1324  addThrownTypes(SPDie, SP->getThrownTypes());
1325 
1326  if (SP->isArtificial())
1327  addFlag(SPDie, dwarf::DW_AT_artificial);
1328 
1329  if (!SP->isLocalToUnit())
1330  addFlag(SPDie, dwarf::DW_AT_external);
1331 
1333  if (SP->isOptimized())
1334  addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1335 
1336  if (unsigned isa = Asm->getISAEncoding())
1337  addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1338  }
1339 
1340  if (SP->isLValueReference())
1341  addFlag(SPDie, dwarf::DW_AT_reference);
1342 
1343  if (SP->isRValueReference())
1344  addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1345 
1346  if (SP->isNoReturn())
1347  addFlag(SPDie, dwarf::DW_AT_noreturn);
1348 
1349  if (SP->isProtected())
1350  addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1352  else if (SP->isPrivate())
1353  addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1355  else if (SP->isPublic())
1356  addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1358 
1359  if (SP->isExplicit())
1360  addFlag(SPDie, dwarf::DW_AT_explicit);
1361 
1362  if (SP->isMainSubprogram())
1363  addFlag(SPDie, dwarf::DW_AT_main_subprogram);
1364 }
1365 
1366 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
1367  DIE *IndexTy) {
1368  DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1369  addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1370 
1371  // The LowerBound value defines the lower bounds which is typically zero for
1372  // C/C++. The Count value is the number of elements. Values are 64 bit. If
1373  // Count == -1 then the array is unbounded and we do not emit
1374  // DW_AT_lower_bound and DW_AT_count attributes.
1375  int64_t LowerBound = SR->getLowerBound();
1376  int64_t DefaultLowerBound = getDefaultLowerBound();
1377  int64_t Count = -1;
1378  if (auto *CI = SR->getCount().dyn_cast<ConstantInt*>())
1379  Count = CI->getSExtValue();
1380 
1381  if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1382  addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1383 
1384  if (auto *CV = SR->getCount().dyn_cast<DIVariable*>()) {
1385  // 'finishVariableDefinition' that creates the types for a variable is
1386  // always called _after_ the DIEs for variables are created.
1387  auto *CountVarDIE = getDIE(CV);
1388  assert(CountVarDIE && "DIE for count is not yet instantiated");
1389  addDIEEntry(DW_Subrange, dwarf::DW_AT_count, *CountVarDIE);
1390  } else if (Count != -1)
1391  // FIXME: An unbounded array should reference the expression that defines
1392  // the array.
1393  addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1394 }
1395 
1396 DIE *DwarfUnit::getIndexTyDie() {
1397  if (IndexTyDie)
1398  return IndexTyDie;
1399  // Construct an integer type to use for indexes.
1400  IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, getUnitDie());
1401  addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1402  addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1403  addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1404  dwarf::DW_ATE_unsigned);
1405  return IndexTyDie;
1406 }
1407 
1408 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1409  if (CTy->isVector())
1410  addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1411 
1412  // Emit the element type.
1413  addType(Buffer, resolve(CTy->getBaseType()));
1414 
1415  // Get an anonymous type for index type.
1416  // FIXME: This type should be passed down from the front end
1417  // as different languages may have different sizes for indexes.
1418  DIE *IdxTy = getIndexTyDie();
1419 
1420  // Add subranges to array type.
1421  DINodeArray Elements = CTy->getElements();
1422  for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1423  // FIXME: Should this really be such a loose cast?
1424  if (auto *Element = dyn_cast_or_null<DINode>(Elements[i]))
1425  if (Element->getTag() == dwarf::DW_TAG_subrange_type)
1426  constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
1427  }
1428 }
1429 
1430 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1431  const DIType *DTy = resolve(CTy->getBaseType());
1432  bool IsUnsigned = DTy && isUnsignedDIType(DD, DTy);
1433  if (DTy) {
1434  if (DD->getDwarfVersion() >= 3)
1435  addType(Buffer, DTy);
1436  if (DD->getDwarfVersion() >= 4 && (CTy->getFlags() & DINode::FlagFixedEnum))
1437  addFlag(Buffer, dwarf::DW_AT_enum_class);
1438  }
1439 
1440  DINodeArray Elements = CTy->getElements();
1441 
1442  // Add enumerators to enumeration type.
1443  for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1444  auto *Enum = dyn_cast_or_null<DIEnumerator>(Elements[i]);
1445  if (Enum) {
1446  DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1447  StringRef Name = Enum->getName();
1448  addString(Enumerator, dwarf::DW_AT_name, Name);
1449  auto Value = static_cast<uint64_t>(Enum->getValue());
1450  addConstantValue(Enumerator, IsUnsigned, Value);
1451  }
1452  }
1453 }
1454 
1456  for (auto CI = ContainingTypeMap.begin(), CE = ContainingTypeMap.end();
1457  CI != CE; ++CI) {
1458  DIE &SPDie = *CI->first;
1459  const DINode *D = CI->second;
1460  if (!D)
1461  continue;
1462  DIE *NDie = getDIE(D);
1463  if (!NDie)
1464  continue;
1465  addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1466  }
1467 }
1468 
1469 DIE &DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
1470  DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer);
1471  StringRef Name = DT->getName();
1472  if (!Name.empty())
1473  addString(MemberDie, dwarf::DW_AT_name, Name);
1474 
1475  if (DIType *Resolved = resolve(DT->getBaseType()))
1476  addType(MemberDie, Resolved);
1477 
1478  addSourceLine(MemberDie, DT);
1479 
1480  if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
1481 
1482  // For C++, virtual base classes are not at fixed offset. Use following
1483  // expression to extract appropriate offset from vtable.
1484  // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1485 
1486  DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc;
1487  addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1488  addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1489  addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1490  addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits());
1491  addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1492  addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1493  addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1494 
1495  addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1496  } else {
1497  uint64_t Size = DT->getSizeInBits();
1498  uint64_t FieldSize = DD->getBaseTypeSize(DT);
1499  uint32_t AlignInBytes = DT->getAlignInBytes();
1500  uint64_t OffsetInBytes;
1501 
1502  bool IsBitfield = FieldSize && Size != FieldSize;
1503  if (IsBitfield) {
1504  // Handle bitfield, assume bytes are 8 bits.
1505  if (DD->useDWARF2Bitfields())
1506  addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1507  addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1508 
1509  uint64_t Offset = DT->getOffsetInBits();
1510  // We can't use DT->getAlignInBits() here: AlignInBits for member type
1511  // is non-zero if and only if alignment was forced (e.g. _Alignas()),
1512  // which can't be done with bitfields. Thus we use FieldSize here.
1513  uint32_t AlignInBits = FieldSize;
1514  uint32_t AlignMask = ~(AlignInBits - 1);
1515  // The bits from the start of the storage unit to the start of the field.
1516  uint64_t StartBitOffset = Offset - (Offset & AlignMask);
1517  // The byte offset of the field's aligned storage unit inside the struct.
1518  OffsetInBytes = (Offset - StartBitOffset) / 8;
1519 
1520  if (DD->useDWARF2Bitfields()) {
1521  uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1522  uint64_t FieldOffset = (HiMark - FieldSize);
1523  Offset -= FieldOffset;
1524 
1525  // Maybe we need to work from the other end.
1526  if (Asm->getDataLayout().isLittleEndian())
1527  Offset = FieldSize - (Offset + Size);
1528 
1529  addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1530  OffsetInBytes = FieldOffset >> 3;
1531  } else {
1532  addUInt(MemberDie, dwarf::DW_AT_data_bit_offset, None, Offset);
1533  }
1534  } else {
1535  // This is not a bitfield.
1536  OffsetInBytes = DT->getOffsetInBits() / 8;
1537  if (AlignInBytes)
1538  addUInt(MemberDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1539  AlignInBytes);
1540  }
1541 
1542  if (DD->getDwarfVersion() <= 2) {
1543  DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc;
1544  addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1545  addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1546  addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1547  } else if (!IsBitfield || DD->useDWARF2Bitfields())
1548  addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1549  OffsetInBytes);
1550  }
1551 
1552  if (DT->isProtected())
1553  addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1555  else if (DT->isPrivate())
1556  addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1558  // Otherwise C++ member and base classes are considered public.
1559  else if (DT->isPublic())
1560  addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1562  if (DT->isVirtual())
1563  addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1564  dwarf::DW_VIRTUALITY_virtual);
1565 
1566  // Objective-C properties.
1567  if (DINode *PNode = DT->getObjCProperty())
1568  if (DIE *PDie = getDIE(PNode))
1569  MemberDie.addValue(DIEValueAllocator, dwarf::DW_AT_APPLE_property,
1570  dwarf::DW_FORM_ref4, DIEEntry(*PDie));
1571 
1572  if (DT->isArtificial())
1573  addFlag(MemberDie, dwarf::DW_AT_artificial);
1574 
1575  return MemberDie;
1576 }
1577 
1579  if (!DT)
1580  return nullptr;
1581 
1582  // Construct the context before querying for the existence of the DIE in case
1583  // such construction creates the DIE.
1584  DIE *ContextDIE = getOrCreateContextDIE(resolve(DT->getScope()));
1585  assert(dwarf::isType(ContextDIE->getTag()) &&
1586  "Static member should belong to a type.");
1587 
1588  if (DIE *StaticMemberDIE = getDIE(DT))
1589  return StaticMemberDIE;
1590 
1591  DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT);
1592 
1593  const DIType *Ty = resolve(DT->getBaseType());
1594 
1595  addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName());
1596  addType(StaticMemberDIE, Ty);
1597  addSourceLine(StaticMemberDIE, DT);
1598  addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1599  addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1600 
1601  // FIXME: We could omit private if the parent is a class_type, and
1602  // public if the parent is something else.
1603  if (DT->isProtected())
1604  addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1606  else if (DT->isPrivate())
1607  addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1609  else if (DT->isPublic())
1610  addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1612 
1613  if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant()))
1614  addConstantValue(StaticMemberDIE, CI, Ty);
1615  if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant()))
1616  addConstantFPValue(StaticMemberDIE, CFP);
1617 
1618  if (uint32_t AlignInBytes = DT->getAlignInBytes())
1619  addUInt(StaticMemberDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1620  AlignInBytes);
1621 
1622  return &StaticMemberDIE;
1623 }
1624 
1626  // Emit size of content not including length itself
1627  Asm->OutStreamer->AddComment("Length of Unit");
1628  Asm->EmitInt32(getHeaderSize() + getUnitDie().getSize());
1629 
1630  Asm->OutStreamer->AddComment("DWARF version number");
1631  unsigned Version = DD->getDwarfVersion();
1632  Asm->EmitInt16(Version);
1633 
1634  // DWARF v5 reorders the address size and adds a unit type.
1635  if (Version >= 5) {
1636  Asm->OutStreamer->AddComment("DWARF Unit Type");
1637  Asm->EmitInt8(UT);
1638  Asm->OutStreamer->AddComment("Address Size (in bytes)");
1640  }
1641 
1642  // We share one abbreviations table across all units so it's always at the
1643  // start of the section. Use a relocatable offset where needed to ensure
1644  // linking doesn't invalidate that offset.
1645  Asm->OutStreamer->AddComment("Offset Into Abbrev. Section");
1647  if (UseOffsets)
1648  Asm->EmitInt32(0);
1649  else
1651  TLOF.getDwarfAbbrevSection()->getBeginSymbol(), false);
1652 
1653  if (Version <= 4) {
1654  Asm->OutStreamer->AddComment("Address Size (in bytes)");
1656  }
1657 }
1658 
1659 void DwarfTypeUnit::emitHeader(bool UseOffsets) {
1660  DwarfUnit::emitCommonHeader(UseOffsets,
1661  DD->useSplitDwarf() ? dwarf::DW_UT_split_type
1662  : dwarf::DW_UT_type);
1663  Asm->OutStreamer->AddComment("Type Signature");
1664  Asm->OutStreamer->EmitIntValue(TypeSignature, sizeof(TypeSignature));
1665  Asm->OutStreamer->AddComment("Type DIE Offset");
1666  // In a skeleton type unit there is no type DIE so emit a zero offset.
1667  Asm->OutStreamer->EmitIntValue(Ty ? Ty->getOffset() : 0,
1668  sizeof(Ty->getOffset()));
1669 }
1670 
1673  const MCSymbol *Hi, const MCSymbol *Lo) {
1674  return Die.addValue(DIEValueAllocator, Attribute,
1675  DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
1676  : dwarf::DW_FORM_data4,
1677  new (DIEValueAllocator) DIEDelta(Hi, Lo));
1678 }
1679 
1682  const MCSymbol *Label, const MCSymbol *Sec) {
1684  return addLabel(Die, Attribute,
1685  DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
1686  : dwarf::DW_FORM_data4,
1687  Label);
1688  return addSectionDelta(Die, Attribute, Label, Sec);
1689 }
1690 
1691 bool DwarfTypeUnit::isDwoUnit() const {
1692  // Since there are no skeleton type units, all type units are dwo type units
1693  // when split DWARF is being used.
1694  return DD->useSplitDwarf();
1695 }
1696 
1698  const DIScope *Context) {
1699  getCU().addGlobalNameForTypeUnit(Name, Context);
1700 }
1701 
1702 void DwarfTypeUnit::addGlobalType(const DIType *Ty, const DIE &Die,
1703  const DIScope *Context) {
1704  getCU().addGlobalTypeUnitType(Ty, Context);
1705 }
1706 
1707 const MCSymbol *DwarfUnit::getCrossSectionRelativeBaseAddress() const {
1709  return nullptr;
1710  if (isDwoUnit())
1711  return nullptr;
1712  return getSection()->getBeginSymbol();
1713 }
1714 
1717  addSectionLabel(getUnitDie(), dwarf::DW_AT_str_offsets_base,
1720 }
DIFlags getFlags() const
const DICompileUnit * getCUNode() const
Definition: DwarfUnit.h:113
void updateAcceleratorTables(const DIScope *Context, const DIType *Ty, const DIE &TyDIE)
If this is a named finished type then include it in the list of types for the accelerator tables...
Definition: DwarfUnit.cpp:774
const TargetLoweringObjectFile & getObjFileLowering() const
Return information about object file lowering.
Definition: AsmPrinter.cpp:208
DIE::value_iterator addSectionDelta(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Hi, const MCSymbol *Lo)
addSectionDelta - Add a label delta attribute data and value.
Definition: DwarfUnit.cpp:1672
MCSection * getDwarfStrOffSection() const
static bool isUnsignedDIType(DwarfDebug *DD, const DIType *Ty)
Return true if type encoding is unsigned.
Definition: DwarfUnit.cpp:543
uint64_t getOffsetInBits() const
bool isPrivate() const
void addFlag(DIE &Die, dwarf::Attribute Attribute)
Add a flag that is true to the DIE.
Definition: DwarfUnit.cpp:207
bool isTypePassByValue() const
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1542
LLVMContext & Context
void addLabelDelta(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Hi, const MCSymbol *Lo)
Add a label delta attribute data and value.
Definition: DwarfUnit.cpp:314
std::unique_ptr< MCStreamer > OutStreamer
This is the MCStreamer object for the file we are generating.
Definition: AsmPrinter.h:92
StringRef getName() const
std::vector< DIELoc * > DIELocs
A list of all the DIELocs in use.
Definition: DwarfUnit.h:94
DIELoc - Represents an expression location.
Definition: DIE.h:846
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
StringRef getName() const
DIE * getOrCreateStaticMemberDIE(const DIDerivedType *DT)
Create new static data member DIE.
Definition: DwarfUnit.cpp:1578
bool isVirtual() const
void EmitInt8(int Value) const
Emit a byte directive and value.
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:42
unsigned size() const
void setMemoryLocationKind()
Lock this down to become a memory location description.
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
const DIType * getType() const
Definition: DwarfDebug.cpp:164
DIFile * getFile() const
Attribute
Attributes.
Definition: Dwarf.h:107
void addThrownTypes(DIE &Die, DINodeArray ThrownTypes)
Add thrown types.
Definition: DwarfUnit.cpp:690
This provides a very simple, boring adaptor for a begin and end iterator into a range type...
void insertDIE(const DINode *Desc, DIE *D)
Insert DIE into the map.
Definition: DwarfUnit.cpp:199
DITypeRef getBaseType() const
unsigned getReg() const
Collects and handles dwarf debug information.
Definition: DwarfDebug.h:196
bool isVector() const
This file contains the declarations for metadata subclasses.
DwarfTypeUnit(DwarfCompileUnit &CU, AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU, MCDwarfDwoLineTable *SplitLineTable=nullptr)
Definition: DwarfUnit.cpp:83
const MachineFunction * MF
The current machine function.
Definition: AsmPrinter.h:95
Base class containing the logic for constructing DWARF expressions independently of whether they are ...
static enum BaseType getBaseType(const Value *Val)
Return the baseType for Val which states whether Val is exclusively derived from constant/null, or not exclusively derived from constant.
void emitDwarfSymbolReference(const MCSymbol *Label, bool ForceOffset=false) const
Emit a reference to a symbol for use in dwarf.
Metadata node.
Definition: Metadata.h:862
StringRef getConfigurationMacros() const
bool useSegmentedStringOffsetsTable() const
Definition: DwarfUnit.h:276
DwarfUnit(dwarf::Tag, const DICompileUnit *CU, AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
Definition: DwarfUnit.cpp:77
bool isForwardDecl() const
bool getDebugInfoForProfiling() const
bool isImm() const
isImm - Tests if this is a MO_Immediate operand.
void addType(DIE &Entity, const DIType *Ty, dwarf::Attribute Attribute=dwarf::DW_AT_type)
Add a new type attribute to the specified entity.
Definition: DwarfUnit.cpp:792
DIE::value_iterator addSectionLabel(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Label, const MCSymbol *Sec)
Add a Dwarf section label attribute data and value.
Definition: DwarfUnit.cpp:1681
StringRef getName() const
AsmPrinter * Asm
Target of Dwarf emission.
Definition: DwarfUnit.h:77
Tagged DWARF-like metadata node.
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1488
std::string fromHex(StringRef Input)
Convert hexadecimal string Input to its binary representation.
Definition: StringExtras.h:140
DIE * getOrCreateTypeDIE(const MDNode *N)
Find existing DIE or create new DIE for the given type.
Definition: DwarfUnit.cpp:727
void addAccelNamespace(StringRef Name, const DIE &Die)
DINodeArray getElements() const
void constructTypeDIE(DIE &Buffer, const DICompositeType *CTy)
Definition: DwarfUnit.cpp:936
bool useSplitDwarf() const
Returns whether or not to change the current debug info for the split dwarf proposal support...
Definition: DwarfDebug.h:506
constexpr char Language[]
Key for Kernel::Metadata::mLanguage.
DIE * getDIE(const DINode *D) const
Returns the DIE map slot for the specified debug variable.
Definition: DwarfUnit.cpp:193
T * resolve(TypedDINodeRef< T > Ref) const
Look in the DwarfDebug map for the MDNode that corresponds to the reference.
Definition: DwarfUnit.h:325
void addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Block)
Add block data.
Definition: DwarfUnit.cpp:356
bool isLValueReference() const
unsigned getTag() const
const ConstantFP * getFPImm() const
Array subrange.
bool isShareableAcrossCUs(const DINode *D) const
Check whether the DIE for this MDNode can be shared across CUs.
Definition: DwarfUnit.cpp:178
static cl::opt< bool > GenerateDwarfTypeUnits("generate-type-units", cl::Hidden, cl::desc("Generate DWARF4 type units."), cl::init(false))
void addConstantFPValue(DIE &Die, const MachineOperand &MO)
Add constant value entry in variable DIE.
Definition: DwarfUnit.cpp:592
void addGlobalTypeUnitType(const DIType *Ty, const DIScope *Context)
Add a new global type present in a type unit to this compile unit.
uint64_t getSizeInBits() const
void constructContainingTypeDIEs()
Construct DIEs for types that contain vtables.
Definition: DwarfUnit.cpp:1455
Holds a subclass of DINode.
virtual unsigned getFrameRegister(const MachineFunction &MF) const =0
Debug information queries.
Holds a DIExpression and keeps track of how many operands have been consumed so far.
DITypeRef getVTableHolder() const
StringRef getFilename() const
This file implements a class to represent arbitrary precision integral constant values and operations...
DenseMap< DIE *, const DINode * > ContainingTypeMap
This map is used to keep track of subprogram DIEs that need DW_AT_containing_type attribute...
Definition: DwarfUnit.h:99
void addString(DIE &Die, dwarf::Attribute Attribute, StringRef Str)
Add a string attribute data and value.
Definition: DwarfUnit.cpp:242
bool getExportSymbols() const
AddressPool & getAddressPool()
Definition: DwarfDebug.h:545
Subprogram description.
int64_t getSExtValue() const
Get sign extended value.
Definition: APInt.h:1554
StringRef getIncludePath() const
unsigned getRuntimeLang() const
DenseMap< const MDNode *, DIE * > & getAbstractSPDies()
Definition: DwarfFile.h:124
This class is used to track local variable information.
Definition: DwarfDebug.h:76
bool doesDwarfUseRelocationsAcrossSections() const
Definition: MCAsmInfo.h:575
A list of DIE values.
Definition: DIE.h:589
void EmitInt16(int Value) const
Emit a short directive and value.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:133
uint32_t getAlignInBytes() const
DwarfCompileUnit & getCU() override
Definition: DwarfUnit.h:394
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:138
bool isLittleEndian() const
Layout endianness...
Definition: DataLayout.h:219
bool isFPImm() const
isFPImm - Tests if this is a MO_FPImmediate operand.
void addGlobalNameForTypeUnit(StringRef Name, const DIScope *Context)
Add a new global name present in a type unit to this compile unit.
DIE * getOrCreateNameSpace(const DINamespace *NS)
Definition: DwarfUnit.cpp:1138
DIE & addChild(DIE *Child)
Add a child to the DIE.
Definition: DIE.h:769
MCSection * getDwarfAbbrevSection() const
unsigned getLine() const
void addConstantValue(DIE &Die, const MachineOperand &MO, const DIType *Ty)
Add constant value entry in variable DIE.
Definition: DwarfUnit.cpp:624
void EmitInt32(int Value) const
Emit a long directive and value.
DIE & getEntry() const
Definition: DIE.h:301
MCSymbol * getStringOffsetsStartSym() const
Definition: DwarfFile.h:113
DIScope * getScope() const
static DIE * get(BumpPtrAllocator &Alloc, dwarf::Tag Tag)
Definition: DIE.h:692
unsigned getFile(StringRef Directory, StringRef FileName, MD5::MD5Result *Checksum)
Definition: MCDwarf.h:240
void applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie, bool SkipSPAttributes=false)
Definition: DwarfUnit.cpp:1257
void addSourceLine(DIE &Die, unsigned Line, const DIFile *File)
Add location information to specified debug information entry.
Definition: DwarfUnit.cpp:370
void addGlobalName(StringRef Name, const DIE &Die, const DIScope *Context) override
Add a new global name to the compile unit.
Definition: DwarfUnit.cpp:1697
A pointer to another debug information entry.
Definition: DIE.h:294
DITemplateParameterArray getTemplateParams() const
This dwarf writer support class manages information associated with a source file.
Definition: DwarfUnit.h:68
DIEDwarfExpression(const AsmPrinter &AP, DwarfUnit &DU, DIELoc &DIE)
Definition: DwarfUnit.cpp:55
DwarfStringPool & getStringPool()
Returns the string pool.
Definition: DwarfFile.h:111
DIEValueList::value_iterator addLabel(DIEValueList &Die, dwarf::Attribute Attribute, dwarf::Form Form, const MCSymbol *Label)
Add a Dwarf label attribute data and value.
Definition: DwarfUnit.cpp:262
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:406
const DIEUnit * getUnit() const
Climb up the parent chain to get the compile unit or type unit that this DIE belongs to...
Definition: DIE.cpp:213
bool applySubprogramDefinitionAttributes(const DISubprogram *SP, DIE &SPDie)
Definition: DwarfUnit.cpp:1214
const MCAsmInfo * MAI
Target Asm Printer information.
Definition: AsmPrinter.h:83
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
CountType getCount() const
This file contains the declarations for the subclasses of Constant, which represent the different fla...
MD5::MD5Result * getMD5AsBytes(const DIFile *File)
If the File has an MD5 checksum, return it as an MD5Result allocated in the MCContext.
Definition: DwarfUnit.cpp:281
A structured debug information entry.
Definition: DIE.h:662
DIELoc * getDIELoc()
Returns a fresh newly allocated DIELoc.
Definition: DwarfUnit.h:143
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:264
DIE & getUnitDie()
Definition: DIE.h:834
static dwarf::Form BestForm(bool IsSigned, uint64_t Int)
Choose the best form for integer.
Definition: DIE.h:170
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:77
void addDwarfTypeUnitType(DwarfCompileUnit &CU, StringRef Identifier, DIE &Die, const DICompositeType *CTy)
Add a DIE to the set of types that we&#39;re going to pull into type units.
unsigned getOrCreateSourceID(const DIFile *File) override
Look up the source ID for the given file.
This file declares a class to represent arbitrary precision floating point values and provide a varie...
DenseMap< const MDNode *, DIE * > MDNodeToDieMap
Tracks the mapping of unit level debug information variables to debug information entries...
Definition: DwarfUnit.h:88
bool useDWARF2Bitfields() const
Returns whether to use the DWARF2 format for bitfields instyead of the DWARF4 format.
Definition: DwarfDebug.h:492
void emitCommonHeader(bool UseOffsets, dwarf::UnitType UT)
Emit the common part of the header for this unit.
Definition: DwarfUnit.cpp:1625
void addAccelType(StringRef Name, const DIE &Die, char Flags)
A label DIE.
Definition: DIE.h:218
DIE * getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal=false)
Definition: DwarfUnit.cpp:1183
Base class for variables.
bool isObjcClassComplete() const
T * resolve(TypedDINodeRef< T > Ref) const
Find the MDNode for the given reference.
Definition: DwarfDebug.h:539
StringRef getDirectory() const
bool useAllLinkageNames() const
Returns whether we should emit all DW_AT_[MIPS_]linkage_name.
Definition: DwarfDebug.h:484
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
A container for string pool string values.
Definition: DIE.h:253
bool isRValueReference() const
void addSInt(DIEValueList &Die, dwarf::Attribute Attribute, Optional< dwarf::Form > Form, int64_t Integer)
Add an signed integer attribute data and value.
Definition: DwarfUnit.cpp:230
DIE * IndexTyDie
An anonymous type for index type. Owned by DIEUnit.
Definition: DwarfUnit.h:84
Base class for scope-like contexts.
A simple label difference DIE.
Definition: DIE.h:236
std::string getParentContextString(const DIScope *Context) const
Get string containing language specific context for a global name.
Definition: DwarfUnit.cpp:798
UnitType
Constants for unit types in DWARF v5.
Definition: Dwarf.h:321
void insertDIE(const MDNode *TypeMD, DIE *Die)
Definition: DwarfFile.h:132
const APFloat & getValueAPF() const
Definition: Constants.h:299
bool isPublic() const
void addExpression(DIExpressionCursor &&Expr, unsigned FragmentOffsetInBits=0)
Emit all remaining operations in the DIExpressionCursor.
uint16_t getLanguage() const
Definition: DwarfUnit.h:112
unsigned getHeaderSize() const override
Compute the size of a header for this unit, not including the initial length field.
Definition: DwarfUnit.h:386
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
Base class for types.
This is the shared class of boolean and integer constants.
Definition: Constants.h:84
StringRef getName() const
MCSection * getSection() const
Return the section that this DIEUnit will be emitted into.
Definition: DIE.h:827
MCSymbol * getSymbol(const GlobalValue *GV) const
Definition: AsmPrinter.cpp:423
MachineOperand class - Representation of each machine instruction operand.
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:862
bool isType(Tag T)
Definition: Dwarf.h:78
const DataFlowGraph & G
Definition: RDFGraph.cpp:211
void addLinkageName(DIE &Die, StringRef LinkageName)
Add a linkage name, if it isn&#39;t empty.
Definition: DwarfUnit.cpp:671
Represents a compile or type unit.
Definition: DIE.h:788
MCSymbol * getBeginSymbol()
Definition: MCSection.h:106
void addGlobalType(const DIType *Ty, const DIE &Die, const DIScope *Context) override
Add a new global type to the compile unit.
Definition: DwarfUnit.cpp:1702
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
DIFile * getFile() const
LLVM_NODISCARD bool isa(const Y &Val)
Definition: Casting.h:142
bool isProtected() const
bool useAppleExtensionAttributes() const
Definition: DwarfDebug.h:500
int64_t getImm() const
void addTemplateParams(DIE &Buffer, DINodeArray TParams)
Add template parameters in buffer.
Definition: DwarfUnit.cpp:679
DwarfDebug * DD
Definition: DwarfUnit.h:80
Class for arbitrary precision integers.
Definition: APInt.h:69
static StringRef dropLLVMManglingEscape(StringRef Name)
If the given string begins with the GlobalValue name mangling escape character &#39;\1&#39;, drop it.
Definition: GlobalValue.h:471
StringRef getName() const
Definition: DwarfDebug.h:136
dwarf::Form BestForm(unsigned DwarfVersion) const
BestForm - Choose the best form for data.
Definition: DIE.h:858
A (clang) module that has been imported by the compile unit.
void addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry)
Add a DIE attribute data and value.
Definition: DwarfUnit.cpp:320
dwarf::Tag getTag() const
Definition: DIE.h:698
amdgpu Simplify well known AMD library false Value Value * Arg
const uint64_t * getRawData() const
This function returns a pointer to the internal storage of the APInt.
Definition: APInt.h:668
DIE * getOrCreateContextDIE(const DIScope *Context)
Get context owner&#39;s DIE.
Definition: DwarfUnit.cpp:697
Type array for a subprogram.
An integer value DIE.
Definition: DIE.h:163
bool isArtificial() const
unsigned getEncoding() const
EntryRef getEntry(AsmPrinter &Asm, StringRef Str)
Get a reference to an entry in the string pool.
dwarf::Form BestForm() const
BestForm - Choose the best form for data.
Definition: DIE.h:892
DIE & createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N=nullptr)
Create a DIE with the given Tag, add the DIE to its parent, and call insertDIE if MD is not null...
Definition: DwarfUnit.cpp:349
#define N
bool shareAcrossDWOCUs() const
Definition: DwarfDebug.cpp:407
DIE * getDIE(const MDNode *TypeMD)
Definition: DwarfFile.h:136
void emitHeader(bool UseOffsets) override
Emit the header for this unit, not including the initial length field.
Definition: DwarfUnit.cpp:1659
DIE * getOrCreateModule(const DIModule *M)
Definition: DwarfUnit.cpp:1159
void addBlockByrefAddress(const DbgVariable &DV, DIE &Die, dwarf::Attribute Attribute, const MachineLocation &Location)
Start with the address based on the location provided, and generate the DWARF information necessary t...
Definition: DwarfUnit.cpp:464
const DICompileUnit * CUNode
MDNode for the compile unit.
Definition: DwarfUnit.h:71
virtual unsigned getISAEncoding()
Get the value for DW_AT_APPLE_isa. Zero if no isa encoding specified.
Definition: AsmPrinter.h:518
void addSectionOffset(DIE &Die, dwarf::Attribute Attribute, uint64_t Integer)
Add an offset into a section attribute data and value.
Definition: DwarfUnit.cpp:273
DwarfExpression implementation for singular DW_AT_location.
void addDIETypeSignature(DIE &Die, uint64_t Signature)
Add a type&#39;s DW_AT_signature and set the declaration flag.
Definition: DwarfUnit.cpp:324
unsigned getCodePointerSize() const
Get the code pointer size in bytes.
Definition: MCAsmInfo.h:383
BumpPtrAllocator DIEValueAllocator
Definition: DwarfUnit.h:74
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Value Representation.
Definition: Value.h:73
DIScopeRef getScope() const
void addStringOffsetsStart()
Add the DW_AT_str_offsets_base attribute to the unit DIE.
Definition: DwarfUnit.cpp:1715
constexpr char Size[]
Key for Kernel::Arg::Metadata::mSize.
unsigned ComputeSize(const AsmPrinter *AP) const
ComputeSize - Calculate the size of the location expression.
Definition: DIE.cpp:718
DIScope * getScope() const
std::vector< DIEBlock * > DIEBlocks
A list of all the DIEBlocks in use.
Definition: DwarfUnit.h:91
uint16_t getDwarfVersion() const
Returns the Dwarf Version.
bool isAppleBlockExtension() const
DIDerivedType * getDiscriminator() const
void addUInt(DIEValueList &Die, dwarf::Attribute Attribute, Optional< dwarf::Form > Form, uint64_t Integer)
Add an unsigned integer attribute data and value.
Definition: DwarfUnit.cpp:216
const DataLayout & getDataLayout() const
Return information about data layout.
Definition: AsmPrinter.cpp:212
unsigned getOffset() const
Get the compile/type unit relative offset of this DIE.
Definition: DIE.h:700
static uint64_t getBaseTypeSize(const DITypeRef TyRef)
If this type is derived from a base type then return base type size.
void addOpAddress(DIELoc &Die, const MCSymbol *Label)
Add a dwarf op address data and value using the form given and an op of either DW_FORM_addr or DW_FOR...
Definition: DwarfUnit.cpp:303
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
A single uniqued string.
Definition: Metadata.h:602
APInt bitcastToAPInt() const
Definition: APFloat.h:1094
unsigned getLine() const
unsigned ComputeSize(const AsmPrinter *AP) const
ComputeSize - Calculate the size of the location expression.
Definition: DIE.cpp:769
DIEBlock - Represents a block of values.
Definition: DIE.h:880
DIFile * getFile() const
DwarfFile * DU
Definition: DwarfUnit.h:81
void constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args)
Construct function argument DIEs.
Definition: DwarfUnit.cpp:888
Root of the metadata hierarchy.
Definition: Metadata.h:58
unsigned getLine() const
bool addMachineRegExpression(const TargetRegisterInfo &TRI, DIExpressionCursor &Expr, unsigned MachineReg, unsigned FragmentOffsetInBits=0)
Emit a machine register location.
StringRef getISysRoot() const
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
value_iterator addValue(BumpPtrAllocator &Alloc, const DIEValue &V)
Definition: DIE.h:640
bool isTypePassByReference() const
DIE * createTypeDIE(const DICompositeType *Ty)
Get context owner&#39;s DIE.
Definition: DwarfUnit.cpp:711
Basic type, like &#39;int&#39; or &#39;float&#39;.
DIScopeRef getScope() const
unsigned getIndex(const MCSymbol *Sym, bool TLS=false)
Returns the index into the address pool with the given label/symbol.
Definition: AddressPool.cpp:20