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