LLVM  14.0.0git
DwarfUnit.cpp
Go to the documentation of this file.
1 //===-- llvm/CodeGen/DwarfUnit.cpp - Dwarf Type and Compile Units ---------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file contains support for constructing a dwarf compile unit.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "DwarfUnit.h"
14 #include "AddressPool.h"
15 #include "DwarfCompileUnit.h"
16 #include "DwarfExpression.h"
17 #include "llvm/ADT/APFloat.h"
18 #include "llvm/ADT/APInt.h"
19 #include "llvm/ADT/None.h"
20 #include "llvm/ADT/StringExtras.h"
26 #include "llvm/IR/Constants.h"
27 #include "llvm/IR/DataLayout.h"
28 #include "llvm/IR/GlobalValue.h"
29 #include "llvm/IR/Metadata.h"
30 #include "llvm/MC/MCAsmInfo.h"
31 #include "llvm/MC/MCContext.h"
32 #include "llvm/MC/MCDwarf.h"
33 #include "llvm/MC/MCSection.h"
34 #include "llvm/MC/MCStreamer.h"
36 #include "llvm/Support/Casting.h"
39 #include <cassert>
40 #include <cstdint>
41 #include <string>
42 #include <utility>
43 
44 using namespace llvm;
45 
46 #define DEBUG_TYPE "dwarfdebug"
47 
50  : DwarfExpression(AP.getDwarfVersion(), CU), AP(AP), OutDIE(DIE) {}
51 
52 void DIEDwarfExpression::emitOp(uint8_t Op, const char* Comment) {
53  CU.addUInt(getActiveDIE(), dwarf::DW_FORM_data1, Op);
54 }
55 
56 void DIEDwarfExpression::emitSigned(int64_t Value) {
57  CU.addSInt(getActiveDIE(), dwarf::DW_FORM_sdata, Value);
58 }
59 
60 void DIEDwarfExpression::emitUnsigned(uint64_t Value) {
61  CU.addUInt(getActiveDIE(), dwarf::DW_FORM_udata, Value);
62 }
63 
64 void DIEDwarfExpression::emitData1(uint8_t Value) {
65  CU.addUInt(getActiveDIE(), dwarf::DW_FORM_data1, Value);
66 }
67 
68 void DIEDwarfExpression::emitBaseTypeRef(uint64_t Idx) {
69  CU.addBaseTypeRef(getActiveDIE(), Idx);
70 }
71 
72 void DIEDwarfExpression::enableTemporaryBuffer() {
73  assert(!IsBuffering && "Already buffering?");
74  IsBuffering = true;
75 }
76 
77 void DIEDwarfExpression::disableTemporaryBuffer() { IsBuffering = false; }
78 
79 unsigned DIEDwarfExpression::getTemporaryBufferSize() {
80  return TmpDIE.computeSize(AP.getDwarfFormParams());
81 }
82 
83 void DIEDwarfExpression::commitTemporaryBuffer() { OutDIE.takeValues(TmpDIE); }
84 
85 bool DIEDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
86  llvm::Register MachineReg) {
87  return MachineReg == TRI.getFrameRegister(*AP.MF);
88 }
89 
91  AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
92  : DIEUnit(UnitTag), CUNode(Node), Asm(A), DD(DW), DU(DWU),
93  IndexTyDie(nullptr) {}
94 
96  DwarfDebug *DW, DwarfFile *DWU,
97  MCDwarfDwoLineTable *SplitLineTable)
98  : DwarfUnit(dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU), CU(CU),
99  SplitLineTable(SplitLineTable) {
100 }
101 
103  for (DIEBlock *B : DIEBlocks)
104  B->~DIEBlock();
105  for (DIELoc *L : DIELocs)
106  L->~DIELoc();
107 }
108 
109 int64_t DwarfUnit::getDefaultLowerBound() const {
110  switch (getLanguage()) {
111  default:
112  break;
113 
114  // The languages below have valid values in all DWARF versions.
115  case dwarf::DW_LANG_C:
116  case dwarf::DW_LANG_C89:
117  case dwarf::DW_LANG_C_plus_plus:
118  return 0;
119 
120  case dwarf::DW_LANG_Fortran77:
121  case dwarf::DW_LANG_Fortran90:
122  return 1;
123 
124  // The languages below have valid values only if the DWARF version >= 3.
125  case dwarf::DW_LANG_C99:
126  case dwarf::DW_LANG_ObjC:
127  case dwarf::DW_LANG_ObjC_plus_plus:
128  if (DD->getDwarfVersion() >= 3)
129  return 0;
130  break;
131 
132  case dwarf::DW_LANG_Fortran95:
133  if (DD->getDwarfVersion() >= 3)
134  return 1;
135  break;
136 
137  // Starting with DWARF v4, all defined languages have valid values.
138  case dwarf::DW_LANG_D:
139  case dwarf::DW_LANG_Java:
140  case dwarf::DW_LANG_Python:
141  case dwarf::DW_LANG_UPC:
142  if (DD->getDwarfVersion() >= 4)
143  return 0;
144  break;
145 
146  case dwarf::DW_LANG_Ada83:
147  case dwarf::DW_LANG_Ada95:
148  case dwarf::DW_LANG_Cobol74:
149  case dwarf::DW_LANG_Cobol85:
150  case dwarf::DW_LANG_Modula2:
151  case dwarf::DW_LANG_Pascal83:
152  case dwarf::DW_LANG_PLI:
153  if (DD->getDwarfVersion() >= 4)
154  return 1;
155  break;
156 
157  // The languages below are new in DWARF v5.
158  case dwarf::DW_LANG_BLISS:
159  case dwarf::DW_LANG_C11:
160  case dwarf::DW_LANG_C_plus_plus_03:
161  case dwarf::DW_LANG_C_plus_plus_11:
162  case dwarf::DW_LANG_C_plus_plus_14:
163  case dwarf::DW_LANG_Dylan:
164  case dwarf::DW_LANG_Go:
165  case dwarf::DW_LANG_Haskell:
166  case dwarf::DW_LANG_OCaml:
167  case dwarf::DW_LANG_OpenCL:
168  case dwarf::DW_LANG_RenderScript:
169  case dwarf::DW_LANG_Rust:
170  case dwarf::DW_LANG_Swift:
171  if (DD->getDwarfVersion() >= 5)
172  return 0;
173  break;
174 
175  case dwarf::DW_LANG_Fortran03:
176  case dwarf::DW_LANG_Fortran08:
177  case dwarf::DW_LANG_Julia:
178  case dwarf::DW_LANG_Modula3:
179  if (DD->getDwarfVersion() >= 5)
180  return 1;
181  break;
182  }
183 
184  return -1;
185 }
186 
187 /// Check whether the DIE for this MDNode can be shared across CUs.
189  // When the MDNode can be part of the type system, the DIE can be shared
190  // across CUs.
191  // Combining type units and cross-CU DIE sharing is lower value (since
192  // cross-CU DIE sharing is used in LTO and removes type redundancy at that
193  // level already) but may be implementable for some value in projects
194  // building multiple independent libraries with LTO and then linking those
195  // together.
196  if (isDwoUnit() && !DD->shareAcrossDWOCUs())
197  return false;
198  return (isa<DIType>(D) ||
199  (isa<DISubprogram>(D) && !cast<DISubprogram>(D)->isDefinition())) &&
200  !DD->generateTypeUnits();
201 }
202 
203 DIE *DwarfUnit::getDIE(const DINode *D) const {
204  if (isShareableAcrossCUs(D))
205  return DU->getDIE(D);
206  return MDNodeToDieMap.lookup(D);
207 }
208 
209 void DwarfUnit::insertDIE(const DINode *Desc, DIE *D) {
210  if (isShareableAcrossCUs(Desc)) {
211  DU->insertDIE(Desc, D);
212  return;
213  }
214  MDNodeToDieMap.insert(std::make_pair(Desc, D));
215 }
216 
218  MDNodeToDieMap.insert(std::make_pair(nullptr, D));
219 }
220 
222  if (DD->getDwarfVersion() >= 4)
223  addAttribute(Die, Attribute, dwarf::DW_FORM_flag_present, DIEInteger(1));
224  else
225  addAttribute(Die, Attribute, dwarf::DW_FORM_flag, DIEInteger(1));
226 }
227 
230  if (!Form)
232  assert(Form != dwarf::DW_FORM_implicit_const &&
233  "DW_FORM_implicit_const is used only for signed integers");
235 }
236 
238  uint64_t Integer) {
239  addUInt(Block, (dwarf::Attribute)0, Form, Integer);
240 }
241 
243  Optional<dwarf::Form> Form, int64_t Integer) {
244  if (!Form)
247 }
248 
250  int64_t Integer) {
252 }
253 
255  StringRef String) {
257  return;
258 
259  if (DD->useInlineStrings()) {
260  addAttribute(Die, Attribute, dwarf::DW_FORM_string,
261  new (DIEValueAllocator)
263  return;
264  }
265  dwarf::Form IxForm =
266  isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp;
267 
268  auto StringPoolEntry =
269  useSegmentedStringOffsetsTable() || IxForm == dwarf::DW_FORM_GNU_str_index
270  ? DU->getStringPool().getIndexedEntry(*Asm, String)
271  : DU->getStringPool().getEntry(*Asm, String);
272 
273  // For DWARF v5 and beyond, use the smallest strx? form possible.
275  IxForm = dwarf::DW_FORM_strx1;
276  unsigned Index = StringPoolEntry.getIndex();
277  if (Index > 0xffffff)
278  IxForm = dwarf::DW_FORM_strx4;
279  else if (Index > 0xffff)
280  IxForm = dwarf::DW_FORM_strx3;
281  else if (Index > 0xff)
282  IxForm = dwarf::DW_FORM_strx2;
283  }
284  addAttribute(Die, Attribute, IxForm, DIEString(StringPoolEntry));
285 }
286 
288  dwarf::Form Form, const MCSymbol *Label) {
289  addAttribute(Die, Attribute, Form, DIELabel(Label));
290 }
291 
293  addLabel(Die, (dwarf::Attribute)0, Form, Label);
294 }
295 
297  uint64_t Integer) {
299 }
300 
301 unsigned DwarfTypeUnit::getOrCreateSourceID(const DIFile *File) {
302  if (!SplitLineTable)
303  return getCU().getOrCreateSourceID(File);
304  if (!UsedLineTable) {
305  UsedLineTable = true;
306  // This is a split type unit that needs a line table.
307  addSectionOffset(getUnitDie(), dwarf::DW_AT_stmt_list, 0);
308  }
309  return SplitLineTable->getFile(
310  File->getDirectory(), File->getFilename(), DD->getMD5AsBytes(File),
311  Asm->OutContext.getDwarfVersion(), File->getSource());
312 }
313 
315  bool UseAddrOffsetFormOrExpressions =
317 
318  const MCSymbol *Base = nullptr;
319  if (Label->isInSection() && UseAddrOffsetFormOrExpressions)
320  Base = DD->getSectionLabel(&Label->getSection());
321 
322  uint32_t Index = DD->getAddressPool().getIndex(Base ? Base : Label);
323 
324  if (DD->getDwarfVersion() >= 5) {
325  addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addrx);
326  addUInt(Die, dwarf::DW_FORM_addrx, Index);
327  } else {
328  addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
329  addUInt(Die, dwarf::DW_FORM_GNU_addr_index, Index);
330  }
331 
332  if (Base && Base != Label) {
333  addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_const4u);
334  addLabelDelta(Die, (dwarf::Attribute)0, Label, Base);
335  addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
336  }
337 }
338 
339 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
340  if (DD->getDwarfVersion() >= 5) {
341  addPoolOpAddress(Die, Sym);
342  return;
343  }
344 
345  if (DD->useSplitDwarf()) {
346  addPoolOpAddress(Die, Sym);
347  return;
348  }
349 
350  addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
351  addLabel(Die, dwarf::DW_FORM_addr, Sym);
352 }
353 
355  const MCSymbol *Hi, const MCSymbol *Lo) {
356  addAttribute(Die, Attribute, dwarf::DW_FORM_data4,
357  new (DIEValueAllocator) DIEDelta(Hi, Lo));
358 }
359 
361  addDIEEntry(Die, Attribute, DIEEntry(Entry));
362 }
363 
365  // Flag the type unit reference as a declaration so that if it contains
366  // members (implicit special members, static data member definitions, member
367  // declarations for definitions in this CU, etc) consumers don't get confused
368  // and think this is a full definition.
369  addFlag(Die, dwarf::DW_AT_declaration);
370 
371  addAttribute(Die, dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
372  DIEInteger(Signature));
373 }
374 
376  DIEEntry Entry) {
377  const DIEUnit *CU = Die.getUnit();
378  const DIEUnit *EntryCU = Entry.getEntry().getUnit();
379  if (!CU)
380  // We assume that Die belongs to this CU, if it is not linked to any CU yet.
381  CU = getUnitDie().getUnit();
382  if (!EntryCU)
383  EntryCU = getUnitDie().getUnit();
384  addAttribute(Die, Attribute,
385  EntryCU == CU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
386  Entry);
387 }
388 
390  DIE &Die = Parent.addChild(DIE::get(DIEValueAllocator, Tag));
391  if (N)
392  insertDIE(N, &Die);
393  return Die;
394 }
395 
398  DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
399  addAttribute(Die, Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
400 }
401 
403  DIEBlock *Block) {
404  Block->computeSize(Asm->getDwarfFormParams());
405  DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
406  addAttribute(Die, Attribute, Form, Block);
407 }
408 
410  DIEBlock *Block) {
411  addBlock(Die, Attribute, Block->BestForm(), Block);
412 }
413 
414 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, const DIFile *File) {
415  if (Line == 0)
416  return;
417 
418  unsigned FileID = getOrCreateSourceID(File);
419  addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
420  addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
421 }
422 
424  assert(V);
425 
426  addSourceLine(Die, V->getLine(), V->getFile());
427 }
428 
430  assert(G);
431 
432  addSourceLine(Die, G->getLine(), G->getFile());
433 }
434 
436  assert(SP);
437 
438  addSourceLine(Die, SP->getLine(), SP->getFile());
439 }
440 
441 void DwarfUnit::addSourceLine(DIE &Die, const DILabel *L) {
442  assert(L);
443 
444  addSourceLine(Die, L->getLine(), L->getFile());
445 }
446 
447 void DwarfUnit::addSourceLine(DIE &Die, const DIType *Ty) {
448  assert(Ty);
449 
450  addSourceLine(Die, Ty->getLine(), Ty->getFile());
451 }
452 
454  assert(Ty);
455 
456  addSourceLine(Die, Ty->getLine(), Ty->getFile());
457 }
458 
460  // Pass this down to addConstantValue as an unsigned bag of bits.
461  addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
462 }
463 
465  const DIType *Ty) {
466  addConstantValue(Die, CI->getValue(), Ty);
467 }
468 
469 void DwarfUnit::addConstantValue(DIE &Die, uint64_t Val, const DIType *Ty) {
470  addConstantValue(Die, DD->isUnsignedDIType(Ty), Val);
471 }
472 
474  // FIXME: This is a bit conservative/simple - it emits negative values always
475  // sign extended to 64 bits rather than minimizing the number of bytes.
476  addUInt(Die, dwarf::DW_AT_const_value,
477  Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
478 }
479 
480 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty) {
481  addConstantValue(Die, Val, DD->isUnsignedDIType(Ty));
482 }
483 
484 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
485  unsigned CIBitWidth = Val.getBitWidth();
486  if (CIBitWidth <= 64) {
488  Unsigned ? Val.getZExtValue() : Val.getSExtValue());
489  return;
490  }
491 
492  DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
493 
494  // Get the raw data form of the large APInt.
495  const uint64_t *Ptr64 = Val.getRawData();
496 
497  int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
498  bool LittleEndian = Asm->getDataLayout().isLittleEndian();
499 
500  // Output the constant to DWARF one byte at a time.
501  for (int i = 0; i < NumBytes; i++) {
502  uint8_t c;
503  if (LittleEndian)
504  c = Ptr64[i / 8] >> (8 * (i & 7));
505  else
506  c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
507  addUInt(*Block, dwarf::DW_FORM_data1, c);
508  }
509 
510  addBlock(Die, dwarf::DW_AT_const_value, Block);
511 }
512 
513 void DwarfUnit::addLinkageName(DIE &Die, StringRef LinkageName) {
514  if (!LinkageName.empty())
515  addString(Die,
516  DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
517  : dwarf::DW_AT_MIPS_linkage_name,
519 }
520 
521 void DwarfUnit::addTemplateParams(DIE &Buffer, DINodeArray TParams) {
522  // Add template parameters.
523  for (const auto *Element : TParams) {
524  if (auto *TTP = dyn_cast<DITemplateTypeParameter>(Element))
525  constructTemplateTypeParameterDIE(Buffer, TTP);
526  else if (auto *TVP = dyn_cast<DITemplateValueParameter>(Element))
527  constructTemplateValueParameterDIE(Buffer, TVP);
528  }
529 }
530 
531 /// Add thrown types.
532 void DwarfUnit::addThrownTypes(DIE &Die, DINodeArray ThrownTypes) {
533  for (const auto *Ty : ThrownTypes) {
534  DIE &TT = createAndAddDIE(dwarf::DW_TAG_thrown_type, Die);
535  addType(TT, cast<DIType>(Ty));
536  }
537 }
538 
540  if ((Flags & DINode::FlagAccessibility) == DINode::FlagProtected)
541  addUInt(Die, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
543  else if ((Flags & DINode::FlagAccessibility) == DINode::FlagPrivate)
544  addUInt(Die, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
546  else if ((Flags & DINode::FlagAccessibility) == DINode::FlagPublic)
547  addUInt(Die, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
549 }
550 
552  if (!Context || isa<DIFile>(Context))
553  return &getUnitDie();
554  if (auto *T = dyn_cast<DIType>(Context))
555  return getOrCreateTypeDIE(T);
556  if (auto *NS = dyn_cast<DINamespace>(Context))
557  return getOrCreateNameSpace(NS);
558  if (auto *SP = dyn_cast<DISubprogram>(Context))
559  return getOrCreateSubprogramDIE(SP);
560  if (auto *M = dyn_cast<DIModule>(Context))
561  return getOrCreateModule(M);
562  return getDIE(Context);
563 }
564 
566  auto *Context = Ty->getScope();
567  DIE *ContextDIE = getOrCreateContextDIE(Context);
568 
569  if (DIE *TyDIE = getDIE(Ty))
570  return TyDIE;
571 
572  // Create new type.
573  DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
574 
575  constructTypeDIE(TyDIE, cast<DICompositeType>(Ty));
576 
577  updateAcceleratorTables(Context, Ty, TyDIE);
578  return &TyDIE;
579 }
580 
582  const DIType *Ty) {
583  // Create new type.
584  DIE &TyDIE = createAndAddDIE(Ty->getTag(), ContextDIE, Ty);
585 
586  updateAcceleratorTables(Context, Ty, TyDIE);
587 
588  if (auto *BT = dyn_cast<DIBasicType>(Ty))
589  constructTypeDIE(TyDIE, BT);
590  else if (auto *ST = dyn_cast<DIStringType>(Ty))
591  constructTypeDIE(TyDIE, ST);
592  else if (auto *STy = dyn_cast<DISubroutineType>(Ty))
593  constructTypeDIE(TyDIE, STy);
594  else if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
595  if (DD->generateTypeUnits() && !Ty->isForwardDecl() &&
596  (Ty->getRawName() || CTy->getRawIdentifier())) {
597  // Skip updating the accelerator tables since this is not the full type.
598  if (MDString *TypeId = CTy->getRawIdentifier())
599  DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
600  else {
601  auto X = DD->enterNonTypeUnitContext();
602  finishNonUnitTypeDIE(TyDIE, CTy);
603  }
604  return &TyDIE;
605  }
606  constructTypeDIE(TyDIE, CTy);
607  } else {
608  constructTypeDIE(TyDIE, cast<DIDerivedType>(Ty));
609  }
610 
611  return &TyDIE;
612 }
613 
615  if (!TyNode)
616  return nullptr;
617 
618  auto *Ty = cast<DIType>(TyNode);
619 
620  // DW_TAG_restrict_type is not supported in DWARF2
621  if (Ty->getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
622  return getOrCreateTypeDIE(cast<DIDerivedType>(Ty)->getBaseType());
623 
624  // DW_TAG_atomic_type is not supported in DWARF < 5
625  if (Ty->getTag() == dwarf::DW_TAG_atomic_type && DD->getDwarfVersion() < 5)
626  return getOrCreateTypeDIE(cast<DIDerivedType>(Ty)->getBaseType());
627 
628  // Construct the context before querying for the existence of the DIE in case
629  // such construction creates the DIE.
630  auto *Context = Ty->getScope();
631  DIE *ContextDIE = getOrCreateContextDIE(Context);
632  assert(ContextDIE);
633 
634  if (DIE *TyDIE = getDIE(Ty))
635  return TyDIE;
636 
637  return static_cast<DwarfUnit *>(ContextDIE->getUnit())
638  ->createTypeDIE(Context, *ContextDIE, Ty);
639 }
640 
641 void DwarfUnit::updateAcceleratorTables(const DIScope *Context,
642  const DIType *Ty, const DIE &TyDIE) {
643  if (!Ty->getName().empty() && !Ty->isForwardDecl()) {
644  bool IsImplementation = false;
645  if (auto *CT = dyn_cast<DICompositeType>(Ty)) {
646  // A runtime language of 0 actually means C/C++ and that any
647  // non-negative value is some version of Objective-C/C++.
648  IsImplementation = CT->getRuntimeLang() == 0 || CT->isObjcClassComplete();
649  }
650  unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
651  DD->addAccelType(*CUNode, Ty->getName(), TyDIE, Flags);
652 
653  if (!Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
654  isa<DINamespace>(Context) || isa<DICommonBlock>(Context))
655  addGlobalType(Ty, TyDIE, Context);
656  }
657 }
658 
659 void DwarfUnit::addType(DIE &Entity, const DIType *Ty,
661  assert(Ty && "Trying to add a type that doesn't exist?");
663 }
664 
666  if (!Context)
667  return "";
668 
669  // FIXME: Decide whether to implement this for non-C++ languages.
671  return "";
672 
673  std::string CS;
675  while (!isa<DICompileUnit>(Context)) {
676  Parents.push_back(Context);
677  if (const DIScope *S = Context->getScope())
678  Context = S;
679  else
680  // Structure, etc types will have a NULL context if they're at the top
681  // level.
682  break;
683  }
684 
685  // Reverse iterate over our list to go from the outermost construct to the
686  // innermost.
687  for (const DIScope *Ctx : llvm::reverse(Parents)) {
688  StringRef Name = Ctx->getName();
689  if (Name.empty() && isa<DINamespace>(Ctx))
690  Name = "(anonymous namespace)";
691  if (!Name.empty()) {
692  CS += Name;
693  CS += "::";
694  }
695  }
696  return CS;
697 }
698 
699 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
700  // Get core information.
701  StringRef Name = BTy->getName();
702  // Add name if not anonymous or intermediate type.
703  if (!Name.empty())
704  addString(Buffer, dwarf::DW_AT_name, Name);
705 
706  // An unspecified type only has a name attribute.
707  if (BTy->getTag() == dwarf::DW_TAG_unspecified_type)
708  return;
709 
710  if (BTy->getTag() != dwarf::DW_TAG_string_type)
711  addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
712  BTy->getEncoding());
713 
714  uint64_t Size = BTy->getSizeInBits() >> 3;
715  addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
716 
717  if (BTy->isBigEndian())
718  addUInt(Buffer, dwarf::DW_AT_endianity, None, dwarf::DW_END_big);
719  else if (BTy->isLittleEndian())
720  addUInt(Buffer, dwarf::DW_AT_endianity, None, dwarf::DW_END_little);
721 }
722 
723 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIStringType *STy) {
724  // Get core information.
725  StringRef Name = STy->getName();
726  // Add name if not anonymous or intermediate type.
727  if (!Name.empty())
728  addString(Buffer, dwarf::DW_AT_name, Name);
729 
730  if (DIVariable *Var = STy->getStringLength()) {
731  if (auto *VarDIE = getDIE(Var))
732  addDIEEntry(Buffer, dwarf::DW_AT_string_length, *VarDIE);
733  } else if (DIExpression *Expr = STy->getStringLengthExp()) {
734  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
735  DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
736  // This is to describe the memory location of the
737  // length of a Fortran deferred length string, so
738  // lock it down as such.
739  DwarfExpr.setMemoryLocationKind();
740  DwarfExpr.addExpression(Expr);
741  addBlock(Buffer, dwarf::DW_AT_string_length, DwarfExpr.finalize());
742  } else {
743  uint64_t Size = STy->getSizeInBits() >> 3;
744  addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
745  }
746 
747  if (STy->getEncoding()) {
748  // For eventual Unicode support.
749  addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
750  STy->getEncoding());
751  }
752 }
753 
754 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy) {
755  // Get core information.
756  StringRef Name = DTy->getName();
757  uint64_t Size = DTy->getSizeInBits() >> 3;
758  uint16_t Tag = Buffer.getTag();
759 
760  // Map to main type, void will not have a type.
761  const DIType *FromTy = DTy->getBaseType();
762  if (FromTy)
763  addType(Buffer, FromTy);
764 
765  // Add name if not anonymous or intermediate type.
766  if (!Name.empty())
767  addString(Buffer, dwarf::DW_AT_name, Name);
768 
769  addAnnotation(Buffer, DTy->getAnnotations());
770 
771  // If alignment is specified for a typedef , create and insert DW_AT_alignment
772  // attribute in DW_TAG_typedef DIE.
773  if (Tag == dwarf::DW_TAG_typedef && DD->getDwarfVersion() >= 5) {
774  uint32_t AlignInBytes = DTy->getAlignInBytes();
775  if (AlignInBytes > 0)
776  addUInt(Buffer, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
777  AlignInBytes);
778  }
779 
780  // Add size if non-zero (derived types might be zero-sized.)
781  if (Size && Tag != dwarf::DW_TAG_pointer_type
782  && Tag != dwarf::DW_TAG_ptr_to_member_type
783  && Tag != dwarf::DW_TAG_reference_type
784  && Tag != dwarf::DW_TAG_rvalue_reference_type)
785  addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
786 
787  if (Tag == dwarf::DW_TAG_ptr_to_member_type)
788  addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
789  *getOrCreateTypeDIE(cast<DIDerivedType>(DTy)->getClassType()));
790  // Add source line info if available and TyDesc is not a forward declaration.
791  if (!DTy->isForwardDecl())
792  addSourceLine(Buffer, DTy);
793 
794  // If DWARF address space value is other than None, add it. The IR
795  // verifier checks that DWARF address space only exists for pointer
796  // or reference types.
797  if (DTy->getDWARFAddressSpace())
798  addUInt(Buffer, dwarf::DW_AT_address_class, dwarf::DW_FORM_data4,
799  DTy->getDWARFAddressSpace().getValue());
800 }
801 
803  for (unsigned i = 1, N = Args.size(); i < N; ++i) {
804  const DIType *Ty = Args[i];
805  if (!Ty) {
806  assert(i == N-1 && "Unspecified parameter must be the last argument");
807  createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
808  } else {
809  DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
810  addType(Arg, Ty);
811  if (Ty->isArtificial())
812  addFlag(Arg, dwarf::DW_AT_artificial);
813  }
814  }
815 }
816 
817 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DISubroutineType *CTy) {
818  // Add return type. A void return won't have a type.
819  auto Elements = cast<DISubroutineType>(CTy)->getTypeArray();
820  if (Elements.size())
821  if (auto RTy = Elements[0])
822  addType(Buffer, RTy);
823 
824  bool isPrototyped = true;
825  if (Elements.size() == 2 && !Elements[1])
826  isPrototyped = false;
827 
828  constructSubprogramArguments(Buffer, Elements);
829 
830  // Add prototype flag if we're dealing with a C language and the function has
831  // been prototyped.
833  if (isPrototyped &&
834  (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
835  Language == dwarf::DW_LANG_ObjC))
836  addFlag(Buffer, dwarf::DW_AT_prototyped);
837 
838  // Add a DW_AT_calling_convention if this has an explicit convention.
839  if (CTy->getCC() && CTy->getCC() != dwarf::DW_CC_normal)
840  addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
841  CTy->getCC());
842 
843  if (CTy->isLValueReference())
844  addFlag(Buffer, dwarf::DW_AT_reference);
845 
846  if (CTy->isRValueReference())
847  addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
848 }
849 
850 void DwarfUnit::addAnnotation(DIE &Buffer, DINodeArray Annotations) {
851  if (!Annotations)
852  return;
853 
854  for (const Metadata *Annotation : Annotations->operands()) {
855  const MDNode *MD = cast<MDNode>(Annotation);
856  const MDString *Name = cast<MDString>(MD->getOperand(0));
857  const auto &Value = MD->getOperand(1);
858 
859  DIE &AnnotationDie = createAndAddDIE(dwarf::DW_TAG_LLVM_annotation, Buffer);
860  addString(AnnotationDie, dwarf::DW_AT_name, Name->getString());
861  if (const auto *Data = dyn_cast<MDString>(Value))
862  addString(AnnotationDie, dwarf::DW_AT_const_value, Data->getString());
863  else if (const auto *Data = dyn_cast<ConstantAsMetadata>(Value))
864  addConstantValue(AnnotationDie, Data->getValue()->getUniqueInteger(),
865  /*Unsigned=*/true);
866  else
867  assert(false && "Unsupported annotation value type");
868  }
869 }
870 
872  // Add name if not anonymous or intermediate type.
873  StringRef Name = CTy->getName();
874 
875  uint64_t Size = CTy->getSizeInBits() >> 3;
876  uint16_t Tag = Buffer.getTag();
877 
878  switch (Tag) {
879  case dwarf::DW_TAG_array_type:
880  constructArrayTypeDIE(Buffer, CTy);
881  break;
882  case dwarf::DW_TAG_enumeration_type:
883  constructEnumTypeDIE(Buffer, CTy);
884  break;
885  case dwarf::DW_TAG_variant_part:
886  case dwarf::DW_TAG_structure_type:
887  case dwarf::DW_TAG_union_type:
888  case dwarf::DW_TAG_class_type:
889  case dwarf::DW_TAG_namelist: {
890  // Emit the discriminator for a variant part.
891  DIDerivedType *Discriminator = nullptr;
892  if (Tag == dwarf::DW_TAG_variant_part) {
893  Discriminator = CTy->getDiscriminator();
894  if (Discriminator) {
895  // DWARF says:
896  // If the variant part has a discriminant, the discriminant is
897  // represented by a separate debugging information entry which is
898  // a child of the variant part entry.
899  DIE &DiscMember = constructMemberDIE(Buffer, Discriminator);
900  addDIEEntry(Buffer, dwarf::DW_AT_discr, DiscMember);
901  }
902  }
903 
904  // Add template parameters to a class, structure or union types.
905  if (Tag == dwarf::DW_TAG_class_type ||
906  Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
907  addTemplateParams(Buffer, CTy->getTemplateParams());
908 
909  // Add elements to structure type.
910  DINodeArray Elements = CTy->getElements();
911  for (const auto *Element : Elements) {
912  if (!Element)
913  continue;
914  if (auto *SP = dyn_cast<DISubprogram>(Element))
916  else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
917  if (DDTy->getTag() == dwarf::DW_TAG_friend) {
918  DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
919  addType(ElemDie, DDTy->getBaseType(), dwarf::DW_AT_friend);
920  } else if (DDTy->isStaticMember()) {
922  } else if (Tag == dwarf::DW_TAG_variant_part) {
923  // When emitting a variant part, wrap each member in
924  // DW_TAG_variant.
925  DIE &Variant = createAndAddDIE(dwarf::DW_TAG_variant, Buffer);
926  if (const ConstantInt *CI =
927  dyn_cast_or_null<ConstantInt>(DDTy->getDiscriminantValue())) {
928  if (DD->isUnsignedDIType(Discriminator->getBaseType()))
929  addUInt(Variant, dwarf::DW_AT_discr_value, None, CI->getZExtValue());
930  else
931  addSInt(Variant, dwarf::DW_AT_discr_value, None, CI->getSExtValue());
932  }
933  constructMemberDIE(Variant, DDTy);
934  } else {
935  constructMemberDIE(Buffer, DDTy);
936  }
937  } else if (auto *Property = dyn_cast<DIObjCProperty>(Element)) {
938  DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer);
939  StringRef PropertyName = Property->getName();
940  addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
941  if (Property->getType())
942  addType(ElemDie, Property->getType());
943  addSourceLine(ElemDie, Property);
944  StringRef GetterName = Property->getGetterName();
945  if (!GetterName.empty())
946  addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
947  StringRef SetterName = Property->getSetterName();
948  if (!SetterName.empty())
949  addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
950  if (unsigned PropertyAttributes = Property->getAttributes())
951  addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
952  PropertyAttributes);
953  } else if (auto *Composite = dyn_cast<DICompositeType>(Element)) {
954  if (Composite->getTag() == dwarf::DW_TAG_variant_part) {
955  DIE &VariantPart = createAndAddDIE(Composite->getTag(), Buffer);
956  constructTypeDIE(VariantPart, Composite);
957  }
958  } else if (Tag == dwarf::DW_TAG_namelist) {
959  auto *Var = dyn_cast<DINode>(Element);
960  auto *VarDIE = getDIE(Var);
961  if (VarDIE) {
962  DIE &ItemDie = createAndAddDIE(dwarf::DW_TAG_namelist_item, Buffer);
963  addDIEEntry(ItemDie, dwarf::DW_AT_namelist_item, *VarDIE);
964  }
965  }
966  }
967 
968  if (CTy->isAppleBlockExtension())
969  addFlag(Buffer, dwarf::DW_AT_APPLE_block);
970 
971  if (CTy->getExportSymbols())
972  addFlag(Buffer, dwarf::DW_AT_export_symbols);
973 
974  // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
975  // inside C++ composite types to point to the base class with the vtable.
976  // Rust uses DW_AT_containing_type to link a vtable to the type
977  // for which it was created.
978  if (auto *ContainingType = CTy->getVTableHolder())
979  addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
980  *getOrCreateTypeDIE(ContainingType));
981 
982  if (CTy->isObjcClassComplete())
983  addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
984 
985  // Add the type's non-standard calling convention.
986  // DW_CC_pass_by_value/DW_CC_pass_by_reference are introduced in DWARF 5.
987  if (!Asm->TM.Options.DebugStrictDwarf || DD->getDwarfVersion() >= 5) {
988  uint8_t CC = 0;
989  if (CTy->isTypePassByValue())
990  CC = dwarf::DW_CC_pass_by_value;
991  else if (CTy->isTypePassByReference())
992  CC = dwarf::DW_CC_pass_by_reference;
993  if (CC)
994  addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
995  CC);
996  }
997  break;
998  }
999  default:
1000  break;
1001  }
1002 
1003  // Add name if not anonymous or intermediate type.
1004  if (!Name.empty())
1005  addString(Buffer, dwarf::DW_AT_name, Name);
1006 
1007  addAnnotation(Buffer, CTy->getAnnotations());
1008 
1009  if (Tag == dwarf::DW_TAG_enumeration_type ||
1010  Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1011  Tag == dwarf::DW_TAG_union_type) {
1012  // Add size if non-zero (derived types might be zero-sized.)
1013  // Ignore the size if it's a non-enum forward decl.
1014  // TODO: Do we care about size for enum forward declarations?
1015  if (Size &&
1016  (!CTy->isForwardDecl() || Tag == dwarf::DW_TAG_enumeration_type))
1017  addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1018  else if (!CTy->isForwardDecl())
1019  // Add zero size if it is not a forward declaration.
1020  addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1021 
1022  // If we're a forward decl, say so.
1023  if (CTy->isForwardDecl())
1024  addFlag(Buffer, dwarf::DW_AT_declaration);
1025 
1026  // Add accessibility info if available.
1027  addAccess(Buffer, CTy->getFlags());
1028 
1029  // Add source line info if available.
1030  if (!CTy->isForwardDecl())
1031  addSourceLine(Buffer, CTy);
1032 
1033  // No harm in adding the runtime language to the declaration.
1034  unsigned RLang = CTy->getRuntimeLang();
1035  if (RLang)
1036  addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1037  RLang);
1038 
1039  // Add align info if available.
1040  if (uint32_t AlignInBytes = CTy->getAlignInBytes())
1041  addUInt(Buffer, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1042  AlignInBytes);
1043  }
1044 }
1045 
1046 void DwarfUnit::constructTemplateTypeParameterDIE(
1047  DIE &Buffer, const DITemplateTypeParameter *TP) {
1048  DIE &ParamDIE =
1049  createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1050  // Add the type if it exists, it could be void and therefore no type.
1051  if (TP->getType())
1052  addType(ParamDIE, TP->getType());
1053  if (!TP->getName().empty())
1054  addString(ParamDIE, dwarf::DW_AT_name, TP->getName());
1055  if (TP->isDefault() && (DD->getDwarfVersion() >= 5))
1056  addFlag(ParamDIE, dwarf::DW_AT_default_value);
1057 }
1058 
1059 void DwarfUnit::constructTemplateValueParameterDIE(
1060  DIE &Buffer, const DITemplateValueParameter *VP) {
1061  DIE &ParamDIE = createAndAddDIE(VP->getTag(), Buffer);
1062 
1063  // Add the type if there is one, template template and template parameter
1064  // packs will not have a type.
1065  if (VP->getTag() == dwarf::DW_TAG_template_value_parameter)
1066  addType(ParamDIE, VP->getType());
1067  if (!VP->getName().empty())
1068  addString(ParamDIE, dwarf::DW_AT_name, VP->getName());
1069  if (VP->isDefault() && (DD->getDwarfVersion() >= 5))
1070  addFlag(ParamDIE, dwarf::DW_AT_default_value);
1071  if (Metadata *Val = VP->getValue()) {
1072  if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1073  addConstantValue(ParamDIE, CI, VP->getType());
1074  else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1075  // We cannot describe the location of dllimport'd entities: the
1076  // computation of their address requires loads from the IAT.
1077  if (!GV->hasDLLImportStorageClass()) {
1078  // For declaration non-type template parameters (such as global values
1079  // and functions)
1080  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1081  addOpAddress(*Loc, Asm->getSymbol(GV));
1082  // Emit DW_OP_stack_value to use the address as the immediate value of
1083  // the parameter, rather than a pointer to it.
1084  addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1085  addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1086  }
1087  } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1088  assert(isa<MDString>(Val));
1089  addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1090  cast<MDString>(Val)->getString());
1091  } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1092  addTemplateParams(ParamDIE, cast<MDTuple>(Val));
1093  }
1094  }
1095 }
1096 
1098  // Construct the context before querying for the existence of the DIE in case
1099  // such construction creates the DIE.
1100  DIE *ContextDIE = getOrCreateContextDIE(NS->getScope());
1101 
1102  if (DIE *NDie = getDIE(NS))
1103  return NDie;
1104  DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1105 
1106  StringRef Name = NS->getName();
1107  if (!Name.empty())
1108  addString(NDie, dwarf::DW_AT_name, NS->getName());
1109  else
1110  Name = "(anonymous namespace)";
1111  DD->addAccelNamespace(*CUNode, Name, NDie);
1112  addGlobalName(Name, NDie, NS->getScope());
1113  if (NS->getExportSymbols())
1114  addFlag(NDie, dwarf::DW_AT_export_symbols);
1115  return &NDie;
1116 }
1117 
1119  // Construct the context before querying for the existence of the DIE in case
1120  // such construction creates the DIE.
1121  DIE *ContextDIE = getOrCreateContextDIE(M->getScope());
1122 
1123  if (DIE *MDie = getDIE(M))
1124  return MDie;
1125  DIE &MDie = createAndAddDIE(dwarf::DW_TAG_module, *ContextDIE, M);
1126 
1127  if (!M->getName().empty()) {
1128  addString(MDie, dwarf::DW_AT_name, M->getName());
1129  addGlobalName(M->getName(), MDie, M->getScope());
1130  }
1131  if (!M->getConfigurationMacros().empty())
1132  addString(MDie, dwarf::DW_AT_LLVM_config_macros,
1133  M->getConfigurationMacros());
1134  if (!M->getIncludePath().empty())
1135  addString(MDie, dwarf::DW_AT_LLVM_include_path, M->getIncludePath());
1136  if (!M->getAPINotesFile().empty())
1137  addString(MDie, dwarf::DW_AT_LLVM_apinotes, M->getAPINotesFile());
1138  if (M->getFile())
1139  addUInt(MDie, dwarf::DW_AT_decl_file, None,
1140  getOrCreateSourceID(M->getFile()));
1141  if (M->getLineNo())
1142  addUInt(MDie, dwarf::DW_AT_decl_line, None, M->getLineNo());
1143  if (M->getIsDecl())
1144  addFlag(MDie, dwarf::DW_AT_declaration);
1145 
1146  return &MDie;
1147 }
1148 
1150  // Construct the context before querying for the existence of the DIE in case
1151  // such construction creates the DIE (as is the case for member function
1152  // declarations).
1153  DIE *ContextDIE =
1154  Minimal ? &getUnitDie() : getOrCreateContextDIE(SP->getScope());
1155 
1156  if (DIE *SPDie = getDIE(SP))
1157  return SPDie;
1158 
1159  if (auto *SPDecl = SP->getDeclaration()) {
1160  if (!Minimal) {
1161  // Add subprogram definitions to the CU die directly.
1162  ContextDIE = &getUnitDie();
1163  // Build the decl now to ensure it precedes the definition.
1164  getOrCreateSubprogramDIE(SPDecl);
1165  }
1166  }
1167 
1168  // DW_TAG_inlined_subroutine may refer to this DIE.
1169  DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1170 
1171  // Stop here and fill this in later, depending on whether or not this
1172  // subprogram turns out to have inlined instances or not.
1173  if (SP->isDefinition())
1174  return &SPDie;
1175 
1176  static_cast<DwarfUnit *>(SPDie.getUnit())
1177  ->applySubprogramAttributes(SP, SPDie);
1178  return &SPDie;
1179 }
1180 
1182  DIE &SPDie, bool Minimal) {
1183  DIE *DeclDie = nullptr;
1184  StringRef DeclLinkageName;
1185  if (auto *SPDecl = SP->getDeclaration()) {
1186  if (!Minimal) {
1187  DITypeRefArray DeclArgs, DefinitionArgs;
1188  DeclArgs = SPDecl->getType()->getTypeArray();
1189  DefinitionArgs = SP->getType()->getTypeArray();
1190 
1191  if (DeclArgs.size() && DefinitionArgs.size())
1192  if (DefinitionArgs[0] != nullptr && DeclArgs[0] != DefinitionArgs[0])
1193  addType(SPDie, DefinitionArgs[0]);
1194 
1195  DeclDie = getDIE(SPDecl);
1196  assert(DeclDie && "This DIE should've already been constructed when the "
1197  "definition DIE was created in "
1198  "getOrCreateSubprogramDIE");
1199  // Look at the Decl's linkage name only if we emitted it.
1200  if (DD->useAllLinkageNames())
1201  DeclLinkageName = SPDecl->getLinkageName();
1202  unsigned DeclID = getOrCreateSourceID(SPDecl->getFile());
1203  unsigned DefID = getOrCreateSourceID(SP->getFile());
1204  if (DeclID != DefID)
1205  addUInt(SPDie, dwarf::DW_AT_decl_file, None, DefID);
1206 
1207  if (SP->getLine() != SPDecl->getLine())
1208  addUInt(SPDie, dwarf::DW_AT_decl_line, None, SP->getLine());
1209  }
1210  }
1211 
1212  // Add function template parameters.
1213  addTemplateParams(SPDie, SP->getTemplateParams());
1214 
1215  // Add the linkage name if we have one and it isn't in the Decl.
1216  StringRef LinkageName = SP->getLinkageName();
1217  assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1218  LinkageName == DeclLinkageName) &&
1219  "decl has a linkage name and it is different");
1220  if (DeclLinkageName.empty() &&
1221  // Always emit it for abstract subprograms.
1222  (DD->useAllLinkageNames() || DU->getAbstractSPDies().lookup(SP)))
1223  addLinkageName(SPDie, LinkageName);
1224 
1225  if (!DeclDie)
1226  return false;
1227 
1228  // Refer to the function declaration where all the other attributes will be
1229  // found.
1230  addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1231  return true;
1232 }
1233 
1235  bool SkipSPAttributes) {
1236  // If -fdebug-info-for-profiling is enabled, need to emit the subprogram
1237  // and its source location.
1238  bool SkipSPSourceLocation = SkipSPAttributes &&
1240  if (!SkipSPSourceLocation)
1241  if (applySubprogramDefinitionAttributes(SP, SPDie, SkipSPAttributes))
1242  return;
1243 
1244  // Constructors and operators for anonymous aggregates do not have names.
1245  if (!SP->getName().empty())
1246  addString(SPDie, dwarf::DW_AT_name, SP->getName());
1247 
1248  addAnnotation(SPDie, SP->getAnnotations());
1249 
1250  if (!SkipSPSourceLocation)
1251  addSourceLine(SPDie, SP);
1252 
1253  // Skip the rest of the attributes under -gmlt to save space.
1254  if (SkipSPAttributes)
1255  return;
1256 
1257  // Add the prototype if we have a prototype and we have a C like
1258  // language.
1260  if (SP->isPrototyped() &&
1261  (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1262  Language == dwarf::DW_LANG_ObjC))
1263  addFlag(SPDie, dwarf::DW_AT_prototyped);
1264 
1265  if (SP->isObjCDirect())
1266  addFlag(SPDie, dwarf::DW_AT_APPLE_objc_direct);
1267 
1268  unsigned CC = 0;
1270  if (const DISubroutineType *SPTy = SP->getType()) {
1271  Args = SPTy->getTypeArray();
1272  CC = SPTy->getCC();
1273  }
1274 
1275  // Add a DW_AT_calling_convention if this has an explicit convention.
1276  if (CC && CC != dwarf::DW_CC_normal)
1277  addUInt(SPDie, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1, CC);
1278 
1279  // Add a return type. If this is a type like a C/C++ void type we don't add a
1280  // return type.
1281  if (Args.size())
1282  if (auto Ty = Args[0])
1283  addType(SPDie, Ty);
1284 
1285  unsigned VK = SP->getVirtuality();
1286  if (VK) {
1287  addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1288  if (SP->getVirtualIndex() != -1u) {
1289  DIELoc *Block = getDIELoc();
1290  addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1291  addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex());
1292  addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1293  }
1294  ContainingTypeMap.insert(std::make_pair(&SPDie, SP->getContainingType()));
1295  }
1296 
1297  if (!SP->isDefinition()) {
1298  addFlag(SPDie, dwarf::DW_AT_declaration);
1299 
1300  // Add arguments. Do not add arguments for subprogram definition. They will
1301  // be handled while processing variables.
1303  }
1304 
1305  addThrownTypes(SPDie, SP->getThrownTypes());
1306 
1307  if (SP->isArtificial())
1308  addFlag(SPDie, dwarf::DW_AT_artificial);
1309 
1310  if (!SP->isLocalToUnit())
1311  addFlag(SPDie, dwarf::DW_AT_external);
1312 
1314  if (SP->isOptimized())
1315  addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1316 
1317  if (unsigned isa = Asm->getISAEncoding())
1318  addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1319  }
1320 
1321  if (SP->isLValueReference())
1322  addFlag(SPDie, dwarf::DW_AT_reference);
1323 
1324  if (SP->isRValueReference())
1325  addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1326 
1327  if (SP->isNoReturn())
1328  addFlag(SPDie, dwarf::DW_AT_noreturn);
1329 
1330  addAccess(SPDie, SP->getFlags());
1331 
1332  if (SP->isExplicit())
1333  addFlag(SPDie, dwarf::DW_AT_explicit);
1334 
1335  if (SP->isMainSubprogram())
1336  addFlag(SPDie, dwarf::DW_AT_main_subprogram);
1337  if (SP->isPure())
1338  addFlag(SPDie, dwarf::DW_AT_pure);
1339  if (SP->isElemental())
1340  addFlag(SPDie, dwarf::DW_AT_elemental);
1341  if (SP->isRecursive())
1342  addFlag(SPDie, dwarf::DW_AT_recursive);
1343 
1344  if (DD->getDwarfVersion() >= 5 && SP->isDeleted())
1345  addFlag(SPDie, dwarf::DW_AT_deleted);
1346 }
1347 
1348 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
1349  DIE *IndexTy) {
1350  DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1351  addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1352 
1353  // The LowerBound value defines the lower bounds which is typically zero for
1354  // C/C++. The Count value is the number of elements. Values are 64 bit. If
1355  // Count == -1 then the array is unbounded and we do not emit
1356  // DW_AT_lower_bound and DW_AT_count attributes.
1357  int64_t DefaultLowerBound = getDefaultLowerBound();
1358 
1359  auto AddBoundTypeEntry = [&](dwarf::Attribute Attr,
1360  DISubrange::BoundType Bound) -> void {
1361  if (auto *BV = Bound.dyn_cast<DIVariable *>()) {
1362  if (auto *VarDIE = getDIE(BV))
1363  addDIEEntry(DW_Subrange, Attr, *VarDIE);
1364  } else if (auto *BE = Bound.dyn_cast<DIExpression *>()) {
1365  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1366  DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
1367  DwarfExpr.setMemoryLocationKind();
1368  DwarfExpr.addExpression(BE);
1369  addBlock(DW_Subrange, Attr, DwarfExpr.finalize());
1370  } else if (auto *BI = Bound.dyn_cast<ConstantInt *>()) {
1371  if (Attr == dwarf::DW_AT_count) {
1372  if (BI->getSExtValue() != -1)
1373  addUInt(DW_Subrange, Attr, None, BI->getSExtValue());
1374  } else if (Attr != dwarf::DW_AT_lower_bound || DefaultLowerBound == -1 ||
1375  BI->getSExtValue() != DefaultLowerBound)
1376  addSInt(DW_Subrange, Attr, dwarf::DW_FORM_sdata, BI->getSExtValue());
1377  }
1378  };
1379 
1380  AddBoundTypeEntry(dwarf::DW_AT_lower_bound, SR->getLowerBound());
1381 
1382  AddBoundTypeEntry(dwarf::DW_AT_count, SR->getCount());
1383 
1384  AddBoundTypeEntry(dwarf::DW_AT_upper_bound, SR->getUpperBound());
1385 
1386  AddBoundTypeEntry(dwarf::DW_AT_byte_stride, SR->getStride());
1387 }
1388 
1389 void DwarfUnit::constructGenericSubrangeDIE(DIE &Buffer,
1390  const DIGenericSubrange *GSR,
1391  DIE *IndexTy) {
1392  DIE &DwGenericSubrange =
1393  createAndAddDIE(dwarf::DW_TAG_generic_subrange, Buffer);
1394  addDIEEntry(DwGenericSubrange, dwarf::DW_AT_type, *IndexTy);
1395 
1396  int64_t DefaultLowerBound = getDefaultLowerBound();
1397 
1398  auto AddBoundTypeEntry = [&](dwarf::Attribute Attr,
1399  DIGenericSubrange::BoundType Bound) -> void {
1400  if (auto *BV = Bound.dyn_cast<DIVariable *>()) {
1401  if (auto *VarDIE = getDIE(BV))
1402  addDIEEntry(DwGenericSubrange, Attr, *VarDIE);
1403  } else if (auto *BE = Bound.dyn_cast<DIExpression *>()) {
1404  if (BE->isConstant() &&
1405  DIExpression::SignedOrUnsignedConstant::SignedConstant ==
1406  *BE->isConstant()) {
1407  if (Attr != dwarf::DW_AT_lower_bound || DefaultLowerBound == -1 ||
1408  static_cast<int64_t>(BE->getElement(1)) != DefaultLowerBound)
1409  addSInt(DwGenericSubrange, Attr, dwarf::DW_FORM_sdata,
1410  BE->getElement(1));
1411  } else {
1412  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1413  DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
1414  DwarfExpr.setMemoryLocationKind();
1415  DwarfExpr.addExpression(BE);
1416  addBlock(DwGenericSubrange, Attr, DwarfExpr.finalize());
1417  }
1418  }
1419  };
1420 
1421  AddBoundTypeEntry(dwarf::DW_AT_lower_bound, GSR->getLowerBound());
1422  AddBoundTypeEntry(dwarf::DW_AT_count, GSR->getCount());
1423  AddBoundTypeEntry(dwarf::DW_AT_upper_bound, GSR->getUpperBound());
1424  AddBoundTypeEntry(dwarf::DW_AT_byte_stride, GSR->getStride());
1425 }
1426 
1427 DIE *DwarfUnit::getIndexTyDie() {
1428  if (IndexTyDie)
1429  return IndexTyDie;
1430  // Construct an integer type to use for indexes.
1431  IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, getUnitDie());
1432  StringRef Name = "__ARRAY_SIZE_TYPE__";
1433  addString(*IndexTyDie, dwarf::DW_AT_name, Name);
1434  addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1435  addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1436  dwarf::DW_ATE_unsigned);
1437  DD->addAccelType(*CUNode, Name, *IndexTyDie, /*Flags*/ 0);
1438  return IndexTyDie;
1439 }
1440 
1441 /// Returns true if the vector's size differs from the sum of sizes of elements
1442 /// the user specified. This can occur if the vector has been rounded up to
1443 /// fit memory alignment constraints.
1444 static bool hasVectorBeenPadded(const DICompositeType *CTy) {
1445  assert(CTy && CTy->isVector() && "Composite type is not a vector");
1446  const uint64_t ActualSize = CTy->getSizeInBits();
1447 
1448  // Obtain the size of each element in the vector.
1449  DIType *BaseTy = CTy->getBaseType();
1450  assert(BaseTy && "Unknown vector element type.");
1451  const uint64_t ElementSize = BaseTy->getSizeInBits();
1452 
1453  // Locate the number of elements in the vector.
1454  const DINodeArray Elements = CTy->getElements();
1455  assert(Elements.size() == 1 &&
1456  Elements[0]->getTag() == dwarf::DW_TAG_subrange_type &&
1457  "Invalid vector element array, expected one element of type subrange");
1458  const auto Subrange = cast<DISubrange>(Elements[0]);
1459  const auto NumVecElements =
1460  Subrange->getCount()
1461  ? Subrange->getCount().get<ConstantInt *>()->getSExtValue()
1462  : 0;
1463 
1464  // Ensure we found the element count and that the actual size is wide
1465  // enough to contain the requested size.
1466  assert(ActualSize >= (NumVecElements * ElementSize) && "Invalid vector size");
1467  return ActualSize != (NumVecElements * ElementSize);
1468 }
1469 
1470 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1471  if (CTy->isVector()) {
1472  addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1473  if (hasVectorBeenPadded(CTy))
1474  addUInt(Buffer, dwarf::DW_AT_byte_size, None,
1475  CTy->getSizeInBits() / CHAR_BIT);
1476  }
1477 
1478  if (DIVariable *Var = CTy->getDataLocation()) {
1479  if (auto *VarDIE = getDIE(Var))
1480  addDIEEntry(Buffer, dwarf::DW_AT_data_location, *VarDIE);
1481  } else if (DIExpression *Expr = CTy->getDataLocationExp()) {
1482  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1483  DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
1484  DwarfExpr.setMemoryLocationKind();
1485  DwarfExpr.addExpression(Expr);
1486  addBlock(Buffer, dwarf::DW_AT_data_location, DwarfExpr.finalize());
1487  }
1488 
1489  if (DIVariable *Var = CTy->getAssociated()) {
1490  if (auto *VarDIE = getDIE(Var))
1491  addDIEEntry(Buffer, dwarf::DW_AT_associated, *VarDIE);
1492  } else if (DIExpression *Expr = CTy->getAssociatedExp()) {
1493  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1494  DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
1495  DwarfExpr.setMemoryLocationKind();
1496  DwarfExpr.addExpression(Expr);
1497  addBlock(Buffer, dwarf::DW_AT_associated, DwarfExpr.finalize());
1498  }
1499 
1500  if (DIVariable *Var = CTy->getAllocated()) {
1501  if (auto *VarDIE = getDIE(Var))
1502  addDIEEntry(Buffer, dwarf::DW_AT_allocated, *VarDIE);
1503  } else if (DIExpression *Expr = CTy->getAllocatedExp()) {
1504  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1505  DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
1506  DwarfExpr.setMemoryLocationKind();
1507  DwarfExpr.addExpression(Expr);
1508  addBlock(Buffer, dwarf::DW_AT_allocated, DwarfExpr.finalize());
1509  }
1510 
1511  if (auto *RankConst = CTy->getRankConst()) {
1512  addSInt(Buffer, dwarf::DW_AT_rank, dwarf::DW_FORM_sdata,
1513  RankConst->getSExtValue());
1514  } else if (auto *RankExpr = CTy->getRankExp()) {
1515  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1516  DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
1517  DwarfExpr.setMemoryLocationKind();
1518  DwarfExpr.addExpression(RankExpr);
1519  addBlock(Buffer, dwarf::DW_AT_rank, DwarfExpr.finalize());
1520  }
1521 
1522  // Emit the element type.
1523  addType(Buffer, CTy->getBaseType());
1524 
1525  // Get an anonymous type for index type.
1526  // FIXME: This type should be passed down from the front end
1527  // as different languages may have different sizes for indexes.
1528  DIE *IdxTy = getIndexTyDie();
1529 
1530  // Add subranges to array type.
1531  DINodeArray Elements = CTy->getElements();
1532  for (DINode *E : Elements) {
1533  // FIXME: Should this really be such a loose cast?
1534  if (auto *Element = dyn_cast_or_null<DINode>(E)) {
1535  if (Element->getTag() == dwarf::DW_TAG_subrange_type)
1536  constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
1537  else if (Element->getTag() == dwarf::DW_TAG_generic_subrange)
1538  constructGenericSubrangeDIE(Buffer, cast<DIGenericSubrange>(Element),
1539  IdxTy);
1540  }
1541  }
1542 }
1543 
1544 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1545  const DIType *DTy = CTy->getBaseType();
1546  bool IsUnsigned = DTy && DD->isUnsignedDIType(DTy);
1547  if (DTy) {
1548  if (DD->getDwarfVersion() >= 3)
1549  addType(Buffer, DTy);
1550  if (DD->getDwarfVersion() >= 4 && (CTy->getFlags() & DINode::FlagEnumClass))
1551  addFlag(Buffer, dwarf::DW_AT_enum_class);
1552  }
1553 
1554  auto *Context = CTy->getScope();
1555  bool IndexEnumerators = !Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
1556  isa<DINamespace>(Context) || isa<DICommonBlock>(Context);
1557  DINodeArray Elements = CTy->getElements();
1558 
1559  // Add enumerators to enumeration type.
1560  for (const DINode *E : Elements) {
1561  auto *Enum = dyn_cast_or_null<DIEnumerator>(E);
1562  if (Enum) {
1563  DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1564  StringRef Name = Enum->getName();
1565  addString(Enumerator, dwarf::DW_AT_name, Name);
1566  addConstantValue(Enumerator, Enum->getValue(), IsUnsigned);
1567  if (IndexEnumerators)
1568  addGlobalName(Name, Enumerator, Context);
1569  }
1570  }
1571 }
1572 
1574  for (auto &P : ContainingTypeMap) {
1575  DIE &SPDie = *P.first;
1576  const DINode *D = P.second;
1577  if (!D)
1578  continue;
1579  DIE *NDie = getDIE(D);
1580  if (!NDie)
1581  continue;
1582  addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1583  }
1584 }
1585 
1586 DIE &DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
1587  DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer);
1588  StringRef Name = DT->getName();
1589  if (!Name.empty())
1590  addString(MemberDie, dwarf::DW_AT_name, Name);
1591 
1592  addAnnotation(MemberDie, DT->getAnnotations());
1593 
1594  if (DIType *Resolved = DT->getBaseType())
1595  addType(MemberDie, Resolved);
1596 
1597  addSourceLine(MemberDie, DT);
1598 
1599  if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
1600 
1601  // For C++, virtual base classes are not at fixed offset. Use following
1602  // expression to extract appropriate offset from vtable.
1603  // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1604 
1605  DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc;
1606  addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1607  addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1608  addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1609  addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits());
1610  addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1611  addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1612  addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1613 
1614  addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1615  } else {
1616  uint64_t Size = DT->getSizeInBits();
1617  uint64_t FieldSize = DD->getBaseTypeSize(DT);
1618  uint32_t AlignInBytes = DT->getAlignInBytes();
1619  uint64_t OffsetInBytes;
1620 
1621  bool IsBitfield = FieldSize && Size != FieldSize;
1622  if (IsBitfield) {
1623  // Handle bitfield, assume bytes are 8 bits.
1624  if (DD->useDWARF2Bitfields())
1625  addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1626  addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1627 
1628  uint64_t Offset = DT->getOffsetInBits();
1629  // We can't use DT->getAlignInBits() here: AlignInBits for member type
1630  // is non-zero if and only if alignment was forced (e.g. _Alignas()),
1631  // which can't be done with bitfields. Thus we use FieldSize here.
1632  uint32_t AlignInBits = FieldSize;
1633  uint32_t AlignMask = ~(AlignInBits - 1);
1634  // The bits from the start of the storage unit to the start of the field.
1635  uint64_t StartBitOffset = Offset - (Offset & AlignMask);
1636  // The byte offset of the field's aligned storage unit inside the struct.
1637  OffsetInBytes = (Offset - StartBitOffset) / 8;
1638 
1639  if (DD->useDWARF2Bitfields()) {
1640  uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1641  uint64_t FieldOffset = (HiMark - FieldSize);
1642  Offset -= FieldOffset;
1643 
1644  // Maybe we need to work from the other end.
1645  if (Asm->getDataLayout().isLittleEndian())
1646  Offset = FieldSize - (Offset + Size);
1647 
1648  addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1649  OffsetInBytes = FieldOffset >> 3;
1650  } else {
1651  addUInt(MemberDie, dwarf::DW_AT_data_bit_offset, None, Offset);
1652  }
1653  } else {
1654  // This is not a bitfield.
1655  OffsetInBytes = DT->getOffsetInBits() / 8;
1656  if (AlignInBytes)
1657  addUInt(MemberDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1658  AlignInBytes);
1659  }
1660 
1661  if (DD->getDwarfVersion() <= 2) {
1662  DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc;
1663  addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1664  addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1665  addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1666  } else if (!IsBitfield || DD->useDWARF2Bitfields()) {
1667  // In DWARF v3, DW_FORM_data4/8 in DW_AT_data_member_location are
1668  // interpreted as location-list pointers. Interpreting constants as
1669  // pointers is not expected, so we use DW_FORM_udata to encode the
1670  // constants here.
1671  if (DD->getDwarfVersion() == 3)
1672  addUInt(MemberDie, dwarf::DW_AT_data_member_location,
1673  dwarf::DW_FORM_udata, OffsetInBytes);
1674  else
1675  addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1676  OffsetInBytes);
1677  }
1678  }
1679 
1680  addAccess(MemberDie, DT->getFlags());
1681 
1682  if (DT->isVirtual())
1683  addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1684  dwarf::DW_VIRTUALITY_virtual);
1685 
1686  // Objective-C properties.
1687  if (DINode *PNode = DT->getObjCProperty())
1688  if (DIE *PDie = getDIE(PNode))
1689  addAttribute(MemberDie, dwarf::DW_AT_APPLE_property,
1690  dwarf::DW_FORM_ref4, DIEEntry(*PDie));
1691 
1692  if (DT->isArtificial())
1693  addFlag(MemberDie, dwarf::DW_AT_artificial);
1694 
1695  return MemberDie;
1696 }
1697 
1699  if (!DT)
1700  return nullptr;
1701 
1702  // Construct the context before querying for the existence of the DIE in case
1703  // such construction creates the DIE.
1704  DIE *ContextDIE = getOrCreateContextDIE(DT->getScope());
1705  assert(dwarf::isType(ContextDIE->getTag()) &&
1706  "Static member should belong to a type.");
1707 
1708  if (DIE *StaticMemberDIE = getDIE(DT))
1709  return StaticMemberDIE;
1710 
1711  DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT);
1712 
1713  const DIType *Ty = DT->getBaseType();
1714 
1715  addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName());
1716  addType(StaticMemberDIE, Ty);
1717  addSourceLine(StaticMemberDIE, DT);
1718  addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1719  addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1720 
1721  // FIXME: We could omit private if the parent is a class_type, and
1722  // public if the parent is something else.
1723  addAccess(StaticMemberDIE, DT->getFlags());
1724 
1725  if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant()))
1726  addConstantValue(StaticMemberDIE, CI, Ty);
1727  if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant()))
1728  addConstantFPValue(StaticMemberDIE, CFP);
1729 
1730  if (uint32_t AlignInBytes = DT->getAlignInBytes())
1731  addUInt(StaticMemberDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1732  AlignInBytes);
1733 
1734  return &StaticMemberDIE;
1735 }
1736 
1738  // Emit size of content not including length itself
1739  if (!DD->useSectionsAsReferences())
1741  isDwoUnit() ? "debug_info_dwo" : "debug_info", "Length of Unit");
1742  else
1744  "Length of Unit");
1745 
1746  Asm->OutStreamer->AddComment("DWARF version number");
1747  unsigned Version = DD->getDwarfVersion();
1748  Asm->emitInt16(Version);
1749 
1750  // DWARF v5 reorders the address size and adds a unit type.
1751  if (Version >= 5) {
1752  Asm->OutStreamer->AddComment("DWARF Unit Type");
1753  Asm->emitInt8(UT);
1754  Asm->OutStreamer->AddComment("Address Size (in bytes)");
1756  }
1757 
1758  // We share one abbreviations table across all units so it's always at the
1759  // start of the section. Use a relocatable offset where needed to ensure
1760  // linking doesn't invalidate that offset.
1761  Asm->OutStreamer->AddComment("Offset Into Abbrev. Section");
1763  if (UseOffsets)
1765  else
1767  TLOF.getDwarfAbbrevSection()->getBeginSymbol(), false);
1768 
1769  if (Version <= 4) {
1770  Asm->OutStreamer->AddComment("Address Size (in bytes)");
1772  }
1773 }
1774 
1775 void DwarfTypeUnit::emitHeader(bool UseOffsets) {
1776  DwarfUnit::emitCommonHeader(UseOffsets,
1777  DD->useSplitDwarf() ? dwarf::DW_UT_split_type
1778  : dwarf::DW_UT_type);
1779  Asm->OutStreamer->AddComment("Type Signature");
1780  Asm->OutStreamer->emitIntValue(TypeSignature, sizeof(TypeSignature));
1781  Asm->OutStreamer->AddComment("Type DIE Offset");
1782  // In a skeleton type unit there is no type DIE so emit a zero offset.
1783  Asm->emitDwarfLengthOrOffset(Ty ? Ty->getOffset() : 0);
1784 }
1785 
1787  const MCSymbol *Hi, const MCSymbol *Lo) {
1790 }
1791 
1793  const MCSymbol *Label, const MCSymbol *Sec) {
1796  else
1797  addSectionDelta(Die, Attribute, Label, Sec);
1798 }
1799 
1800 bool DwarfTypeUnit::isDwoUnit() const {
1801  // Since there are no skeleton type units, all type units are dwo type units
1802  // when split DWARF is being used.
1803  return DD->useSplitDwarf();
1804 }
1805 
1807  const DIScope *Context) {
1809 }
1810 
1811 void DwarfTypeUnit::addGlobalType(const DIType *Ty, const DIE &Die,
1812  const DIScope *Context) {
1814 }
1815 
1816 const MCSymbol *DwarfUnit::getCrossSectionRelativeBaseAddress() const {
1818  return nullptr;
1819  if (isDwoUnit())
1820  return nullptr;
1821  return getSection()->getBeginSymbol();
1822 }
1823 
1826  addSectionLabel(getUnitDie(), dwarf::DW_AT_str_offsets_base,
1829 }
1830 
1832  assert(DD->getDwarfVersion() >= 5 &&
1833  "DW_AT_rnglists_base requires DWARF version 5 or later");
1835  addSectionLabel(getUnitDie(), dwarf::DW_AT_rnglists_base,
1838 }
1839 
1840 void DwarfTypeUnit::finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) {
1841  addFlag(D, dwarf::DW_AT_declaration);
1842  StringRef Name = CTy->getName();
1843  if (!Name.empty())
1844  addString(D, dwarf::DW_AT_name, Name);
1845  getCU().createTypeDIE(CTy);
1846 }
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
llvm::DIType::getScope
DIScope * getScope() const
Definition: DebugInfoMetadata.h:710
llvm::DwarfUnit::getOrCreateStaticMemberDIE
DIE * getOrCreateStaticMemberDIE(const DIDerivedType *DT)
Create new static data member DIE.
Definition: DwarfUnit.cpp:1698
i
i
Definition: README.txt:29
llvm::DwarfUnit::addSourceLine
void addSourceLine(DIE &Die, unsigned Line, const DIFile *File)
Add location information to specified debug information entry.
Definition: DwarfUnit.cpp:414
llvm::DwarfStringPool::getEntry
EntryRef getEntry(AsmPrinter &Asm, StringRef Str)
Get a reference to an entry in the string pool.
Definition: DwarfStringPool.cpp:39
llvm::DICompositeType::getRankExp
DIExpression * getRankExp() const
Definition: DebugInfoMetadata.h:1242
llvm::DwarfUnit::isShareableAcrossCUs
bool isShareableAcrossCUs(const DINode *D) const
Check whether the DIE for this MDNode can be shared across CUs.
Definition: DwarfUnit.cpp:188
llvm::DwarfUnit::useSegmentedStringOffsetsTable
bool useSegmentedStringOffsetsTable() const
Definition: DwarfUnit.h:263
llvm::DwarfUnit::getOrCreateSourceID
virtual unsigned getOrCreateSourceID(const DIFile *File)=0
Look up the source ID for the given file.
llvm::DILabel::getLine
unsigned getLine() const
Definition: DebugInfoMetadata.h:3238
llvm::DICompositeType::getVTableHolder
DIType * getVTableHolder() const
Definition: DebugInfoMetadata.h:1197
llvm::DIObjCProperty::getFile
DIFile * getFile() const
Definition: DebugInfoMetadata.h:3314
llvm::DICompositeType::getBaseType
DIType * getBaseType() const
Definition: DebugInfoMetadata.h:1193
llvm::DwarfUnit::addRnglistsBase
void addRnglistsBase()
Add the DW_AT_rnglists_base attribute to the unit DIE.
Definition: DwarfUnit.cpp:1831
MCDwarf.h
llvm::DwarfUnit::addThrownTypes
void addThrownTypes(DIE &Die, DINodeArray ThrownTypes)
Add thrown types.
Definition: DwarfUnit.cpp:532
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AllocatorList.h:23
llvm::DIType
Base class for types.
Definition: DebugInfoMetadata.h:665
llvm::MCSymbol
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::DwarfDebug::getAddressPool
AddressPool & getAddressPool()
Definition: DwarfDebug.h:804
llvm::DwarfUnit::addFlag
void addFlag(DIE &Die, dwarf::Attribute Attribute)
Add a flag that is true to the DIE.
Definition: DwarfUnit.cpp:221
Metadata.h
llvm::DIType::getSizeInBits
uint64_t getSizeInBits() const
Definition: DebugInfoMetadata.h:704
llvm::GlobalValue::dropLLVMManglingEscape
static StringRef dropLLVMManglingEscape(StringRef Name)
If the given string begins with the GlobalValue name mangling escape character '\1',...
Definition: GlobalValue.h:488
llvm::DIGenericSubrange
Definition: DebugInfoMetadata.h:362
T
llvm::dwarf::DW_ACCESS_protected
@ DW_ACCESS_protected
Definition: Dwarf.h:177
llvm::Attribute
Definition: Attributes.h:52
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::DwarfUnit::getOrCreateContextDIE
DIE * getOrCreateContextDIE(const DIScope *Context)
Get context owner's DIE.
Definition: DwarfUnit.cpp:551
llvm::DwarfUnit::emitCommonHeader
void emitCommonHeader(bool UseOffsets, dwarf::UnitType UT)
Emit the common part of the header for this unit.
Definition: DwarfUnit.cpp:1737
llvm::DwarfCompileUnit
Definition: DwarfCompileUnit.h:47
llvm::DwarfFile::getAbstractSPDies
DenseMap< const MDNode *, DIE * > & getAbstractSPDies()
Definition: DwarfFile.h:165
llvm::DICompositeType::getAnnotations
DINodeArray getAnnotations() const
Definition: DebugInfoMetadata.h:1247
llvm::DwarfUnit::DU
DwarfFile * DU
Definition: DwarfUnit.h:51
llvm::DIType::isAppleBlockExtension
bool isAppleBlockExtension() const
Definition: DebugInfoMetadata.h:733
llvm::AsmPrinter::MAI
const MCAsmInfo * MAI
Target Asm Printer information.
Definition: AsmPrinter.h:88
llvm::DwarfFile::getDIE
DIE * getDIE(const MDNode *TypeMD)
Definition: DwarfFile.h:177
llvm::DIEUnit
Represents a compile or type unit.
Definition: DIE.h:880
llvm::ConstantInt::getValue
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:133
llvm::MCSection::getBeginSymbol
MCSymbol * getBeginSymbol()
Definition: MCSection.h:127
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1175
llvm::DIStringType
String type, Fortran CHARACTER(n)
Definition: DebugInfoMetadata.h:839
llvm::isa
LLVM_NODISCARD bool isa(const Y &Val)
Definition: Casting.h:141
llvm::dwarf::Form
Form
Definition: Dwarf.h:131
llvm::DwarfUnit::addLabelDelta
void addLabelDelta(DIEValueList &Die, dwarf::Attribute Attribute, const MCSymbol *Hi, const MCSymbol *Lo)
Add a label delta attribute data and value.
Definition: DwarfUnit.cpp:354
llvm::APInt::getSExtValue
int64_t getSExtValue() const
Get sign extended value.
Definition: APInt.h:1479
llvm::DITemplateParameter::isDefault
bool isDefault() const
Definition: DebugInfoMetadata.h:2428
llvm::MipsISD::Lo
@ Lo
Definition: MipsISelLowering.h:79
llvm::DwarfUnit::insertDIE
void insertDIE(const DINode *Desc, DIE *D)
Insert DIE into the map.
Definition: DwarfUnit.cpp:209
llvm::DwarfUnit::addOpAddress
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:339
llvm::DwarfUnit::getDIE
DIE * getDIE(const DINode *D) const
Returns the DIE map slot for the specified debug variable.
Definition: DwarfUnit.cpp:203
llvm::DIScope::getName
StringRef getName() const
Definition: DebugInfoMetadata.cpp:262
llvm::DwarfUnit::getOrCreateSubprogramDIE
DIE * getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal=false)
Definition: DwarfUnit.cpp:1149
llvm::DICompositeType::getRankConst
ConstantInt * getRankConst() const
Definition: DebugInfoMetadata.h:1237
APInt.h
llvm::TargetRegisterInfo
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
Definition: TargetRegisterInfo.h:233
llvm::DwarfUnit::addType
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:659
llvm::DwarfUnit::getCU
virtual DwarfCompileUnit & getCU()=0
llvm::DISubrange::getUpperBound
BoundType getUpperBound() const
Definition: DebugInfoMetadata.cpp:412
llvm::DIType::isVirtual
bool isVirtual() const
Definition: DebugInfoMetadata.h:734
llvm::APInt::getBitWidth
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1412
llvm::DwarfUnit::addString
void addString(DIE &Die, dwarf::Attribute Attribute, StringRef Str)
Add a string attribute data and value.
Definition: DwarfUnit.cpp:254
llvm::reverse
auto reverse(ContainerTy &&C, std::enable_if_t< has_rbegin< ContainerTy >::value > *=nullptr)
Definition: STLExtras.h:414
llvm::DwarfUnit::addDIETypeSignature
void addDIETypeSignature(DIE &Die, uint64_t Signature)
Add a type's DW_AT_signature and set the declaration flag.
Definition: DwarfUnit.cpp:364
llvm::DICompositeType::getDataLocationExp
DIExpression * getDataLocationExp() const
Definition: DebugInfoMetadata.h:1219
llvm::ConstantFP::getValueAPF
const APFloat & getValueAPF() const
Definition: Constants.h:297
llvm::DIStringType::getStringLengthExp
DIExpression * getStringLengthExp() const
Definition: DebugInfoMetadata.h:902
llvm::MCAsmInfo::getCodePointerSize
unsigned getCodePointerSize() const
Get the code pointer size in bytes.
Definition: MCAsmInfo.h:536
llvm::Optional
Definition: APInt.h:33
llvm::DIType::getAlignInBytes
uint32_t getAlignInBytes() const
Definition: DebugInfoMetadata.h:706
llvm::DIE
A structured debug information entry.
Definition: DIE.h:739
llvm::DwarfUnit::addSInt
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:242
llvm::MCObjectFileInfo::getDwarfStrOffSection
MCSection * getDwarfStrOffSection() const
Definition: MCObjectFileInfo.h:315
llvm::DIExpression
DWARF expression.
Definition: DebugInfoMetadata.h:2596
llvm::DwarfFile::insertDIE
void insertDIE(const MDNode *TypeMD, DIE *Die)
Definition: DwarfFile.h:173
llvm::DIE::getTag
dwarf::Tag getTag() const
Definition: DIE.h:775
llvm::dwarf::Tag
Tag
Definition: Dwarf.h:104
llvm::DINameKind::LinkageName
@ LinkageName
llvm::DwarfStringPool::getIndexedEntry
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....
Definition: DwarfStringPool.cpp:45
llvm::DINode::FlagAccessibility
@ FlagAccessibility
Definition: DebugInfoMetadata.h:170
llvm::DwarfUnit::constructTypeDIE
void constructTypeDIE(DIE &Buffer, const DICompositeType *CTy)
Definition: DwarfUnit.cpp:871
llvm::DwarfDebug::useSectionsAsReferences
bool useSectionsAsReferences() const
Returns whether to use sections as labels rather than temp symbols.
Definition: DwarfDebug.h:729
TRI
unsigned const TargetRegisterInfo * TRI
Definition: MachineSink.cpp:1564
llvm::Data
@ Data
Definition: SIMachineScheduler.h:55
llvm::DINamespace
Definition: DebugInfoMetadata.h:2286
llvm::DwarfDebug::addDwarfTypeUnitType
void addDwarfTypeUnitType(DwarfCompileUnit &CU, StringRef Identifier, DIE &Die, const DICompositeType *CTy)
Add a DIE to the set of types that we're going to pull into type units.
Definition: DwarfDebug.cpp:3364
getBaseType
static enum BaseType getBaseType(const Value *Val)
Return the baseType for Val which states whether Val is exclusively derived from constant/null,...
Definition: SafepointIRVerifier.cpp:328
llvm::DIType::isLValueReference
bool isLValueReference() const
Definition: DebugInfoMetadata.h:743
llvm::dwarf::Attribute
Attribute
Attributes.
Definition: Dwarf.h:124
new
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM ID Predecessors according to mbb< bb27, 0x8b0a7c0 > Note ADDri is not a two address instruction its result reg1037 is an operand of the PHI node in bb76 and its operand reg1039 is the result of the PHI node We should treat it as a two address code and make sure the ADDri is scheduled after any node that reads reg1039 Use info(i.e. register scavenger) to assign it a free register to allow reuse the collector could move the objects and invalidate the derived pointer This is bad enough in the first but safe points can crop up unpredictably **array_addr i32 n y store obj * new
Definition: README.txt:125
Context
ManagedStatic< detail::RecordContext > Context
Definition: Record.cpp:96
llvm::Annotations
Annotations lets you mark points and ranges inside source code, for tests:
Definition: Annotations.h:46
llvm::MipsISD::Hi
@ Hi
Definition: MipsISelLowering.h:75
llvm::TargetLoweringObjectFile
Definition: TargetLoweringObjectFile.h:44
llvm::DwarfExpression
Base class containing the logic for constructing DWARF expressions independently of whether they are ...
Definition: DwarfExpression.h:106
llvm::DITypeRefArray
Definition: DebugInfoMetadata.h:67
Arg
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
Definition: AMDGPULibCalls.cpp:185
hasVectorBeenPadded
static bool hasVectorBeenPadded(const DICompositeType *CTy)
Returns true if the vector's size differs from the sum of sizes of elements the user specified.
Definition: DwarfUnit.cpp:1444
llvm::DIE::addChild
DIE & addChild(DIE *Child)
Add a child to the DIE.
Definition: DIE.h:854
llvm::DwarfDebug::addAccelNamespace
void addAccelNamespace(const DICompileUnit &CU, StringRef Name, const DIE &Die)
Definition: DwarfDebug.cpp:3510
CommandLine.h
DwarfExpression.h
llvm::ConstantInt
This is the shared class of boolean and integer constants.
Definition: Constants.h:79
llvm::DIObjCProperty
Definition: DebugInfoMetadata.h:3260
llvm::DIType::getFlags
DIFlags getFlags() const
Definition: DebugInfoMetadata.h:708
llvm::DITemplateParameter::getType
DIType * getType() const
Definition: DebugInfoMetadata.h:2424
llvm::DwarfDebug::useAllLinkageNames
bool useAllLinkageNames() const
Returns whether we should emit all DW_AT_[MIPS_]linkage_name.
Definition: DwarfDebug.h:694
GlobalValue.h
llvm::DISubrange::getCount
BoundType getCount() const
Definition: DebugInfoMetadata.cpp:370
Constants.h
llvm::DwarfDebug::getMD5AsBytes
Optional< MD5::MD5Result > getMD5AsBytes(const DIFile *File) const
If the File has an MD5 checksum, return it as an MD5Result allocated in the MCContext.
Definition: DwarfDebug.cpp:3545
llvm::DILocalVariable
Local variable.
Definition: DebugInfoMetadata.h:3104
llvm::DwarfUnit::constructContainingTypeDIEs
void constructContainingTypeDIEs()
Construct DIEs for types that contain vtables.
Definition: DwarfUnit.cpp:1573
llvm::DwarfUnit::addSectionOffset
void addSectionOffset(DIE &Die, dwarf::Attribute Attribute, uint64_t Integer)
Add an offset into a section attribute data and value.
Definition: DwarfUnit.cpp:296
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::AMDGPU::HSAMD::Kernel::Key::Language
constexpr char Language[]
Key for Kernel::Metadata::mLanguage.
Definition: AMDGPUMetadata.h:383
llvm::AsmPrinter::OutStreamer
std::unique_ptr< MCStreamer > OutStreamer
This is the MCStreamer object for the file we are generating.
Definition: AsmPrinter.h:97
llvm::DwarfUnit::addConstantValue
void addConstantValue(DIE &Die, const ConstantInt *CI, const DIType *Ty)
Add constant value entry in variable DIE.
Definition: DwarfUnit.cpp:464
llvm::HighlightColor::Enumerator
@ Enumerator
llvm::DwarfUnit::addAnnotation
void addAnnotation(DIE &Buffer, DINodeArray Annotations)
Add DW_TAG_LLVM_annotation.
Definition: DwarfUnit.cpp:850
llvm::DwarfUnit::addSectionLabel
void addSectionLabel(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Label, const MCSymbol *Sec)
Add a Dwarf section label attribute data and value.
Definition: DwarfUnit.cpp:1792
llvm::DwarfUnit::DIEBlocks
std::vector< DIEBlock * > DIEBlocks
A list of all the DIEBlocks in use.
Definition: DwarfUnit.h:61
MCContext.h
llvm::dwarf::DW_FLAG_type_implementation
@ DW_FLAG_type_implementation
Definition: Dwarf.h:517
llvm::DwarfDebug::useAddrOffsetForm
bool useAddrOffsetForm() const
Definition: DwarfDebug.h:724
llvm::DIType::getLine
unsigned getLine() const
Definition: DebugInfoMetadata.h:703
llvm::DwarfUnit::getParentContextString
std::string getParentContextString(const DIScope *Context) const
Get string containing language specific context for a global name.
Definition: DwarfUnit.cpp:665
llvm::DIType::isObjcClassComplete
bool isObjcClassComplete() const
Definition: DebugInfoMetadata.h:737
llvm::DwarfUnit::CUNode
const DICompileUnit * CUNode
MDNode for the compile unit.
Definition: DwarfUnit.h:38
llvm::DIType::getName
StringRef getName() const
Definition: DebugInfoMetadata.h:711
llvm::DIEDelta
A simple label difference DIE.
Definition: DIE.h:256
llvm::DwarfUnit::applySubprogramAttributes
void applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie, bool SkipSPAttributes=false)
Definition: DwarfUnit.cpp:1234
llvm::BitTracker
Definition: BitTracker.h:35
llvm::DISubrange
Array subrange.
Definition: DebugInfoMetadata.h:298
llvm::DwarfUnit::addSectionDelta
void addSectionDelta(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Hi, const MCSymbol *Lo)
addSectionDelta - Add a label delta attribute data and value.
Definition: DwarfUnit.cpp:1786
llvm::DwarfUnit::addTemplateParams
void addTemplateParams(DIE &Buffer, DINodeArray TParams)
Add template parameters in buffer.
Definition: DwarfUnit.cpp:521
llvm::DICompositeType::getRuntimeLang
unsigned getRuntimeLang() const
Definition: DebugInfoMetadata.h:1204
llvm::DITemplateTypeParameter
Definition: DebugInfoMetadata.h:2436
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
Integer
So we should use XX3Form_Rcr to implement instrinsic Convert DP outs ins xscvdpsp No builtin are required Round &Convert QP DP(dword[1] is set to zero) No builtin are required Round to Quad Precision Integer
Definition: README_P9.txt:366
llvm::MCContext::getDwarfVersion
uint16_t getDwarfVersion() const
Definition: MCContext.h:793
llvm::DIBasicType::getEncoding
unsigned getEncoding() const
Definition: DebugInfoMetadata.h:825
llvm::DICompositeType::getDiscriminator
DIDerivedType * getDiscriminator() const
Definition: DebugInfoMetadata.h:1212
llvm::APInt::getZExtValue
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1467
llvm::ConstantFP
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:257
APFloat.h
This file declares a class to represent arbitrary precision floating point values and provide a varie...
llvm::DICompositeType::getTemplateParams
DITemplateParameterArray getTemplateParams() const
Definition: DebugInfoMetadata.h:1200
llvm::DIEInteger
An integer value DIE.
Definition: DIE.h:163
llvm::DwarfUnit::addLinkageName
void addLinkageName(DIE &Die, StringRef LinkageName)
Add a linkage name, if it isn't empty.
Definition: DwarfUnit.cpp:513
llvm::DIEBlock
DIEBlock - Represents a block of values.
Definition: DIE.h:966
llvm::AsmPrinter::emitDwarfSymbolReference
void emitDwarfSymbolReference(const MCSymbol *Label, bool ForceOffset=false) const
Emit a reference to a symbol for use in dwarf.
Definition: AsmPrinterDwarf.cpp:158
llvm::APFloat::bitcastToAPInt
APInt bitcastToAPInt() const
Definition: APFloat.h:1130
llvm::AsmPrinter::emitInt8
void emitInt8(int Value) const
Emit a byte directive and value.
Definition: AsmPrinter.cpp:2436
llvm::DIEValueList::takeValues
void takeValues(DIEValueList &Other)
Take ownership of the nodes in Other, and append them to the back of the list.
Definition: DIE.h:725
llvm::Metadata
Root of the metadata hierarchy.
Definition: Metadata.h:62
c
the resulting code requires compare and branches when and if the revised code is with conditional branches instead of More there is a byte word extend before each where there should be only and the condition codes are not remembered when the same two values are compared twice More LSR enhancements i8 and i32 load store addressing modes are identical int int c
Definition: README.txt:418
AddressPool.h
llvm::DwarfUnit::DIEValueAllocator
BumpPtrAllocator DIEValueAllocator
Definition: DwarfUnit.h:41
llvm::DIEString
A container for string pool string values.
Definition: DIE.h:273
llvm::None
const NoneType None
Definition: None.h:23
llvm::MCObjectFileInfo::getDwarfRnglistsSection
MCSection * getDwarfRnglistsSection() const
Definition: MCObjectFileInfo.h:287
X
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
llvm::DIEInlineString
A container for inline string values.
Definition: DIE.h:292
llvm::DebugHandlerBase::getBaseTypeSize
static uint64_t getBaseTypeSize(const DIType *Ty)
If this type is derived from a base type then return base type size.
Definition: DebugHandlerBase.cpp:148
llvm::DwarfUnit::getDIELoc
DIELoc * getDIELoc()
Returns a fresh newly allocated DIELoc.
Definition: DwarfUnit.h:130
llvm::MDNode::getOperand
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1137
llvm::DwarfUnit::addPoolOpAddress
void addPoolOpAddress(DIEValueList &Die, const MCSymbol *Label)
Definition: DwarfUnit.cpp:314
G
const DataFlowGraph & G
Definition: RDFGraph.cpp:202
llvm::DwarfDebug::useAddrOffsetExpressions
bool useAddrOffsetExpressions() const
Definition: DwarfDebug.h:718
llvm::DwarfDebug::getDwarfSectionOffsetForm
dwarf::Form getDwarfSectionOffsetForm() const
Returns a suitable DWARF form to represent a section offset, i.e.
Definition: DwarfDebug.cpp:3524
llvm::DIType::isTypePassByValue
bool isTypePassByValue() const
Definition: DebugInfoMetadata.h:745
llvm::DwarfUnit::getOrCreateModule
DIE * getOrCreateModule(const DIModule *M)
Definition: DwarfUnit.cpp:1118
llvm::DITemplateValueParameter::getValue
Metadata * getValue() const
Definition: DebugInfoMetadata.h:2520
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::StringRef::empty
constexpr LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:152
llvm::DICompositeType::getElements
DINodeArray getElements() const
Definition: DebugInfoMetadata.h:1194
Index
uint32_t Index
Definition: ELFObjHandler.cpp:83
llvm::dwarf::isType
bool isType(Tag T)
Definition: Dwarf.h:112
llvm::DINamespace::getName
StringRef getName() const
Definition: DebugInfoMetadata.h:2326
llvm::DwarfDebug
Collects and handles dwarf debug information.
Definition: DwarfDebug.h:296
uint64_t
llvm::APInt::getRawData
const uint64_t * getRawData() const
This function returns a pointer to the internal storage of the APInt.
Definition: APInt.h:533
D
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
llvm::DwarfCompileUnit::addGlobalNameForTypeUnit
void addGlobalNameForTypeUnit(StringRef Name, const DIScope *Context)
Add a new global name present in a type unit to this compile unit.
Definition: DwarfCompileUnit.cpp:1399
llvm::DIType::isTypePassByReference
bool isTypePassByReference() const
Definition: DebugInfoMetadata.h:746
llvm::ARM_MB::ST
@ ST
Definition: ARMBaseInfo.h:73
llvm::DIEDwarfExpression
DwarfExpression implementation for singular DW_AT_location.
Definition: DwarfExpression.h:406
llvm::DataLayout::isLittleEndian
bool isLittleEndian() const
Layout endianness...
Definition: DataLayout.h:244
llvm::DIGlobalVariable
Global variables.
Definition: DebugInfoMetadata.h:2957
llvm::TargetRegisterInfo::getFrameRegister
virtual Register getFrameRegister(const MachineFunction &MF) const =0
Debug information queries.
llvm::DwarfDebug::useSplitDwarf
bool useSplitDwarf() const
Returns whether or not to change the current debug info for the split dwarf proposal support.
Definition: DwarfDebug.h:750
llvm::DIType::getExportSymbols
bool getExportSymbols() const
Definition: DebugInfoMetadata.h:751
StringExtras.h
llvm::DwarfCompileUnit::getOrCreateSourceID
unsigned getOrCreateSourceID(const DIFile *File) override
Look up the source ID for the given file.
Definition: DwarfCompileUnit.cpp:120
llvm::DwarfUnit::addStringOffsetsStart
void addStringOffsetsStart()
Add the DW_AT_str_offsets_base attribute to the unit DIE.
Definition: DwarfUnit.cpp:1824
llvm::DICompileUnit
Compile unit.
Definition: DebugInfoMetadata.h:1337
llvm::DIEUnit::getSection
MCSection * getSection() const
Return the section that this DIEUnit will be emitted into.
Definition: DIE.h:916
llvm::DIELoc
DIELoc - Represents an expression location.
Definition: DIE.h:930
llvm::dwarf::DW_ACCESS_public
@ DW_ACCESS_public
Definition: Dwarf.h:176
llvm::dwarf::UnitType
UnitType
Constants for unit types in DWARF v5.
Definition: Dwarf.h:460
llvm::DINamespace::getExportSymbols
bool getExportSymbols() const
Definition: DebugInfoMetadata.h:2324
llvm::DIType::isVector
bool isVector() const
Definition: DebugInfoMetadata.h:740
llvm::DwarfUnit::Asm
AsmPrinter * Asm
Target of Dwarf emission.
Definition: DwarfUnit.h:44
llvm::mc::getDwarfVersion
int getDwarfVersion()
llvm::TargetMachine::Options
TargetOptions Options
Definition: TargetMachine.h:121
llvm::DINamespace::getScope
DIScope * getScope() const
Definition: DebugInfoMetadata.h:2325
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::AsmPrinter::getSymbol
MCSymbol * getSymbol(const GlobalValue *GV) const
Definition: AsmPrinter.cpp:494
llvm::DwarfUnit::MDNodeToDieMap
DenseMap< const MDNode *, DIE * > MDNodeToDieMap
Tracks the mapping of unit level debug information variables to debug information entries.
Definition: DwarfUnit.h:58
llvm::AsmPrinter::emitDwarfUnitLength
void emitDwarfUnitLength(uint64_t Length, const Twine &Comment) const
Emit a unit length field.
Definition: AsmPrinterDwarf.cpp:201
llvm::DwarfTypeUnit::getCU
DwarfCompileUnit & getCU() override
Definition: DwarfUnit.h:383
llvm::DICompileUnit::isDebugDirectivesOnly
bool isDebugDirectivesOnly() const
Definition: DebugInfoMetadata.h:1473
llvm::DICompositeType::getDataLocation
DIVariable * getDataLocation() const
Definition: DebugInfoMetadata.h:1216
llvm::AsmPrinter::MF
MachineFunction * MF
The current machine function.
Definition: AsmPrinter.h:100
llvm::AsmPrinter::OutContext
MCContext & OutContext
This is the context for the output file that we are streaming.
Definition: AsmPrinter.h:92
iterator_range.h
llvm::DIStringType::getStringLength
DIVariable * getStringLength() const
Definition: DebugInfoMetadata.h:898
llvm::DIEEntry
A pointer to another debug information entry.
Definition: DIE.h:314
llvm::DwarfUnit::DIELocs
std::vector< DIELoc * > DIELocs
A list of all the DIELocs in use.
Definition: DwarfUnit.h:64
llvm::MDNode
Metadata node.
Definition: Metadata.h:906
llvm::DwarfTypeUnit::emitHeader
void emitHeader(bool UseOffsets) override
Emit the header for this unit, not including the initial length field.
Definition: DwarfUnit.cpp:1775
llvm::DwarfUnit::constructSubprogramArguments
void constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args)
Construct function argument DIEs.
Definition: DwarfUnit.cpp:802
llvm::DwarfUnit::IndexTyDie
DIE * IndexTyDie
An anonymous type for index type. Owned by DIEUnit.
Definition: DwarfUnit.h:54
llvm::DIGenericSubrange::getCount
BoundType getCount() const
Definition: DebugInfoMetadata.cpp:464
llvm::AsmPrinter::emitDwarfLengthOrOffset
void emitDwarfLengthOrOffset(uint64_t Value) const
Emit 32- or 64-bit value depending on the DWARF format.
Definition: AsmPrinterDwarf.cpp:196
MCSection.h
llvm::DIBasicType
Basic type, like 'int' or 'float'.
Definition: DebugInfoMetadata.h:771
llvm::APInt
Class for arbitrary precision integers.
Definition: APInt.h:75
llvm::DINode::getTag
dwarf::Tag getTag() const
Definition: DebugInfoMetadata.h:160
llvm::DISubrange::getStride
BoundType getStride() const
Definition: DebugInfoMetadata.cpp:433
llvm::DISubroutineType::getCC
uint8_t getCC() const
Definition: DebugInfoMetadata.h:1323
llvm::DISubroutineType
Type array for a subprogram.
Definition: DebugInfoMetadata.h:1283
llvm::dwarf::SourceLanguage
SourceLanguage
Definition: Dwarf.h:200
llvm::DICompositeType
Composite types.
Definition: DebugInfoMetadata.h:1060
llvm::DIScope::getScope
DIScope * getScope() const
Definition: DebugInfoMetadata.cpp:238
llvm::DwarfUnit::getOrCreateTypeDIE
DIE * getOrCreateTypeDIE(const MDNode *TyNode)
Find existing DIE or create new DIE for the given type.
Definition: DwarfUnit.cpp:614
llvm::DwarfUnit::createAndAddDIE
DIE & createAndAddDIE(dwarf::Tag 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:389
None.h
MCAsmInfo.h
DataLayout.h
llvm::MCDwarfDwoLineTable
Definition: MCDwarf.h:314
llvm::dwarf::DW_ACCESS_private
@ DW_ACCESS_private
Definition: Dwarf.h:178
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
llvm::DIGenericSubrange::getStride
BoundType getStride() const
Definition: DebugInfoMetadata.cpp:515
llvm::DINode
Tagged DWARF-like metadata node.
Definition: DebugInfoMetadata.h:127
MachineLocation.h
llvm::DIEDwarfExpression::DIEDwarfExpression
DIEDwarfExpression(const AsmPrinter &AP, DwarfCompileUnit &CU, DIELoc &DIE)
Definition: DwarfUnit.cpp:48
llvm::DIVariable::getLine
unsigned getLine() const
Definition: DebugInfoMetadata.h:2540
TargetLoweringObjectFile.h
uint32_t
llvm::DIStringType::getEncoding
unsigned getEncoding() const
Definition: DebugInfoMetadata.h:906
TargetSubtargetInfo.h
Unsigned
@ Unsigned
Definition: NVPTXISelLowering.cpp:4645
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::DIE::get
static DIE * get(BumpPtrAllocator &Alloc, dwarf::Tag Tag)
Definition: DIE.h:769
llvm::MCAsmInfo::doesDwarfUseRelocationsAcrossSections
bool doesDwarfUseRelocationsAcrossSections() const
Definition: MCAsmInfo.h:784
llvm::DICompositeType::getAssociated
DIVariable * getAssociated() const
Definition: DebugInfoMetadata.h:1223
llvm::DwarfDebug::generateTypeUnits
bool generateTypeUnits() const
Returns whether to generate DWARF v4 type units.
Definition: DwarfDebug.h:737
llvm::pdb::PDB_SymType::Enum
@ Enum
DwarfCompileUnit.h
llvm::AsmPrinter::getISAEncoding
virtual unsigned getISAEncoding()
Get the value for DW_AT_APPLE_isa. Zero if no isa encoding specified.
Definition: AsmPrinter.h:671
llvm::DIVariable
Base class for variables.
Definition: DebugInfoMetadata.h:2528
llvm::TargetOptions::DebugStrictDwarf
unsigned DebugStrictDwarf
When set to true, don't use DWARF extensions in later DWARF versions.
Definition: TargetOptions.h:343
llvm::DwarfDebug::shareAcrossDWOCUs
bool shareAcrossDWOCUs() const
Definition: DwarfDebug.cpp:561
llvm::DIType::getRawName
MDString * getRawName() const
Definition: DebugInfoMetadata.h:714
llvm::DwarfUnit::addGlobalName
virtual void addGlobalName(StringRef Name, const DIE &Die, const DIScope *Context)=0
Add a new global name to the compile unit.
llvm::DILabel::getFile
DIFile * getFile() const
Definition: DebugInfoMetadata.h:3240
llvm::PointerUnion
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
Definition: PointerUnion.h:107
llvm::DwarfUnit::EndLabel
MCSymbol * EndLabel
Emitted at the end of the CU and used to compute the CU Length field.
Definition: DwarfUnit.h:47
llvm::DIType::isLittleEndian
bool isLittleEndian() const
Definition: DebugInfoMetadata.h:750
llvm::Register
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
llvm::DwarfDebug::enterNonTypeUnitContext
NonTypeUnitContext enterNonTypeUnitContext()
Definition: DwarfDebug.cpp:3462
llvm::DwarfDebug::getSectionLabel
const MCSymbol * getSectionLabel(const MCSection *S)
Definition: DwarfDebug.cpp:3533
llvm::DwarfFile::getStringPool
DwarfStringPool & getStringPool()
Returns the string pool.
Definition: DwarfFile.h:144
llvm::DIType::isForwardDecl
bool isForwardDecl() const
Definition: DebugInfoMetadata.h:732
llvm::DwarfUnit::getOrCreateNameSpace
DIE * getOrCreateNameSpace(const DINamespace *NS)
Definition: DwarfUnit.cpp:1097
llvm::DISubrange::getLowerBound
BoundType getLowerBound() const
Definition: DebugInfoMetadata.cpp:391
llvm::DwarfFile::getStringOffsetsStartSym
MCSymbol * getStringOffsetsStartSym() const
Definition: DwarfFile.h:146
llvm::DITypeRefArray::size
unsigned size() const
Definition: DebugInfoMetadata.h:82
llvm::DIType::getOffsetInBits
uint64_t getOffsetInBits() const
Definition: DebugInfoMetadata.h:707
llvm::DwarfUnit::DD
DwarfDebug * DD
Definition: DwarfUnit.h:50
llvm::DwarfDebug::useAppleExtensionAttributes
bool useAppleExtensionAttributes() const
Definition: DwarfDebug.h:744
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
llvm::DIE::getUnit
DIEUnit * getUnit() const
Climb up the parent chain to get the compile unit or type unit that this DIE belongs to.
Definition: DIE.cpp:214
llvm::DwarfUnit::addAttribute
void addAttribute(DIEValueList &Die, dwarf::Attribute Attribute, dwarf::Form Form, T &&Value)
Definition: DwarfUnit.h:79
llvm::DIScope
Base class for scope-like contexts.
Definition: DebugInfoMetadata.h:476
uint16_t
llvm::DIType::isBigEndian
bool isBigEndian() const
Definition: DebugInfoMetadata.h:749
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:325
llvm::DwarfUnit::addUInt
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:228
llvm::DwarfDebug::useInlineStrings
bool useInlineStrings() const
Returns whether to use inline strings.
Definition: DwarfDebug.h:705
llvm::DwarfUnit::addAccess
void addAccess(DIE &Die, DINode::DIFlags Flags)
Add the accessibility attribute.
Definition: DwarfUnit.cpp:539
Casting.h
llvm::DITemplateParameter::getName
StringRef getName() const
Definition: DebugInfoMetadata.h:2423
llvm::DwarfCompileUnit::addGlobalTypeUnitType
void addGlobalTypeUnitType(const DIType *Ty, const DIScope *Context)
Add a new global type present in a type unit to this compile unit.
Definition: DwarfCompileUnit.cpp:1420
llvm::DICompileUnit::getDebugInfoForProfiling
bool getDebugInfoForProfiling() const
Definition: DebugInfoMetadata.h:1476
DwarfUnit.h
llvm::MCDwarfDwoLineTable::getFile
unsigned getFile(StringRef Directory, StringRef FileName, Optional< MD5::MD5Result > Checksum, uint16_t DwarfVersion, Optional< StringRef > Source)
Definition: MCDwarf.h:327
llvm::DwarfUnit::~DwarfUnit
~DwarfUnit()
Definition: DwarfUnit.cpp:102
llvm::DwarfUnit::addBlock
void addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc)
Add block data.
Definition: DwarfUnit.cpp:396
llvm::DIELoc::BestForm
dwarf::Form BestForm(unsigned DwarfVersion) const
BestForm - Choose the best form for data.
Definition: DIE.h:944
llvm::AsmPrinter
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:82
llvm::AddressPool::getIndex
unsigned getIndex(const MCSymbol *Sym, bool TLS=false)
Returns the index into the address pool with the given label/symbol.
Definition: AddressPool.cpp:19
llvm::DIELoc::computeSize
unsigned computeSize(const dwarf::FormParams &FormParams) const
Calculate the size of the location expression.
Definition: DIE.cpp:717
llvm::DwarfFile
Definition: DwarfFile.h:49
llvm::dwarf::isCPlusPlus
bool isCPlusPlus(SourceLanguage S)
Definition: Dwarf.h:208
llvm::DwarfUnit::createTypeDIE
DIE * createTypeDIE(const DIScope *Context, DIE &ContextDIE, const DIType *Ty)
Creates type DIE with specific context.
Definition: DwarfUnit.cpp:581
llvm::DwarfTypeUnit::addGlobalType
void addGlobalType(const DIType *Ty, const DIE &Die, const DIScope *Context) override
Add a new global type to the compile unit.
Definition: DwarfUnit.cpp:1811
llvm::DIDerivedType
Derived types.
Definition: DebugInfoMetadata.h:919
llvm::MCObjectFileInfo::getDwarfAbbrevSection
MCSection * getDwarfAbbrevSection() const
Definition: MCObjectFileInfo.h:264
llvm::DwarfUnit::addGlobalType
virtual void addGlobalType(const DIType *Ty, const DIE &Die, const DIScope *Context)=0
Add a new global type to the compile unit.
llvm::DwarfTypeUnit::DwarfTypeUnit
DwarfTypeUnit(DwarfCompileUnit &CU, AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU, MCDwarfDwoLineTable *SplitLineTable=nullptr)
Definition: DwarfUnit.cpp:95
llvm::DIVariable::getFile
DIFile * getFile() const
Definition: DebugInfoMetadata.h:2543
llvm::DITemplateValueParameter
Definition: DebugInfoMetadata.h:2478
llvm::DIEInteger::BestForm
static dwarf::Form BestForm(bool IsSigned, uint64_t Int)
Choose the best form for integer.
Definition: DIE.h:170
llvm::DwarfFile::getRnglistsTableBaseSym
MCSymbol * getRnglistsTableBaseSym() const
Definition: DwarfFile.h:149
llvm::AsmPrinter::TM
TargetMachine & TM
Target machine description.
Definition: AsmPrinter.h:85
llvm::DwarfUnit::addLabel
void addLabel(DIEValueList &Die, dwarf::Attribute Attribute, dwarf::Form Form, const MCSymbol *Label)
Add a Dwarf label attribute data and value.
Definition: DwarfUnit.cpp:287
Version
uint64_t Version
Definition: RawMemProfReader.cpp:25
llvm::DINode::DIFlags
DIFlags
Debug info flags.
Definition: DebugInfoMetadata.h:166
llvm::DIGenericSubrange::getLowerBound
BoundType getLowerBound() const
Definition: DebugInfoMetadata.cpp:481
llvm::AsmPrinter::getObjFileLowering
const TargetLoweringObjectFile & getObjFileLowering() const
Return information about object file lowering.
Definition: AsmPrinter.cpp:223
N
#define N
MCStreamer.h
llvm::DICompositeType::getAllocated
DIVariable * getAllocated() const
Definition: DebugInfoMetadata.h:1230
llvm::DwarfDebug::addAccelType
void addAccelType(const DICompileUnit &CU, StringRef Name, const DIE &Die, char Flags)
Definition: DwarfDebug.cpp:3515
llvm::AsmPrinter::getDataLayout
const DataLayout & getDataLayout() const
Return information about data layout.
Definition: AsmPrinter.cpp:227
llvm::DwarfDebug::useDWARF2Bitfields
bool useDWARF2Bitfields() const
Returns whether to use the DWARF2 format for bitfields instyead of the DWARF4 format.
Definition: DwarfDebug.h:702
llvm::DwarfUnit::applySubprogramDefinitionAttributes
bool applySubprogramDefinitionAttributes(const DISubprogram *SP, DIE &SPDie, bool Minimal)
Definition: DwarfUnit.cpp:1181
llvm::DISubprogram
Subprogram description.
Definition: DebugInfoMetadata.h:1826
MachineOperand.h
llvm::DIModule
Represents a module in the programming language, for example, a Clang module, or a Fortran module.
Definition: DebugInfoMetadata.h:2338
llvm::HexStyle::Asm
@ Asm
0ffh
Definition: MCInstPrinter.h:34
llvm::DwarfDebug::getDwarfVersion
uint16_t getDwarfVersion() const
Returns the Dwarf Version.
Definition: DwarfDebug.cpp:3520
llvm::DILabel
Label.
Definition: DebugInfoMetadata.h:3194
llvm::DwarfUnit
This dwarf writer support class manages information associated with a source file.
Definition: DwarfUnit.h:35
llvm::DebugHandlerBase::isUnsignedDIType
static bool isUnsignedDIType(const DIType *Ty)
Return true if type encoding is unsigned.
Definition: DebugHandlerBase.cpp:177
llvm::AMDGPU::HSAMD::Kernel::Key::Args
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
Definition: AMDGPUMetadata.h:389
llvm::DICompositeType::getAllocatedExp
DIExpression * getAllocatedExp() const
Definition: DebugInfoMetadata.h:1233
llvm::DwarfUnit::ContainingTypeMap
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:69
llvm::DIType::isArtificial
bool isArtificial() const
Definition: DebugInfoMetadata.h:735
llvm::DIEValueList
A list of DIE values.
Definition: DIE.h:662
MachineFunction.h
llvm::MDString
A single uniqued string.
Definition: Metadata.h:611
llvm::DwarfTypeUnit::addGlobalName
void addGlobalName(StringRef Name, const DIE &Die, const DIScope *Context) override
Add a new global name to the compile unit.
Definition: DwarfUnit.cpp:1806
llvm::DwarfUnit::addConstantFPValue
void addConstantFPValue(DIE &Die, const ConstantFP *CFP)
Add constant value entry in variable DIE.
Definition: DwarfUnit.cpp:459
CU
Definition: AArch64AsmBackend.cpp:504
llvm::DIELabel
A label DIE.
Definition: DIE.h:218
llvm::DIType::isRValueReference
bool isRValueReference() const
Definition: DebugInfoMetadata.h:744
llvm::DwarfUnit::getLanguage
uint16_t getLanguage() const
Definition: DwarfUnit.h:98
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::AsmPrinter::emitInt16
void emitInt16(int Value) const
Emit a short directive and value.
Definition: AsmPrinter.cpp:2439
TargetRegisterInfo.h
File
Instrumentation for Order File
Definition: InstrOrderFile.cpp:205
llvm::DIEUnit::getUnitDie
DIE & getUnitDie()
Definition: DIE.h:919
llvm::DIObjCProperty::getLine
unsigned getLine() const
Definition: DebugInfoMetadata.h:3311
llvm::DICompositeType::getAssociatedExp
DIExpression * getAssociatedExp() const
Definition: DebugInfoMetadata.h:1226
llvm::DwarfUnit::getHeaderSize
virtual unsigned getHeaderSize() const
Compute the size of a header for this unit, not including the initial length field.
Definition: DwarfUnit.h:269
llvm::AsmPrinter::getDwarfFormParams
dwarf::FormParams getDwarfFormParams() const
Returns information about the byte size of DW_FORM values.
Definition: AsmPrinter.cpp:3657
llvm::sampleprof::Base
@ Base
Definition: Discriminator.h:58
llvm::DIScope::getFile
DIFile * getFile() const
Definition: DebugInfoMetadata.h:484
llvm::DIFile
File.
Definition: DebugInfoMetadata.h:530
llvm::DwarfUnit::DwarfUnit
DwarfUnit(dwarf::Tag, const DICompileUnit *Node, AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
Definition: DwarfUnit.cpp:90
llvm::DwarfUnit::addDIEEntry
void addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry)
Add a DIE attribute data and value.
Definition: DwarfUnit.cpp:360
llvm::DIGenericSubrange::getUpperBound
BoundType getUpperBound() const
Definition: DebugInfoMetadata.cpp:498