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);
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 (this includes subprogram
190  // declarations *and* subprogram definitions, even local definitions), the
191  // DIE must be shared across CUs.
192  // Combining type units and cross-CU DIE sharing is lower value (since
193  // cross-CU DIE sharing is used in LTO and removes type redundancy at that
194  // level already) but may be implementable for some value in projects
195  // building multiple independent libraries with LTO and then linking those
196  // together.
197  if (isDwoUnit() && !DD->shareAcrossDWOCUs())
198  return false;
199  return (isa<DIType>(D) || isa<DISubprogram>(D)) && !DD->generateTypeUnits();
200 }
201 
202 DIE *DwarfUnit::getDIE(const DINode *D) const {
203  if (isShareableAcrossCUs(D))
204  return DU->getDIE(D);
205  return MDNodeToDieMap.lookup(D);
206 }
207 
208 void DwarfUnit::insertDIE(const DINode *Desc, DIE *D) {
209  if (isShareableAcrossCUs(Desc)) {
210  DU->insertDIE(Desc, D);
211  return;
212  }
213  MDNodeToDieMap.insert(std::make_pair(Desc, D));
214 }
215 
217  MDNodeToDieMap.insert(std::make_pair(nullptr, D));
218 }
219 
221  if (DD->getDwarfVersion() >= 4)
222  addAttribute(Die, Attribute, dwarf::DW_FORM_flag_present, DIEInteger(1));
223  else
224  addAttribute(Die, Attribute, dwarf::DW_FORM_flag, DIEInteger(1));
225 }
226 
228  Optional<dwarf::Form> Form, uint64_t Integer) {
229  if (!Form)
231  assert(Form != dwarf::DW_FORM_implicit_const &&
232  "DW_FORM_implicit_const is used only for signed integers");
234 }
235 
237  uint64_t Integer) {
238  addUInt(Block, (dwarf::Attribute)0, Form, Integer);
239 }
240 
242  Optional<dwarf::Form> Form, int64_t Integer) {
243  if (!Form)
246 }
247 
249  int64_t Integer) {
251 }
252 
254  StringRef String) {
256  return;
257 
258  if (DD->useInlineStrings()) {
259  addAttribute(Die, Attribute, dwarf::DW_FORM_string,
260  new (DIEValueAllocator)
262  return;
263  }
264  dwarf::Form IxForm =
265  isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp;
266 
267  auto StringPoolEntry =
268  useSegmentedStringOffsetsTable() || IxForm == dwarf::DW_FORM_GNU_str_index
269  ? DU->getStringPool().getIndexedEntry(*Asm, String)
270  : DU->getStringPool().getEntry(*Asm, String);
271 
272  // For DWARF v5 and beyond, use the smallest strx? form possible.
274  IxForm = dwarf::DW_FORM_strx1;
275  unsigned Index = StringPoolEntry.getIndex();
276  if (Index > 0xffffff)
277  IxForm = dwarf::DW_FORM_strx4;
278  else if (Index > 0xffff)
279  IxForm = dwarf::DW_FORM_strx3;
280  else if (Index > 0xff)
281  IxForm = dwarf::DW_FORM_strx2;
282  }
283  addAttribute(Die, Attribute, IxForm, DIEString(StringPoolEntry));
284 }
285 
287  dwarf::Form Form, const MCSymbol *Label) {
288  addAttribute(Die, Attribute, Form, DIELabel(Label));
289 }
290 
292  addLabel(Die, (dwarf::Attribute)0, Form, Label);
293 }
294 
296  uint64_t Integer) {
298 }
299 
300 unsigned DwarfTypeUnit::getOrCreateSourceID(const DIFile *File) {
301  if (!SplitLineTable)
302  return getCU().getOrCreateSourceID(File);
303  if (!UsedLineTable) {
304  UsedLineTable = true;
305  // This is a split type unit that needs a line table.
306  addSectionOffset(getUnitDie(), dwarf::DW_AT_stmt_list, 0);
307  }
308  return SplitLineTable->getFile(
309  File->getDirectory(), File->getFilename(), DD->getMD5AsBytes(File),
310  Asm->OutContext.getDwarfVersion(), File->getSource());
311 }
312 
314  bool UseAddrOffsetFormOrExpressions =
316 
317  const MCSymbol *Base = nullptr;
318  if (Label->isInSection() && UseAddrOffsetFormOrExpressions)
319  Base = DD->getSectionLabel(&Label->getSection());
320 
321  uint32_t Index = DD->getAddressPool().getIndex(Base ? Base : Label);
322 
323  if (DD->getDwarfVersion() >= 5) {
324  addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addrx);
325  addUInt(Die, dwarf::DW_FORM_addrx, Index);
326  } else {
327  addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
328  addUInt(Die, dwarf::DW_FORM_GNU_addr_index, Index);
329  }
330 
331  if (Base && Base != Label) {
332  addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_const4u);
333  addLabelDelta(Die, (dwarf::Attribute)0, Label, Base);
334  addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
335  }
336 }
337 
338 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
339  if (DD->getDwarfVersion() >= 5) {
340  addPoolOpAddress(Die, Sym);
341  return;
342  }
343 
344  if (DD->useSplitDwarf()) {
345  addPoolOpAddress(Die, Sym);
346  return;
347  }
348 
349  addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
350  addLabel(Die, dwarf::DW_FORM_addr, Sym);
351 }
352 
354  const MCSymbol *Hi, const MCSymbol *Lo) {
355  addAttribute(Die, Attribute, dwarf::DW_FORM_data4,
356  new (DIEValueAllocator) DIEDelta(Hi, Lo));
357 }
358 
360  addDIEEntry(Die, Attribute, DIEEntry(Entry));
361 }
362 
363 void DwarfUnit::addDIETypeSignature(DIE &Die, uint64_t Signature) {
364  // Flag the type unit reference as a declaration so that if it contains
365  // members (implicit special members, static data member definitions, member
366  // declarations for definitions in this CU, etc) consumers don't get confused
367  // and think this is a full definition.
368  addFlag(Die, dwarf::DW_AT_declaration);
369 
370  addAttribute(Die, dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
371  DIEInteger(Signature));
372 }
373 
375  DIEEntry Entry) {
376  const DIEUnit *CU = Die.getUnit();
377  const DIEUnit *EntryCU = Entry.getEntry().getUnit();
378  if (!CU)
379  // We assume that Die belongs to this CU, if it is not linked to any CU yet.
380  CU = getUnitDie().getUnit();
381  if (!EntryCU)
382  EntryCU = getUnitDie().getUnit();
383  addAttribute(Die, Attribute,
384  EntryCU == CU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
385  Entry);
386 }
387 
389  DIE &Die = Parent.addChild(DIE::get(DIEValueAllocator, Tag));
390  if (N)
391  insertDIE(N, &Die);
392  return Die;
393 }
394 
396  Loc->ComputeSize(Asm);
397  DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
398  addAttribute(Die, Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
399 }
400 
402  DIEBlock *Block) {
403  Block->ComputeSize(Asm);
404  DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
405  addAttribute(Die, Attribute, Form, Block);
406 }
407 
409  DIEBlock *Block) {
410  addBlock(Die, Attribute, Block->BestForm(), Block);
411 }
412 
413 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, const DIFile *File) {
414  if (Line == 0)
415  return;
416 
417  unsigned FileID = getOrCreateSourceID(File);
418  addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
419  addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
420 }
421 
423  assert(V);
424 
425  addSourceLine(Die, V->getLine(), V->getFile());
426 }
427 
429  assert(G);
430 
431  addSourceLine(Die, G->getLine(), G->getFile());
432 }
433 
435  assert(SP);
436 
437  addSourceLine(Die, SP->getLine(), SP->getFile());
438 }
439 
440 void DwarfUnit::addSourceLine(DIE &Die, const DILabel *L) {
441  assert(L);
442 
443  addSourceLine(Die, L->getLine(), L->getFile());
444 }
445 
446 void DwarfUnit::addSourceLine(DIE &Die, const DIType *Ty) {
447  assert(Ty);
448 
449  addSourceLine(Die, Ty->getLine(), Ty->getFile());
450 }
451 
453  assert(Ty);
454 
455  addSourceLine(Die, Ty->getLine(), Ty->getFile());
456 }
457 
459  // Pass this down to addConstantValue as an unsigned bag of bits.
460  addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
461 }
462 
464  const DIType *Ty) {
465  addConstantValue(Die, CI->getValue(), Ty);
466 }
467 
468 void DwarfUnit::addConstantValue(DIE &Die, uint64_t Val, const DIType *Ty) {
469  addConstantValue(Die, DD->isUnsignedDIType(Ty), Val);
470 }
471 
472 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
473  // FIXME: This is a bit conservative/simple - it emits negative values always
474  // sign extended to 64 bits rather than minimizing the number of bytes.
475  addUInt(Die, dwarf::DW_AT_const_value,
476  Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
477 }
478 
479 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty) {
480  addConstantValue(Die, Val, DD->isUnsignedDIType(Ty));
481 }
482 
483 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
484  unsigned CIBitWidth = Val.getBitWidth();
485  if (CIBitWidth <= 64) {
487  Unsigned ? Val.getZExtValue() : Val.getSExtValue());
488  return;
489  }
490 
491  DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
492 
493  // Get the raw data form of the large APInt.
494  const uint64_t *Ptr64 = Val.getRawData();
495 
496  int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
497  bool LittleEndian = Asm->getDataLayout().isLittleEndian();
498 
499  // Output the constant to DWARF one byte at a time.
500  for (int i = 0; i < NumBytes; i++) {
501  uint8_t c;
502  if (LittleEndian)
503  c = Ptr64[i / 8] >> (8 * (i & 7));
504  else
505  c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
506  addUInt(*Block, dwarf::DW_FORM_data1, c);
507  }
508 
509  addBlock(Die, dwarf::DW_AT_const_value, Block);
510 }
511 
512 void DwarfUnit::addLinkageName(DIE &Die, StringRef LinkageName) {
513  if (!LinkageName.empty())
514  addString(Die,
515  DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
516  : dwarf::DW_AT_MIPS_linkage_name,
518 }
519 
520 void DwarfUnit::addTemplateParams(DIE &Buffer, DINodeArray TParams) {
521  // Add template parameters.
522  for (const auto *Element : TParams) {
523  if (auto *TTP = dyn_cast<DITemplateTypeParameter>(Element))
524  constructTemplateTypeParameterDIE(Buffer, TTP);
525  else if (auto *TVP = dyn_cast<DITemplateValueParameter>(Element))
526  constructTemplateValueParameterDIE(Buffer, TVP);
527  }
528 }
529 
530 /// Add thrown types.
531 void DwarfUnit::addThrownTypes(DIE &Die, DINodeArray ThrownTypes) {
532  for (const auto *Ty : ThrownTypes) {
533  DIE &TT = createAndAddDIE(dwarf::DW_TAG_thrown_type, Die);
534  addType(TT, cast<DIType>(Ty));
535  }
536 }
537 
539  if (!Context || isa<DIFile>(Context))
540  return &getUnitDie();
541  if (auto *T = dyn_cast<DIType>(Context))
542  return getOrCreateTypeDIE(T);
543  if (auto *NS = dyn_cast<DINamespace>(Context))
544  return getOrCreateNameSpace(NS);
545  if (auto *SP = dyn_cast<DISubprogram>(Context))
546  return getOrCreateSubprogramDIE(SP);
547  if (auto *M = dyn_cast<DIModule>(Context))
548  return getOrCreateModule(M);
549  return getDIE(Context);
550 }
551 
553  auto *Context = Ty->getScope();
554  DIE *ContextDIE = getOrCreateContextDIE(Context);
555 
556  if (DIE *TyDIE = getDIE(Ty))
557  return TyDIE;
558 
559  // Create new type.
560  DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
561 
562  constructTypeDIE(TyDIE, cast<DICompositeType>(Ty));
563 
564  updateAcceleratorTables(Context, Ty, TyDIE);
565  return &TyDIE;
566 }
567 
569  const DIType *Ty) {
570  // Create new type.
571  DIE &TyDIE = createAndAddDIE(Ty->getTag(), ContextDIE, Ty);
572 
573  updateAcceleratorTables(Context, Ty, TyDIE);
574 
575  if (auto *BT = dyn_cast<DIBasicType>(Ty))
576  constructTypeDIE(TyDIE, BT);
577  else if (auto *ST = dyn_cast<DIStringType>(Ty))
578  constructTypeDIE(TyDIE, ST);
579  else if (auto *STy = dyn_cast<DISubroutineType>(Ty))
580  constructTypeDIE(TyDIE, STy);
581  else if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
582  if (DD->generateTypeUnits() && !Ty->isForwardDecl() &&
583  (Ty->getRawName() || CTy->getRawIdentifier())) {
584  // Skip updating the accelerator tables since this is not the full type.
585  if (MDString *TypeId = CTy->getRawIdentifier())
586  DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
587  else {
588  auto X = DD->enterNonTypeUnitContext();
589  finishNonUnitTypeDIE(TyDIE, CTy);
590  }
591  return &TyDIE;
592  }
593  constructTypeDIE(TyDIE, CTy);
594  } else {
595  constructTypeDIE(TyDIE, cast<DIDerivedType>(Ty));
596  }
597 
598  return &TyDIE;
599 }
600 
602  if (!TyNode)
603  return nullptr;
604 
605  auto *Ty = cast<DIType>(TyNode);
606 
607  // DW_TAG_restrict_type is not supported in DWARF2
608  if (Ty->getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
609  return getOrCreateTypeDIE(cast<DIDerivedType>(Ty)->getBaseType());
610 
611  // DW_TAG_atomic_type is not supported in DWARF < 5
612  if (Ty->getTag() == dwarf::DW_TAG_atomic_type && DD->getDwarfVersion() < 5)
613  return getOrCreateTypeDIE(cast<DIDerivedType>(Ty)->getBaseType());
614 
615  // Construct the context before querying for the existence of the DIE in case
616  // such construction creates the DIE.
617  auto *Context = Ty->getScope();
618  DIE *ContextDIE = getOrCreateContextDIE(Context);
619  assert(ContextDIE);
620 
621  if (DIE *TyDIE = getDIE(Ty))
622  return TyDIE;
623 
624  return static_cast<DwarfUnit *>(ContextDIE->getUnit())
625  ->createTypeDIE(Context, *ContextDIE, Ty);
626 }
627 
628 void DwarfUnit::updateAcceleratorTables(const DIScope *Context,
629  const DIType *Ty, const DIE &TyDIE) {
630  if (!Ty->getName().empty() && !Ty->isForwardDecl()) {
631  bool IsImplementation = false;
632  if (auto *CT = dyn_cast<DICompositeType>(Ty)) {
633  // A runtime language of 0 actually means C/C++ and that any
634  // non-negative value is some version of Objective-C/C++.
635  IsImplementation = CT->getRuntimeLang() == 0 || CT->isObjcClassComplete();
636  }
637  unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
638  DD->addAccelType(*CUNode, Ty->getName(), TyDIE, Flags);
639 
640  if (!Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
641  isa<DINamespace>(Context) || isa<DICommonBlock>(Context))
642  addGlobalType(Ty, TyDIE, Context);
643  }
644 }
645 
646 void DwarfUnit::addType(DIE &Entity, const DIType *Ty,
648  assert(Ty && "Trying to add a type that doesn't exist?");
650 }
651 
653  if (!Context)
654  return "";
655 
656  // FIXME: Decide whether to implement this for non-C++ languages.
658  return "";
659 
660  std::string CS;
662  while (!isa<DICompileUnit>(Context)) {
663  Parents.push_back(Context);
664  if (const DIScope *S = Context->getScope())
665  Context = S;
666  else
667  // Structure, etc types will have a NULL context if they're at the top
668  // level.
669  break;
670  }
671 
672  // Reverse iterate over our list to go from the outermost construct to the
673  // innermost.
674  for (const DIScope *Ctx : make_range(Parents.rbegin(), Parents.rend())) {
675  StringRef Name = Ctx->getName();
676  if (Name.empty() && isa<DINamespace>(Ctx))
677  Name = "(anonymous namespace)";
678  if (!Name.empty()) {
679  CS += Name;
680  CS += "::";
681  }
682  }
683  return CS;
684 }
685 
686 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
687  // Get core information.
688  StringRef Name = BTy->getName();
689  // Add name if not anonymous or intermediate type.
690  if (!Name.empty())
691  addString(Buffer, dwarf::DW_AT_name, Name);
692 
693  // An unspecified type only has a name attribute.
694  if (BTy->getTag() == dwarf::DW_TAG_unspecified_type)
695  return;
696 
697  if (BTy->getTag() != dwarf::DW_TAG_string_type)
698  addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
699  BTy->getEncoding());
700 
701  uint64_t Size = BTy->getSizeInBits() >> 3;
702  addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
703 
704  if (BTy->isBigEndian())
705  addUInt(Buffer, dwarf::DW_AT_endianity, None, dwarf::DW_END_big);
706  else if (BTy->isLittleEndian())
707  addUInt(Buffer, dwarf::DW_AT_endianity, None, dwarf::DW_END_little);
708 }
709 
710 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIStringType *STy) {
711  // Get core information.
712  StringRef Name = STy->getName();
713  // Add name if not anonymous or intermediate type.
714  if (!Name.empty())
715  addString(Buffer, dwarf::DW_AT_name, Name);
716 
717  if (DIVariable *Var = STy->getStringLength()) {
718  if (auto *VarDIE = getDIE(Var))
719  addDIEEntry(Buffer, dwarf::DW_AT_string_length, *VarDIE);
720  } else if (DIExpression *Expr = STy->getStringLengthExp()) {
721  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
722  DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
723  // This is to describe the memory location of the
724  // length of a Fortran deferred length string, so
725  // lock it down as such.
726  DwarfExpr.setMemoryLocationKind();
727  DwarfExpr.addExpression(Expr);
728  addBlock(Buffer, dwarf::DW_AT_string_length, DwarfExpr.finalize());
729  } else {
730  uint64_t Size = STy->getSizeInBits() >> 3;
731  addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
732  }
733 
734  if (STy->getEncoding()) {
735  // For eventual Unicode support.
736  addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
737  STy->getEncoding());
738  }
739 }
740 
741 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy) {
742  // Get core information.
743  StringRef Name = DTy->getName();
744  uint64_t Size = DTy->getSizeInBits() >> 3;
745  uint16_t Tag = Buffer.getTag();
746 
747  // Map to main type, void will not have a type.
748  const DIType *FromTy = DTy->getBaseType();
749  if (FromTy)
750  addType(Buffer, FromTy);
751 
752  // Add name if not anonymous or intermediate type.
753  if (!Name.empty())
754  addString(Buffer, dwarf::DW_AT_name, Name);
755 
756  // If alignment is specified for a typedef , create and insert DW_AT_alignment
757  // attribute in DW_TAG_typedef DIE.
758  if (Tag == dwarf::DW_TAG_typedef && DD->getDwarfVersion() >= 5) {
759  uint32_t AlignInBytes = DTy->getAlignInBytes();
760  if (AlignInBytes > 0)
761  addUInt(Buffer, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
762  AlignInBytes);
763  }
764 
765  // Add size if non-zero (derived types might be zero-sized.)
766  if (Size && Tag != dwarf::DW_TAG_pointer_type
767  && Tag != dwarf::DW_TAG_ptr_to_member_type
768  && Tag != dwarf::DW_TAG_reference_type
769  && Tag != dwarf::DW_TAG_rvalue_reference_type)
770  addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
771 
772  if (Tag == dwarf::DW_TAG_ptr_to_member_type)
773  addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
774  *getOrCreateTypeDIE(cast<DIDerivedType>(DTy)->getClassType()));
775  // Add source line info if available and TyDesc is not a forward declaration.
776  if (!DTy->isForwardDecl())
777  addSourceLine(Buffer, DTy);
778 
779  // If DWARF address space value is other than None, add it. The IR
780  // verifier checks that DWARF address space only exists for pointer
781  // or reference types.
782  if (DTy->getDWARFAddressSpace())
783  addUInt(Buffer, dwarf::DW_AT_address_class, dwarf::DW_FORM_data4,
784  DTy->getDWARFAddressSpace().getValue());
785 }
786 
788  for (unsigned i = 1, N = Args.size(); i < N; ++i) {
789  const DIType *Ty = Args[i];
790  if (!Ty) {
791  assert(i == N-1 && "Unspecified parameter must be the last argument");
792  createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
793  } else {
794  DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
795  addType(Arg, Ty);
796  if (Ty->isArtificial())
797  addFlag(Arg, dwarf::DW_AT_artificial);
798  }
799  }
800 }
801 
802 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DISubroutineType *CTy) {
803  // Add return type. A void return won't have a type.
804  auto Elements = cast<DISubroutineType>(CTy)->getTypeArray();
805  if (Elements.size())
806  if (auto RTy = Elements[0])
807  addType(Buffer, RTy);
808 
809  bool isPrototyped = true;
810  if (Elements.size() == 2 && !Elements[1])
811  isPrototyped = false;
812 
813  constructSubprogramArguments(Buffer, Elements);
814 
815  // Add prototype flag if we're dealing with a C language and the function has
816  // been prototyped.
818  if (isPrototyped &&
819  (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
820  Language == dwarf::DW_LANG_ObjC))
821  addFlag(Buffer, dwarf::DW_AT_prototyped);
822 
823  // Add a DW_AT_calling_convention if this has an explicit convention.
824  if (CTy->getCC() && CTy->getCC() != dwarf::DW_CC_normal)
825  addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
826  CTy->getCC());
827 
828  if (CTy->isLValueReference())
829  addFlag(Buffer, dwarf::DW_AT_reference);
830 
831  if (CTy->isRValueReference())
832  addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
833 }
834 
836  // Add name if not anonymous or intermediate type.
837  StringRef Name = CTy->getName();
838 
839  uint64_t Size = CTy->getSizeInBits() >> 3;
840  uint16_t Tag = Buffer.getTag();
841 
842  switch (Tag) {
843  case dwarf::DW_TAG_array_type:
844  constructArrayTypeDIE(Buffer, CTy);
845  break;
846  case dwarf::DW_TAG_enumeration_type:
847  constructEnumTypeDIE(Buffer, CTy);
848  break;
849  case dwarf::DW_TAG_variant_part:
850  case dwarf::DW_TAG_structure_type:
851  case dwarf::DW_TAG_union_type:
852  case dwarf::DW_TAG_class_type: {
853  // Emit the discriminator for a variant part.
854  DIDerivedType *Discriminator = nullptr;
855  if (Tag == dwarf::DW_TAG_variant_part) {
856  Discriminator = CTy->getDiscriminator();
857  if (Discriminator) {
858  // DWARF says:
859  // If the variant part has a discriminant, the discriminant is
860  // represented by a separate debugging information entry which is
861  // a child of the variant part entry.
862  DIE &DiscMember = constructMemberDIE(Buffer, Discriminator);
863  addDIEEntry(Buffer, dwarf::DW_AT_discr, DiscMember);
864  }
865  }
866 
867  // Add template parameters to a class, structure or union types.
868  if (Tag == dwarf::DW_TAG_class_type ||
869  Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
870  addTemplateParams(Buffer, CTy->getTemplateParams());
871 
872  // Add elements to structure type.
873  DINodeArray Elements = CTy->getElements();
874  for (const auto *Element : Elements) {
875  if (!Element)
876  continue;
877  if (auto *SP = dyn_cast<DISubprogram>(Element))
879  else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
880  if (DDTy->getTag() == dwarf::DW_TAG_friend) {
881  DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
882  addType(ElemDie, DDTy->getBaseType(), dwarf::DW_AT_friend);
883  } else if (DDTy->isStaticMember()) {
885  } else if (Tag == dwarf::DW_TAG_variant_part) {
886  // When emitting a variant part, wrap each member in
887  // DW_TAG_variant.
888  DIE &Variant = createAndAddDIE(dwarf::DW_TAG_variant, Buffer);
889  if (const ConstantInt *CI =
890  dyn_cast_or_null<ConstantInt>(DDTy->getDiscriminantValue())) {
891  if (DD->isUnsignedDIType(Discriminator->getBaseType()))
892  addUInt(Variant, dwarf::DW_AT_discr_value, None, CI->getZExtValue());
893  else
894  addSInt(Variant, dwarf::DW_AT_discr_value, None, CI->getSExtValue());
895  }
896  constructMemberDIE(Variant, DDTy);
897  } else {
898  constructMemberDIE(Buffer, DDTy);
899  }
900  } else if (auto *Property = dyn_cast<DIObjCProperty>(Element)) {
901  DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer);
902  StringRef PropertyName = Property->getName();
903  addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
904  if (Property->getType())
905  addType(ElemDie, Property->getType());
906  addSourceLine(ElemDie, Property);
907  StringRef GetterName = Property->getGetterName();
908  if (!GetterName.empty())
909  addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
910  StringRef SetterName = Property->getSetterName();
911  if (!SetterName.empty())
912  addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
913  if (unsigned PropertyAttributes = Property->getAttributes())
914  addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
915  PropertyAttributes);
916  } else if (auto *Composite = dyn_cast<DICompositeType>(Element)) {
917  if (Composite->getTag() == dwarf::DW_TAG_variant_part) {
918  DIE &VariantPart = createAndAddDIE(Composite->getTag(), Buffer);
919  constructTypeDIE(VariantPart, Composite);
920  }
921  }
922  }
923 
924  if (CTy->isAppleBlockExtension())
925  addFlag(Buffer, dwarf::DW_AT_APPLE_block);
926 
927  if (CTy->getExportSymbols())
928  addFlag(Buffer, dwarf::DW_AT_export_symbols);
929 
930  // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
931  // inside C++ composite types to point to the base class with the vtable.
932  // Rust uses DW_AT_containing_type to link a vtable to the type
933  // for which it was created.
934  if (auto *ContainingType = CTy->getVTableHolder())
935  addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
936  *getOrCreateTypeDIE(ContainingType));
937 
938  if (CTy->isObjcClassComplete())
939  addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
940 
941  // Add the type's non-standard calling convention.
942  // DW_CC_pass_by_value/DW_CC_pass_by_reference are introduced in DWARF 5.
943  if (!Asm->TM.Options.DebugStrictDwarf || DD->getDwarfVersion() >= 5) {
944  uint8_t CC = 0;
945  if (CTy->isTypePassByValue())
946  CC = dwarf::DW_CC_pass_by_value;
947  else if (CTy->isTypePassByReference())
948  CC = dwarf::DW_CC_pass_by_reference;
949  if (CC)
950  addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
951  CC);
952  }
953  break;
954  }
955  default:
956  break;
957  }
958 
959  // Add name if not anonymous or intermediate type.
960  if (!Name.empty())
961  addString(Buffer, dwarf::DW_AT_name, Name);
962 
963  if (Tag == dwarf::DW_TAG_enumeration_type ||
964  Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
965  Tag == dwarf::DW_TAG_union_type) {
966  // Add size if non-zero (derived types might be zero-sized.)
967  // Ignore the size if it's a non-enum forward decl.
968  // TODO: Do we care about size for enum forward declarations?
969  if (Size &&
970  (!CTy->isForwardDecl() || Tag == dwarf::DW_TAG_enumeration_type))
971  addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
972  else if (!CTy->isForwardDecl())
973  // Add zero size if it is not a forward declaration.
974  addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
975 
976  // If we're a forward decl, say so.
977  if (CTy->isForwardDecl())
978  addFlag(Buffer, dwarf::DW_AT_declaration);
979 
980  // Add source line info if available.
981  if (!CTy->isForwardDecl())
982  addSourceLine(Buffer, CTy);
983 
984  // No harm in adding the runtime language to the declaration.
985  unsigned RLang = CTy->getRuntimeLang();
986  if (RLang)
987  addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
988  RLang);
989 
990  // Add align info if available.
991  if (uint32_t AlignInBytes = CTy->getAlignInBytes())
992  addUInt(Buffer, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
993  AlignInBytes);
994  }
995 }
996 
997 void DwarfUnit::constructTemplateTypeParameterDIE(
998  DIE &Buffer, const DITemplateTypeParameter *TP) {
999  DIE &ParamDIE =
1000  createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1001  // Add the type if it exists, it could be void and therefore no type.
1002  if (TP->getType())
1003  addType(ParamDIE, TP->getType());
1004  if (!TP->getName().empty())
1005  addString(ParamDIE, dwarf::DW_AT_name, TP->getName());
1006  if (TP->isDefault() && (DD->getDwarfVersion() >= 5))
1007  addFlag(ParamDIE, dwarf::DW_AT_default_value);
1008 }
1009 
1010 void DwarfUnit::constructTemplateValueParameterDIE(
1011  DIE &Buffer, const DITemplateValueParameter *VP) {
1012  DIE &ParamDIE = createAndAddDIE(VP->getTag(), Buffer);
1013 
1014  // Add the type if there is one, template template and template parameter
1015  // packs will not have a type.
1016  if (VP->getTag() == dwarf::DW_TAG_template_value_parameter)
1017  addType(ParamDIE, VP->getType());
1018  if (!VP->getName().empty())
1019  addString(ParamDIE, dwarf::DW_AT_name, VP->getName());
1020  if (VP->isDefault() && (DD->getDwarfVersion() >= 5))
1021  addFlag(ParamDIE, dwarf::DW_AT_default_value);
1022  if (Metadata *Val = VP->getValue()) {
1023  if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1024  addConstantValue(ParamDIE, CI, VP->getType());
1025  else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1026  // We cannot describe the location of dllimport'd entities: the
1027  // computation of their address requires loads from the IAT.
1028  if (!GV->hasDLLImportStorageClass()) {
1029  // For declaration non-type template parameters (such as global values
1030  // and functions)
1031  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1032  addOpAddress(*Loc, Asm->getSymbol(GV));
1033  // Emit DW_OP_stack_value to use the address as the immediate value of
1034  // the parameter, rather than a pointer to it.
1035  addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1036  addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1037  }
1038  } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1039  assert(isa<MDString>(Val));
1040  addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1041  cast<MDString>(Val)->getString());
1042  } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1043  addTemplateParams(ParamDIE, cast<MDTuple>(Val));
1044  }
1045  }
1046 }
1047 
1049  // Construct the context before querying for the existence of the DIE in case
1050  // such construction creates the DIE.
1051  DIE *ContextDIE = getOrCreateContextDIE(NS->getScope());
1052 
1053  if (DIE *NDie = getDIE(NS))
1054  return NDie;
1055  DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1056 
1057  StringRef Name = NS->getName();
1058  if (!Name.empty())
1059  addString(NDie, dwarf::DW_AT_name, NS->getName());
1060  else
1061  Name = "(anonymous namespace)";
1062  DD->addAccelNamespace(*CUNode, Name, NDie);
1063  addGlobalName(Name, NDie, NS->getScope());
1064  if (NS->getExportSymbols())
1065  addFlag(NDie, dwarf::DW_AT_export_symbols);
1066  return &NDie;
1067 }
1068 
1070  // Construct the context before querying for the existence of the DIE in case
1071  // such construction creates the DIE.
1072  DIE *ContextDIE = getOrCreateContextDIE(M->getScope());
1073 
1074  if (DIE *MDie = getDIE(M))
1075  return MDie;
1076  DIE &MDie = createAndAddDIE(dwarf::DW_TAG_module, *ContextDIE, M);
1077 
1078  if (!M->getName().empty()) {
1079  addString(MDie, dwarf::DW_AT_name, M->getName());
1080  addGlobalName(M->getName(), MDie, M->getScope());
1081  }
1082  if (!M->getConfigurationMacros().empty())
1083  addString(MDie, dwarf::DW_AT_LLVM_config_macros,
1084  M->getConfigurationMacros());
1085  if (!M->getIncludePath().empty())
1086  addString(MDie, dwarf::DW_AT_LLVM_include_path, M->getIncludePath());
1087  if (!M->getAPINotesFile().empty())
1088  addString(MDie, dwarf::DW_AT_LLVM_apinotes, M->getAPINotesFile());
1089  if (M->getFile())
1090  addUInt(MDie, dwarf::DW_AT_decl_file, None,
1091  getOrCreateSourceID(M->getFile()));
1092  if (M->getLineNo())
1093  addUInt(MDie, dwarf::DW_AT_decl_line, None, M->getLineNo());
1094  if (M->getIsDecl())
1095  addFlag(MDie, dwarf::DW_AT_declaration);
1096 
1097  return &MDie;
1098 }
1099 
1101  // Construct the context before querying for the existence of the DIE in case
1102  // such construction creates the DIE (as is the case for member function
1103  // declarations).
1104  DIE *ContextDIE =
1105  Minimal ? &getUnitDie() : getOrCreateContextDIE(SP->getScope());
1106 
1107  if (DIE *SPDie = getDIE(SP))
1108  return SPDie;
1109 
1110  if (auto *SPDecl = SP->getDeclaration()) {
1111  if (!Minimal) {
1112  // Add subprogram definitions to the CU die directly.
1113  ContextDIE = &getUnitDie();
1114  // Build the decl now to ensure it precedes the definition.
1115  getOrCreateSubprogramDIE(SPDecl);
1116  }
1117  }
1118 
1119  // DW_TAG_inlined_subroutine may refer to this DIE.
1120  DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1121 
1122  // Stop here and fill this in later, depending on whether or not this
1123  // subprogram turns out to have inlined instances or not.
1124  if (SP->isDefinition())
1125  return &SPDie;
1126 
1127  static_cast<DwarfUnit *>(SPDie.getUnit())
1128  ->applySubprogramAttributes(SP, SPDie);
1129  return &SPDie;
1130 }
1131 
1133  DIE &SPDie, bool Minimal) {
1134  DIE *DeclDie = nullptr;
1135  StringRef DeclLinkageName;
1136  if (auto *SPDecl = SP->getDeclaration()) {
1137  if (!Minimal) {
1138  DITypeRefArray DeclArgs, DefinitionArgs;
1139  DeclArgs = SPDecl->getType()->getTypeArray();
1140  DefinitionArgs = SP->getType()->getTypeArray();
1141 
1142  if (DeclArgs.size() && DefinitionArgs.size())
1143  if (DefinitionArgs[0] != NULL && DeclArgs[0] != DefinitionArgs[0])
1144  addType(SPDie, DefinitionArgs[0]);
1145 
1146  DeclDie = getDIE(SPDecl);
1147  assert(DeclDie && "This DIE should've already been constructed when the "
1148  "definition DIE was created in "
1149  "getOrCreateSubprogramDIE");
1150  // Look at the Decl's linkage name only if we emitted it.
1151  if (DD->useAllLinkageNames())
1152  DeclLinkageName = SPDecl->getLinkageName();
1153  unsigned DeclID = getOrCreateSourceID(SPDecl->getFile());
1154  unsigned DefID = getOrCreateSourceID(SP->getFile());
1155  if (DeclID != DefID)
1156  addUInt(SPDie, dwarf::DW_AT_decl_file, None, DefID);
1157 
1158  if (SP->getLine() != SPDecl->getLine())
1159  addUInt(SPDie, dwarf::DW_AT_decl_line, None, SP->getLine());
1160  }
1161  }
1162 
1163  // Add function template parameters.
1164  addTemplateParams(SPDie, SP->getTemplateParams());
1165 
1166  // Add the linkage name if we have one and it isn't in the Decl.
1167  StringRef LinkageName = SP->getLinkageName();
1168  assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1169  LinkageName == DeclLinkageName) &&
1170  "decl has a linkage name and it is different");
1171  if (DeclLinkageName.empty() &&
1172  // Always emit it for abstract subprograms.
1173  (DD->useAllLinkageNames() || DU->getAbstractSPDies().lookup(SP)))
1174  addLinkageName(SPDie, LinkageName);
1175 
1176  if (!DeclDie)
1177  return false;
1178 
1179  // Refer to the function declaration where all the other attributes will be
1180  // found.
1181  addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1182  return true;
1183 }
1184 
1186  bool SkipSPAttributes) {
1187  // If -fdebug-info-for-profiling is enabled, need to emit the subprogram
1188  // and its source location.
1189  bool SkipSPSourceLocation = SkipSPAttributes &&
1191  if (!SkipSPSourceLocation)
1192  if (applySubprogramDefinitionAttributes(SP, SPDie, SkipSPAttributes))
1193  return;
1194 
1195  // Constructors and operators for anonymous aggregates do not have names.
1196  if (!SP->getName().empty())
1197  addString(SPDie, dwarf::DW_AT_name, SP->getName());
1198 
1199  if (!SkipSPSourceLocation)
1200  addSourceLine(SPDie, SP);
1201 
1202  // Skip the rest of the attributes under -gmlt to save space.
1203  if (SkipSPAttributes)
1204  return;
1205 
1206  // Add the prototype if we have a prototype and we have a C like
1207  // language.
1209  if (SP->isPrototyped() &&
1210  (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1211  Language == dwarf::DW_LANG_ObjC))
1212  addFlag(SPDie, dwarf::DW_AT_prototyped);
1213 
1214  if (SP->isObjCDirect())
1215  addFlag(SPDie, dwarf::DW_AT_APPLE_objc_direct);
1216 
1217  unsigned CC = 0;
1219  if (const DISubroutineType *SPTy = SP->getType()) {
1220  Args = SPTy->getTypeArray();
1221  CC = SPTy->getCC();
1222  }
1223 
1224  // Add a DW_AT_calling_convention if this has an explicit convention.
1225  if (CC && CC != dwarf::DW_CC_normal)
1226  addUInt(SPDie, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1, CC);
1227 
1228  // Add a return type. If this is a type like a C/C++ void type we don't add a
1229  // return type.
1230  if (Args.size())
1231  if (auto Ty = Args[0])
1232  addType(SPDie, Ty);
1233 
1234  unsigned VK = SP->getVirtuality();
1235  if (VK) {
1236  addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1237  if (SP->getVirtualIndex() != -1u) {
1238  DIELoc *Block = getDIELoc();
1239  addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1240  addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex());
1241  addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1242  }
1243  ContainingTypeMap.insert(std::make_pair(&SPDie, SP->getContainingType()));
1244  }
1245 
1246  if (!SP->isDefinition()) {
1247  addFlag(SPDie, dwarf::DW_AT_declaration);
1248 
1249  // Add arguments. Do not add arguments for subprogram definition. They will
1250  // be handled while processing variables.
1252  }
1253 
1254  addThrownTypes(SPDie, SP->getThrownTypes());
1255 
1256  if (SP->isArtificial())
1257  addFlag(SPDie, dwarf::DW_AT_artificial);
1258 
1259  if (!SP->isLocalToUnit())
1260  addFlag(SPDie, dwarf::DW_AT_external);
1261 
1263  if (SP->isOptimized())
1264  addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1265 
1266  if (unsigned isa = Asm->getISAEncoding())
1267  addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1268  }
1269 
1270  if (SP->isLValueReference())
1271  addFlag(SPDie, dwarf::DW_AT_reference);
1272 
1273  if (SP->isRValueReference())
1274  addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1275 
1276  if (SP->isNoReturn())
1277  addFlag(SPDie, dwarf::DW_AT_noreturn);
1278 
1279  if (SP->isProtected())
1280  addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1282  else if (SP->isPrivate())
1283  addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1285  else if (SP->isPublic())
1286  addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1288 
1289  if (SP->isExplicit())
1290  addFlag(SPDie, dwarf::DW_AT_explicit);
1291 
1292  if (SP->isMainSubprogram())
1293  addFlag(SPDie, dwarf::DW_AT_main_subprogram);
1294  if (SP->isPure())
1295  addFlag(SPDie, dwarf::DW_AT_pure);
1296  if (SP->isElemental())
1297  addFlag(SPDie, dwarf::DW_AT_elemental);
1298  if (SP->isRecursive())
1299  addFlag(SPDie, dwarf::DW_AT_recursive);
1300 
1301  if (DD->getDwarfVersion() >= 5 && SP->isDeleted())
1302  addFlag(SPDie, dwarf::DW_AT_deleted);
1303 }
1304 
1305 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
1306  DIE *IndexTy) {
1307  DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1308  addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1309 
1310  // The LowerBound value defines the lower bounds which is typically zero for
1311  // C/C++. The Count value is the number of elements. Values are 64 bit. If
1312  // Count == -1 then the array is unbounded and we do not emit
1313  // DW_AT_lower_bound and DW_AT_count attributes.
1314  int64_t DefaultLowerBound = getDefaultLowerBound();
1315 
1316  auto AddBoundTypeEntry = [&](dwarf::Attribute Attr,
1317  DISubrange::BoundType Bound) -> void {
1318  if (auto *BV = Bound.dyn_cast<DIVariable *>()) {
1319  if (auto *VarDIE = getDIE(BV))
1320  addDIEEntry(DW_Subrange, Attr, *VarDIE);
1321  } else if (auto *BE = Bound.dyn_cast<DIExpression *>()) {
1322  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1323  DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
1324  DwarfExpr.setMemoryLocationKind();
1325  DwarfExpr.addExpression(BE);
1326  addBlock(DW_Subrange, Attr, DwarfExpr.finalize());
1327  } else if (auto *BI = Bound.dyn_cast<ConstantInt *>()) {
1328  if (Attr == dwarf::DW_AT_count) {
1329  if (BI->getSExtValue() != -1)
1330  addUInt(DW_Subrange, Attr, None, BI->getSExtValue());
1331  } else if (Attr != dwarf::DW_AT_lower_bound || DefaultLowerBound == -1 ||
1332  BI->getSExtValue() != DefaultLowerBound)
1333  addSInt(DW_Subrange, Attr, dwarf::DW_FORM_sdata, BI->getSExtValue());
1334  }
1335  };
1336 
1337  AddBoundTypeEntry(dwarf::DW_AT_lower_bound, SR->getLowerBound());
1338 
1339  AddBoundTypeEntry(dwarf::DW_AT_count, SR->getCount());
1340 
1341  AddBoundTypeEntry(dwarf::DW_AT_upper_bound, SR->getUpperBound());
1342 
1343  AddBoundTypeEntry(dwarf::DW_AT_byte_stride, SR->getStride());
1344 }
1345 
1346 void DwarfUnit::constructGenericSubrangeDIE(DIE &Buffer,
1347  const DIGenericSubrange *GSR,
1348  DIE *IndexTy) {
1349  DIE &DwGenericSubrange =
1350  createAndAddDIE(dwarf::DW_TAG_generic_subrange, Buffer);
1351  addDIEEntry(DwGenericSubrange, dwarf::DW_AT_type, *IndexTy);
1352 
1353  int64_t DefaultLowerBound = getDefaultLowerBound();
1354 
1355  auto AddBoundTypeEntry = [&](dwarf::Attribute Attr,
1356  DIGenericSubrange::BoundType Bound) -> void {
1357  if (auto *BV = Bound.dyn_cast<DIVariable *>()) {
1358  if (auto *VarDIE = getDIE(BV))
1359  addDIEEntry(DwGenericSubrange, Attr, *VarDIE);
1360  } else if (auto *BE = Bound.dyn_cast<DIExpression *>()) {
1361  if (BE->isConstant() &&
1362  DIExpression::SignedOrUnsignedConstant::SignedConstant ==
1363  *BE->isConstant()) {
1364  if (Attr != dwarf::DW_AT_lower_bound || DefaultLowerBound == -1 ||
1365  static_cast<int64_t>(BE->getElement(1)) != DefaultLowerBound)
1366  addSInt(DwGenericSubrange, Attr, dwarf::DW_FORM_sdata,
1367  BE->getElement(1));
1368  } else {
1369  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1370  DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
1371  DwarfExpr.setMemoryLocationKind();
1372  DwarfExpr.addExpression(BE);
1373  addBlock(DwGenericSubrange, Attr, DwarfExpr.finalize());
1374  }
1375  }
1376  };
1377 
1378  AddBoundTypeEntry(dwarf::DW_AT_lower_bound, GSR->getLowerBound());
1379  AddBoundTypeEntry(dwarf::DW_AT_count, GSR->getCount());
1380  AddBoundTypeEntry(dwarf::DW_AT_upper_bound, GSR->getUpperBound());
1381  AddBoundTypeEntry(dwarf::DW_AT_byte_stride, GSR->getStride());
1382 }
1383 
1384 DIE *DwarfUnit::getIndexTyDie() {
1385  if (IndexTyDie)
1386  return IndexTyDie;
1387  // Construct an integer type to use for indexes.
1388  IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, getUnitDie());
1389  StringRef Name = "__ARRAY_SIZE_TYPE__";
1390  addString(*IndexTyDie, dwarf::DW_AT_name, Name);
1391  addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1392  addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1393  dwarf::DW_ATE_unsigned);
1394  DD->addAccelType(*CUNode, Name, *IndexTyDie, /*Flags*/ 0);
1395  return IndexTyDie;
1396 }
1397 
1398 /// Returns true if the vector's size differs from the sum of sizes of elements
1399 /// the user specified. This can occur if the vector has been rounded up to
1400 /// fit memory alignment constraints.
1401 static bool hasVectorBeenPadded(const DICompositeType *CTy) {
1402  assert(CTy && CTy->isVector() && "Composite type is not a vector");
1403  const uint64_t ActualSize = CTy->getSizeInBits();
1404 
1405  // Obtain the size of each element in the vector.
1406  DIType *BaseTy = CTy->getBaseType();
1407  assert(BaseTy && "Unknown vector element type.");
1408  const uint64_t ElementSize = BaseTy->getSizeInBits();
1409 
1410  // Locate the number of elements in the vector.
1411  const DINodeArray Elements = CTy->getElements();
1412  assert(Elements.size() == 1 &&
1413  Elements[0]->getTag() == dwarf::DW_TAG_subrange_type &&
1414  "Invalid vector element array, expected one element of type subrange");
1415  const auto Subrange = cast<DISubrange>(Elements[0]);
1416  const auto NumVecElements =
1417  Subrange->getCount()
1418  ? Subrange->getCount().get<ConstantInt *>()->getSExtValue()
1419  : 0;
1420 
1421  // Ensure we found the element count and that the actual size is wide
1422  // enough to contain the requested size.
1423  assert(ActualSize >= (NumVecElements * ElementSize) && "Invalid vector size");
1424  return ActualSize != (NumVecElements * ElementSize);
1425 }
1426 
1427 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1428  if (CTy->isVector()) {
1429  addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1430  if (hasVectorBeenPadded(CTy))
1431  addUInt(Buffer, dwarf::DW_AT_byte_size, None,
1432  CTy->getSizeInBits() / CHAR_BIT);
1433  }
1434 
1435  if (DIVariable *Var = CTy->getDataLocation()) {
1436  if (auto *VarDIE = getDIE(Var))
1437  addDIEEntry(Buffer, dwarf::DW_AT_data_location, *VarDIE);
1438  } else if (DIExpression *Expr = CTy->getDataLocationExp()) {
1439  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1440  DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
1441  DwarfExpr.setMemoryLocationKind();
1442  DwarfExpr.addExpression(Expr);
1443  addBlock(Buffer, dwarf::DW_AT_data_location, DwarfExpr.finalize());
1444  }
1445 
1446  if (DIVariable *Var = CTy->getAssociated()) {
1447  if (auto *VarDIE = getDIE(Var))
1448  addDIEEntry(Buffer, dwarf::DW_AT_associated, *VarDIE);
1449  } else if (DIExpression *Expr = CTy->getAssociatedExp()) {
1450  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1451  DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
1452  DwarfExpr.setMemoryLocationKind();
1453  DwarfExpr.addExpression(Expr);
1454  addBlock(Buffer, dwarf::DW_AT_associated, DwarfExpr.finalize());
1455  }
1456 
1457  if (DIVariable *Var = CTy->getAllocated()) {
1458  if (auto *VarDIE = getDIE(Var))
1459  addDIEEntry(Buffer, dwarf::DW_AT_allocated, *VarDIE);
1460  } else if (DIExpression *Expr = CTy->getAllocatedExp()) {
1461  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1462  DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
1463  DwarfExpr.setMemoryLocationKind();
1464  DwarfExpr.addExpression(Expr);
1465  addBlock(Buffer, dwarf::DW_AT_allocated, DwarfExpr.finalize());
1466  }
1467 
1468  if (auto *RankConst = CTy->getRankConst()) {
1469  addSInt(Buffer, dwarf::DW_AT_rank, dwarf::DW_FORM_sdata,
1470  RankConst->getSExtValue());
1471  } else if (auto *RankExpr = CTy->getRankExp()) {
1472  DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1473  DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
1474  DwarfExpr.setMemoryLocationKind();
1475  DwarfExpr.addExpression(RankExpr);
1476  addBlock(Buffer, dwarf::DW_AT_rank, DwarfExpr.finalize());
1477  }
1478 
1479  // Emit the element type.
1480  addType(Buffer, CTy->getBaseType());
1481 
1482  // Get an anonymous type for index type.
1483  // FIXME: This type should be passed down from the front end
1484  // as different languages may have different sizes for indexes.
1485  DIE *IdxTy = getIndexTyDie();
1486 
1487  // Add subranges to array type.
1488  DINodeArray Elements = CTy->getElements();
1489  for (DINode *E : Elements) {
1490  // FIXME: Should this really be such a loose cast?
1491  if (auto *Element = dyn_cast_or_null<DINode>(E)) {
1492  if (Element->getTag() == dwarf::DW_TAG_subrange_type)
1493  constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
1494  else if (Element->getTag() == dwarf::DW_TAG_generic_subrange)
1495  constructGenericSubrangeDIE(Buffer, cast<DIGenericSubrange>(Element),
1496  IdxTy);
1497  }
1498  }
1499 }
1500 
1501 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1502  const DIType *DTy = CTy->getBaseType();
1503  bool IsUnsigned = DTy && DD->isUnsignedDIType(DTy);
1504  if (DTy) {
1505  if (DD->getDwarfVersion() >= 3)
1506  addType(Buffer, DTy);
1507  if (DD->getDwarfVersion() >= 4 && (CTy->getFlags() & DINode::FlagEnumClass))
1508  addFlag(Buffer, dwarf::DW_AT_enum_class);
1509  }
1510 
1511  auto *Context = CTy->getScope();
1512  bool IndexEnumerators = !Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
1513  isa<DINamespace>(Context) || isa<DICommonBlock>(Context);
1514  DINodeArray Elements = CTy->getElements();
1515 
1516  // Add enumerators to enumeration type.
1517  for (const DINode *E : Elements) {
1518  auto *Enum = dyn_cast_or_null<DIEnumerator>(E);
1519  if (Enum) {
1520  DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1521  StringRef Name = Enum->getName();
1522  addString(Enumerator, dwarf::DW_AT_name, Name);
1523  addConstantValue(Enumerator, Enum->getValue(), IsUnsigned);
1524  if (IndexEnumerators)
1525  addGlobalName(Name, Enumerator, Context);
1526  }
1527  }
1528 }
1529 
1531  for (auto &P : ContainingTypeMap) {
1532  DIE &SPDie = *P.first;
1533  const DINode *D = P.second;
1534  if (!D)
1535  continue;
1536  DIE *NDie = getDIE(D);
1537  if (!NDie)
1538  continue;
1539  addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1540  }
1541 }
1542 
1543 DIE &DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
1544  DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer);
1545  StringRef Name = DT->getName();
1546  if (!Name.empty())
1547  addString(MemberDie, dwarf::DW_AT_name, Name);
1548 
1549  if (DIType *Resolved = DT->getBaseType())
1550  addType(MemberDie, Resolved);
1551 
1552  addSourceLine(MemberDie, DT);
1553 
1554  if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
1555 
1556  // For C++, virtual base classes are not at fixed offset. Use following
1557  // expression to extract appropriate offset from vtable.
1558  // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1559 
1560  DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc;
1561  addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1562  addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1563  addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1564  addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits());
1565  addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1566  addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1567  addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1568 
1569  addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1570  } else {
1571  uint64_t Size = DT->getSizeInBits();
1572  uint64_t FieldSize = DD->getBaseTypeSize(DT);
1573  uint32_t AlignInBytes = DT->getAlignInBytes();
1574  uint64_t OffsetInBytes;
1575 
1576  bool IsBitfield = FieldSize && Size != FieldSize;
1577  if (IsBitfield) {
1578  // Handle bitfield, assume bytes are 8 bits.
1579  if (DD->useDWARF2Bitfields())
1580  addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1581  addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1582 
1583  uint64_t Offset = DT->getOffsetInBits();
1584  // We can't use DT->getAlignInBits() here: AlignInBits for member type
1585  // is non-zero if and only if alignment was forced (e.g. _Alignas()),
1586  // which can't be done with bitfields. Thus we use FieldSize here.
1587  uint32_t AlignInBits = FieldSize;
1588  uint32_t AlignMask = ~(AlignInBits - 1);
1589  // The bits from the start of the storage unit to the start of the field.
1590  uint64_t StartBitOffset = Offset - (Offset & AlignMask);
1591  // The byte offset of the field's aligned storage unit inside the struct.
1592  OffsetInBytes = (Offset - StartBitOffset) / 8;
1593 
1594  if (DD->useDWARF2Bitfields()) {
1595  uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1596  uint64_t FieldOffset = (HiMark - FieldSize);
1597  Offset -= FieldOffset;
1598 
1599  // Maybe we need to work from the other end.
1600  if (Asm->getDataLayout().isLittleEndian())
1601  Offset = FieldSize - (Offset + Size);
1602 
1603  addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1604  OffsetInBytes = FieldOffset >> 3;
1605  } else {
1606  addUInt(MemberDie, dwarf::DW_AT_data_bit_offset, None, Offset);
1607  }
1608  } else {
1609  // This is not a bitfield.
1610  OffsetInBytes = DT->getOffsetInBits() / 8;
1611  if (AlignInBytes)
1612  addUInt(MemberDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1613  AlignInBytes);
1614  }
1615 
1616  if (DD->getDwarfVersion() <= 2) {
1617  DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc;
1618  addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1619  addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1620  addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1621  } else if (!IsBitfield || DD->useDWARF2Bitfields()) {
1622  // In DWARF v3, DW_FORM_data4/8 in DW_AT_data_member_location are
1623  // interpreted as location-list pointers. Interpreting constants as
1624  // pointers is not expected, so we use DW_FORM_udata to encode the
1625  // constants here.
1626  if (DD->getDwarfVersion() == 3)
1627  addUInt(MemberDie, dwarf::DW_AT_data_member_location,
1628  dwarf::DW_FORM_udata, OffsetInBytes);
1629  else
1630  addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1631  OffsetInBytes);
1632  }
1633  }
1634 
1635  if (DT->isProtected())
1636  addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1638  else if (DT->isPrivate())
1639  addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1641  // Otherwise C++ member and base classes are considered public.
1642  else if (DT->isPublic())
1643  addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1645  if (DT->isVirtual())
1646  addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1647  dwarf::DW_VIRTUALITY_virtual);
1648 
1649  // Objective-C properties.
1650  if (DINode *PNode = DT->getObjCProperty())
1651  if (DIE *PDie = getDIE(PNode))
1652  addAttribute(MemberDie, dwarf::DW_AT_APPLE_property,
1653  dwarf::DW_FORM_ref4, DIEEntry(*PDie));
1654 
1655  if (DT->isArtificial())
1656  addFlag(MemberDie, dwarf::DW_AT_artificial);
1657 
1658  return MemberDie;
1659 }
1660 
1662  if (!DT)
1663  return nullptr;
1664 
1665  // Construct the context before querying for the existence of the DIE in case
1666  // such construction creates the DIE.
1667  DIE *ContextDIE = getOrCreateContextDIE(DT->getScope());
1668  assert(dwarf::isType(ContextDIE->getTag()) &&
1669  "Static member should belong to a type.");
1670 
1671  if (DIE *StaticMemberDIE = getDIE(DT))
1672  return StaticMemberDIE;
1673 
1674  DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT);
1675 
1676  const DIType *Ty = DT->getBaseType();
1677 
1678  addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName());
1679  addType(StaticMemberDIE, Ty);
1680  addSourceLine(StaticMemberDIE, DT);
1681  addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1682  addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1683 
1684  // FIXME: We could omit private if the parent is a class_type, and
1685  // public if the parent is something else.
1686  if (DT->isProtected())
1687  addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1689  else if (DT->isPrivate())
1690  addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1692  else if (DT->isPublic())
1693  addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1695 
1696  if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant()))
1697  addConstantValue(StaticMemberDIE, CI, Ty);
1698  if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant()))
1699  addConstantFPValue(StaticMemberDIE, CFP);
1700 
1701  if (uint32_t AlignInBytes = DT->getAlignInBytes())
1702  addUInt(StaticMemberDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1703  AlignInBytes);
1704 
1705  return &StaticMemberDIE;
1706 }
1707 
1709  // Emit size of content not including length itself
1710  if (!DD->useSectionsAsReferences())
1712  isDwoUnit() ? "debug_info_dwo" : "debug_info", "Length of Unit");
1713  else
1715  "Length of Unit");
1716 
1717  Asm->OutStreamer->AddComment("DWARF version number");
1718  unsigned Version = DD->getDwarfVersion();
1719  Asm->emitInt16(Version);
1720 
1721  // DWARF v5 reorders the address size and adds a unit type.
1722  if (Version >= 5) {
1723  Asm->OutStreamer->AddComment("DWARF Unit Type");
1724  Asm->emitInt8(UT);
1725  Asm->OutStreamer->AddComment("Address Size (in bytes)");
1727  }
1728 
1729  // We share one abbreviations table across all units so it's always at the
1730  // start of the section. Use a relocatable offset where needed to ensure
1731  // linking doesn't invalidate that offset.
1732  Asm->OutStreamer->AddComment("Offset Into Abbrev. Section");
1734  if (UseOffsets)
1736  else
1738  TLOF.getDwarfAbbrevSection()->getBeginSymbol(), false);
1739 
1740  if (Version <= 4) {
1741  Asm->OutStreamer->AddComment("Address Size (in bytes)");
1743  }
1744 }
1745 
1746 void DwarfTypeUnit::emitHeader(bool UseOffsets) {
1747  DwarfUnit::emitCommonHeader(UseOffsets,
1748  DD->useSplitDwarf() ? dwarf::DW_UT_split_type
1749  : dwarf::DW_UT_type);
1750  Asm->OutStreamer->AddComment("Type Signature");
1751  Asm->OutStreamer->emitIntValue(TypeSignature, sizeof(TypeSignature));
1752  Asm->OutStreamer->AddComment("Type DIE Offset");
1753  // In a skeleton type unit there is no type DIE so emit a zero offset.
1754  Asm->emitDwarfLengthOrOffset(Ty ? Ty->getOffset() : 0);
1755 }
1756 
1758  const MCSymbol *Hi, const MCSymbol *Lo) {
1761 }
1762 
1764  const MCSymbol *Label, const MCSymbol *Sec) {
1767  else
1768  addSectionDelta(Die, Attribute, Label, Sec);
1769 }
1770 
1771 bool DwarfTypeUnit::isDwoUnit() const {
1772  // Since there are no skeleton type units, all type units are dwo type units
1773  // when split DWARF is being used.
1774  return DD->useSplitDwarf();
1775 }
1776 
1778  const DIScope *Context) {
1780 }
1781 
1782 void DwarfTypeUnit::addGlobalType(const DIType *Ty, const DIE &Die,
1783  const DIScope *Context) {
1785 }
1786 
1787 const MCSymbol *DwarfUnit::getCrossSectionRelativeBaseAddress() const {
1789  return nullptr;
1790  if (isDwoUnit())
1791  return nullptr;
1792  return getSection()->getBeginSymbol();
1793 }
1794 
1797  addSectionLabel(getUnitDie(), dwarf::DW_AT_str_offsets_base,
1800 }
1801 
1803  assert(DD->getDwarfVersion() >= 5 &&
1804  "DW_AT_rnglists_base requires DWARF version 5 or later");
1806  addSectionLabel(getUnitDie(), dwarf::DW_AT_rnglists_base,
1809 }
1810 
1811 void DwarfTypeUnit::finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) {
1812  addFlag(D, dwarf::DW_AT_declaration);
1813  StringRef Name = CTy->getName();
1814  if (!Name.empty())
1815  addString(D, dwarf::DW_AT_name, Name);
1816  getCU().createTypeDIE(CTy);
1817 }
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
llvm::DIType::getScope
DIScope * getScope() const
Definition: DebugInfoMetadata.h:707
llvm::DwarfUnit::getOrCreateStaticMemberDIE
DIE * getOrCreateStaticMemberDIE(const DIDerivedType *DT)
Create new static data member DIE.
Definition: DwarfUnit.cpp:1661
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:413
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:1227
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:262
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:3179
llvm::DICompositeType::getVTableHolder
DIType * getVTableHolder() const
Definition: DebugInfoMetadata.h:1184
llvm::DIObjCProperty::getFile
DIFile * getFile() const
Definition: DebugInfoMetadata.h:3255
llvm::DICompositeType::getBaseType
DIType * getBaseType() const
Definition: DebugInfoMetadata.h:1180
llvm::DwarfUnit::addRnglistsBase
void addRnglistsBase()
Add the DW_AT_rnglists_base attribute to the unit DIE.
Definition: DwarfUnit.cpp:1802
MCDwarf.h
llvm::DwarfUnit::addThrownTypes
void addThrownTypes(DIE &Die, DINodeArray ThrownTypes)
Add thrown types.
Definition: DwarfUnit.cpp:531
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::DIType
Base class for types.
Definition: DebugInfoMetadata.h:662
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::StringRef::empty
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:153
llvm::make_range
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
Definition: iterator_range.h:53
llvm::DwarfDebug::getAddressPool
AddressPool & getAddressPool()
Definition: DwarfDebug.h:800
llvm::DwarfUnit::addFlag
void addFlag(DIE &Die, dwarf::Attribute Attribute)
Add a flag that is true to the DIE.
Definition: DwarfUnit.cpp:220
Metadata.h
llvm::DIType::getSizeInBits
uint64_t getSizeInBits() const
Definition: DebugInfoMetadata.h:701
llvm::GlobalValue::dropLLVMManglingEscape
static StringRef dropLLVMManglingEscape(StringRef Name)
If the given string begins with the GlobalValue name mangling escape character '\1',...
Definition: GlobalValue.h:482
llvm::DIGenericSubrange
Definition: DebugInfoMetadata.h:362
llvm::dwarf::DW_ACCESS_protected
@ DW_ACCESS_protected
Definition: Dwarf.h:177
llvm::DIType::isProtected
bool isProtected() const
Definition: DebugInfoMetadata.h:724
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:538
llvm::DwarfUnit::emitCommonHeader
void emitCommonHeader(bool UseOffsets, dwarf::UnitType UT)
Emit the common part of the header for this unit.
Definition: DwarfUnit.cpp:1708
llvm::DwarfCompileUnit
Definition: DwarfCompileUnit.h:47
llvm::DwarfFile::getAbstractSPDies
DenseMap< const MDNode *, DIE * > & getAbstractSPDies()
Definition: DwarfFile.h:165
llvm::DwarfUnit::DU
DwarfFile * DU
Definition: DwarfUnit.h:53
llvm::DIType::isAppleBlockExtension
bool isAppleBlockExtension() const
Definition: DebugInfoMetadata.h:731
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:872
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:1168
llvm::DIStringType
String type, Fortran CHARACTER(n)
Definition: DebugInfoMetadata.h:837
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:353
llvm::APInt::getSExtValue
int64_t getSExtValue() const
Get sign extended value.
Definition: APInt.h:1643
llvm::DITemplateParameter::isDefault
bool isDefault() const
Definition: DebugInfoMetadata.h:2389
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:208
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:338
llvm::DwarfUnit::getDIE
DIE * getDIE(const DINode *D) const
Returns the DIE map slot for the specified debug variable.
Definition: DwarfUnit.cpp:202
llvm::DIScope::getName
StringRef getName() const
Definition: DebugInfoMetadata.cpp:261
llvm::DwarfUnit::getOrCreateSubprogramDIE
DIE * getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal=false)
Definition: DwarfUnit.cpp:1100
llvm::DICompositeType::getRankConst
ConstantInt * getRankConst() const
Definition: DebugInfoMetadata.h:1222
APInt.h
llvm::TargetRegisterInfo
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
Definition: TargetRegisterInfo.h:231
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:646
llvm::DwarfUnit::getCU
virtual DwarfCompileUnit & getCU()=0
llvm::DISubrange::getUpperBound
BoundType getUpperBound() const
Definition: DebugInfoMetadata.cpp:411
llvm::DIType::isVirtual
bool isVirtual() const
Definition: DebugInfoMetadata.h:732
llvm::APInt::getBitWidth
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1581
llvm::DwarfUnit::addString
void addString(DIE &Die, dwarf::Attribute Attribute, StringRef Str)
Add a string attribute data and value.
Definition: DwarfUnit.cpp:253
llvm::DIType::isPrivate
bool isPrivate() const
Definition: DebugInfoMetadata.h:721
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:363
llvm::DICompositeType::getDataLocationExp
DIExpression * getDataLocationExp() const
Definition: DebugInfoMetadata.h:1204
llvm::ConstantFP::getValueAPF
const APFloat & getValueAPF() const
Definition: Constants.h:297
llvm::DIStringType::getStringLengthExp
DIExpression * getStringLengthExp() const
Definition: DebugInfoMetadata.h:900
llvm::MCAsmInfo::getCodePointerSize
unsigned getCodePointerSize() const
Get the code pointer size in bytes.
Definition: MCAsmInfo.h:536
llvm::Optional
Definition: APInt.h:33
T
#define T
Definition: Mips16ISelLowering.cpp:341
llvm::DIType::getAlignInBytes
uint32_t getAlignInBytes() const
Definition: DebugInfoMetadata.h:703
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:241
llvm::MCObjectFileInfo::getDwarfStrOffSection
MCSection * getDwarfStrOffSection() const
Definition: MCObjectFileInfo.h:311
llvm::DIExpression
DWARF expression.
Definition: DebugInfoMetadata.h:2557
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::DwarfUnit::constructTypeDIE
void constructTypeDIE(DIE &Buffer, const DICompositeType *CTy)
Definition: DwarfUnit.cpp:835
llvm::DwarfDebug::useSectionsAsReferences
bool useSectionsAsReferences() const
Returns whether to use sections as labels rather than temp symbols.
Definition: DwarfDebug.h:728
TRI
unsigned const TargetRegisterInfo * TRI
Definition: MachineSink.cpp:1567
llvm::DINamespace
Definition: DebugInfoMetadata.h:2247
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:3356
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:741
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
llvm::MipsISD::Hi
@ Hi
Definition: MipsISelLowering.h:75
llvm::TargetLoweringObjectFile
Definition: TargetLoweringObjectFile.h:43
Context
LLVMContext & Context
Definition: NVVMIntrRange.cpp:66
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:206
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:1401
llvm::DIE::addChild
DIE & addChild(DIE *Child)
Add a child to the DIE.
Definition: DIE.h:846
llvm::DwarfDebug::addAccelNamespace
void addAccelNamespace(const DICompileUnit &CU, StringRef Name, const DIE &Die)
Definition: DwarfDebug.cpp:3502
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:3201
llvm::DIType::getFlags
DIFlags getFlags() const
Definition: DebugInfoMetadata.h:705
llvm::DITemplateParameter::getType
DIType * getType() const
Definition: DebugInfoMetadata.h:2385
llvm::DwarfDebug::useAllLinkageNames
bool useAllLinkageNames() const
Returns whether we should emit all DW_AT_[MIPS_]linkage_name.
Definition: DwarfDebug.h:693
GlobalValue.h
llvm::DIELoc::ComputeSize
unsigned ComputeSize(const AsmPrinter *AP) const
ComputeSize - Calculate the size of the location expression.
Definition: DIE.cpp:719
llvm::DIType::isPublic
bool isPublic() const
Definition: DebugInfoMetadata.h:727
llvm::DISubrange::getCount
BoundType getCount() const
Definition: DebugInfoMetadata.cpp:369
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:3537
llvm::DILocalVariable
Local variable.
Definition: DebugInfoMetadata.h:3053
llvm::DwarfUnit::constructContainingTypeDIEs
void constructContainingTypeDIEs()
Construct DIEs for types that contain vtables.
Definition: DwarfUnit.cpp:1530
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:295
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:463
llvm::HighlightColor::Enumerator
@ Enumerator
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:1763
llvm::DwarfUnit::DIEBlocks
std::vector< DIEBlock * > DIEBlocks
A list of all the DIEBlocks in use.
Definition: DwarfUnit.h:63
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:723
llvm::DIType::getLine
unsigned getLine() const
Definition: DebugInfoMetadata.h:700
llvm::DwarfUnit::getParentContextString
std::string getParentContextString(const DIScope *Context) const
Get string containing language specific context for a global name.
Definition: DwarfUnit.cpp:652
llvm::DIType::isObjcClassComplete
bool isObjcClassComplete() const
Definition: DebugInfoMetadata.h:735
llvm::DwarfUnit::CUNode
const DICompileUnit * CUNode
MDNode for the compile unit.
Definition: DwarfUnit.h:40
llvm::DIType::getName
StringRef getName() const
Definition: DebugInfoMetadata.h:708
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:1185
llvm::BitTracker
Definition: BitTracker.h:35
llvm::DISubrange
Array subrange.
Definition: DebugInfoMetadata.h:296
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:1757
llvm::DwarfUnit::addTemplateParams
void addTemplateParams(DIE &Buffer, DINodeArray TParams)
Add template parameters in buffer.
Definition: DwarfUnit.cpp:520
llvm::DICompositeType::getRuntimeLang
unsigned getRuntimeLang() const
Definition: DebugInfoMetadata.h:1191
llvm::DITemplateTypeParameter
Definition: DebugInfoMetadata.h:2397
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:823
llvm::DICompositeType::getDiscriminator
DIDerivedType * getDiscriminator() const
Definition: DebugInfoMetadata.h:1199
llvm::APInt::getZExtValue
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1631
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:1187
llvm::IndexedInstrProf::Version
const uint64_t Version
Definition: InstrProf.h:991
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:512
llvm::DIEBlock
DIEBlock - Represents a block of values.
Definition: DIE.h:959
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:1132
llvm::AsmPrinter::emitInt8
void emitInt8(int Value) const
Emit a byte directive and value.
Definition: AsmPrinter.cpp:2402
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:43
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:283
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:132
llvm::DwarfUnit::addPoolOpAddress
void addPoolOpAddress(DIEValueList &Die, const MCSymbol *Label)
Definition: DwarfUnit.cpp:313
G
const DataFlowGraph & G
Definition: RDFGraph.cpp:202
llvm::DwarfDebug::useAddrOffsetExpressions
bool useAddrOffsetExpressions() const
Definition: DwarfDebug.h:717
llvm::DwarfDebug::getDwarfSectionOffsetForm
dwarf::Form getDwarfSectionOffsetForm() const
Returns a suitable DWARF form to represent a section offset, i.e.
Definition: DwarfDebug.cpp:3516
llvm::DIType::isTypePassByValue
bool isTypePassByValue() const
Definition: DebugInfoMetadata.h:743
llvm::DwarfUnit::getOrCreateModule
DIE * getOrCreateModule(const DIModule *M)
Definition: DwarfUnit.cpp:1069
llvm::DITemplateValueParameter::getValue
Metadata * getValue() const
Definition: DebugInfoMetadata.h:2481
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::DICompositeType::getElements
DINodeArray getElements() const
Definition: DebugInfoMetadata.h:1181
Index
uint32_t Index
Definition: ELFObjHandler.cpp:84
llvm::dwarf::isType
bool isType(Tag T)
Definition: Dwarf.h:112
llvm::DINamespace::getName
StringRef getName() const
Definition: DebugInfoMetadata.h:2287
llvm::DwarfDebug
Collects and handles dwarf debug information.
Definition: DwarfDebug.h:295
llvm::APInt::getRawData
const uint64_t * getRawData() const
This function returns a pointer to the internal storage of the APInt.
Definition: APInt.h:694
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:1373
llvm::DIType::isTypePassByReference
bool isTypePassByReference() const
Definition: DebugInfoMetadata.h:744
llvm::ARM_MB::ST
@ ST
Definition: ARMBaseInfo.h:73
llvm::DIEDwarfExpression
DwarfExpression implementation for singular DW_AT_location.
Definition: DwarfExpression.h:405
llvm::DataLayout::isLittleEndian
bool isLittleEndian() const
Layout endianness...
Definition: DataLayout.h:241
llvm::DIGlobalVariable
Global variables.
Definition: DebugInfoMetadata.h:2911
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:749
llvm::DIType::getExportSymbols
bool getExportSymbols() const
Definition: DebugInfoMetadata.h:749
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:1795
llvm::DICompileUnit
Compile unit.
Definition: DebugInfoMetadata.h:1317
llvm::DIEUnit::getSection
MCSection * getSection() const
Return the section that this DIEUnit will be emitted into.
Definition: DIE.h:908
llvm::DIELoc
DIELoc - Represents an expression location.
Definition: DIE.h:922
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:2285
llvm::DIType::isVector
bool isVector() const
Definition: DebugInfoMetadata.h:738
llvm::DwarfUnit::Asm
AsmPrinter * Asm
Target of Dwarf emission.
Definition: DwarfUnit.h:46
llvm::mc::getDwarfVersion
int getDwarfVersion()
llvm::TargetMachine::Options
TargetOptions Options
Definition: TargetMachine.h:115
llvm::DINamespace::getScope
DIScope * getScope() const
Definition: DebugInfoMetadata.h:2286
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::AsmPrinter::getSymbol
MCSymbol * getSymbol(const GlobalValue *GV) const
Definition: AsmPrinter.cpp:492
llvm::DwarfUnit::MDNodeToDieMap
DenseMap< const MDNode *, DIE * > MDNodeToDieMap
Tracks the mapping of unit level debug information variables to debug information entries.
Definition: DwarfUnit.h:60
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:379
llvm::DICompileUnit::isDebugDirectivesOnly
bool isDebugDirectivesOnly() const
Definition: DebugInfoMetadata.h:1453
llvm::DICompositeType::getDataLocation
DIVariable * getDataLocation() const
Definition: DebugInfoMetadata.h:1201
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:896
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:66
llvm::MDNode
Metadata node.
Definition: Metadata.h:897
llvm::DwarfTypeUnit::emitHeader
void emitHeader(bool UseOffsets) override
Emit the header for this unit, not including the initial length field.
Definition: DwarfUnit.cpp:1746
llvm::DwarfUnit::constructSubprogramArguments
void constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args)
Construct function argument DIEs.
Definition: DwarfUnit.cpp:787
llvm::DwarfUnit::IndexTyDie
DIE * IndexTyDie
An anonymous type for index type. Owned by DIEUnit.
Definition: DwarfUnit.h:56
llvm::DIGenericSubrange::getCount
BoundType getCount() const
Definition: DebugInfoMetadata.cpp:463
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:769
llvm::APInt
Class for arbitrary precision integers.
Definition: APInt.h:70
llvm::DINode::getTag
dwarf::Tag getTag() const
Definition: DebugInfoMetadata.h:160
llvm::DISubrange::getStride
BoundType getStride() const
Definition: DebugInfoMetadata.cpp:432
llvm::DISubroutineType::getCC
uint8_t getCC() const
Definition: DebugInfoMetadata.h:1303
llvm::DISubroutineType
Type array for a subprogram.
Definition: DebugInfoMetadata.h:1263
llvm::dwarf::SourceLanguage
SourceLanguage
Definition: Dwarf.h:200
llvm::DICompositeType
Composite types.
Definition: DebugInfoMetadata.h:1051
llvm::DIScope::getScope
DIScope * getScope() const
Definition: DebugInfoMetadata.cpp:237
llvm::DwarfUnit::getOrCreateTypeDIE
DIE * getOrCreateTypeDIE(const MDNode *TyNode)
Find existing DIE or create new DIE for the given type.
Definition: DwarfUnit.cpp:601
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:388
None.h
MCAsmInfo.h
DataLayout.h
llvm::MCDwarfDwoLineTable
Definition: MCDwarf.h:283
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:58
llvm::DIGenericSubrange::getStride
BoundType getStride() const
Definition: DebugInfoMetadata.cpp:514
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:2501
TargetLoweringObjectFile.h
uint32_t
llvm::DIStringType::getEncoding
unsigned getEncoding() const
Definition: DebugInfoMetadata.h:904
TargetSubtargetInfo.h
Unsigned
@ Unsigned
Definition: NVPTXISelLowering.cpp:4631
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:1208
llvm::DwarfDebug::generateTypeUnits
bool generateTypeUnits() const
Returns whether to generate DWARF v4 type units.
Definition: DwarfDebug.h:736
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:667
llvm::DIVariable
Base class for variables.
Definition: DebugInfoMetadata.h:2489
llvm::TargetOptions::DebugStrictDwarf
unsigned DebugStrictDwarf
When set to true, don't use DWARF extensions in later DWARF versions.
Definition: TargetOptions.h:324
llvm::DwarfDebug::shareAcrossDWOCUs
bool shareAcrossDWOCUs() const
Definition: DwarfDebug.cpp:561
llvm::DIType::getRawName
MDString * getRawName() const
Definition: DebugInfoMetadata.h:712
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:3181
llvm::PointerUnion
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
Definition: PointerUnion.h:149
llvm::DwarfUnit::EndLabel
MCSymbol * EndLabel
Emitted at the end of the CU and used to compute the CU Length field.
Definition: DwarfUnit.h:49
llvm::DIType::isLittleEndian
bool isLittleEndian() const
Definition: DebugInfoMetadata.h:748
llvm::Register
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
llvm::DwarfDebug::enterNonTypeUnitContext
NonTypeUnitContext enterNonTypeUnitContext()
Definition: DwarfDebug.cpp:3454
llvm::DwarfDebug::getSectionLabel
const MCSymbol * getSectionLabel(const MCSection *S)
Definition: DwarfDebug.cpp:3525
llvm::DwarfFile::getStringPool
DwarfStringPool & getStringPool()
Returns the string pool.
Definition: DwarfFile.h:144
llvm::DIType::isForwardDecl
bool isForwardDecl() const
Definition: DebugInfoMetadata.h:730
llvm::DwarfUnit::getOrCreateNameSpace
DIE * getOrCreateNameSpace(const DINamespace *NS)
Definition: DwarfUnit.cpp:1048
llvm::DISubrange::getLowerBound
BoundType getLowerBound() const
Definition: DebugInfoMetadata.cpp:390
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:704
llvm::DwarfUnit::DD
DwarfDebug * DD
Definition: DwarfUnit.h:52
llvm::DwarfDebug::useAppleExtensionAttributes
bool useAppleExtensionAttributes() const
Definition: DwarfDebug.h:743
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
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:81
llvm::DIScope
Base class for scope-like contexts.
Definition: DebugInfoMetadata.h:476
uint16_t
llvm::DIType::isBigEndian
bool isBigEndian() const
Definition: DebugInfoMetadata.h:747
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:314
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:227
llvm::DwarfDebug::useInlineStrings
bool useInlineStrings() const
Returns whether to use inline strings.
Definition: DwarfDebug.h:704
Casting.h
llvm::DITemplateParameter::getName
StringRef getName() const
Definition: DebugInfoMetadata.h:2384
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:1394
llvm::DICompileUnit::getDebugInfoForProfiling
bool getDebugInfoForProfiling() const
Definition: DebugInfoMetadata.h:1456
DwarfUnit.h
llvm::MCDwarfDwoLineTable::getFile
unsigned getFile(StringRef Directory, StringRef FileName, Optional< MD5::MD5Result > Checksum, uint16_t DwarfVersion, Optional< StringRef > Source)
Definition: MCDwarf.h:296
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:395
llvm::DIELoc::BestForm
dwarf::Form BestForm(unsigned DwarfVersion) const
BestForm - Choose the best form for data.
Definition: DIE.h:937
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::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:568
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:1782
llvm::DIDerivedType
Derived types.
Definition: DebugInfoMetadata.h:917
llvm::MCObjectFileInfo::getDwarfAbbrevSection
MCSection * getDwarfAbbrevSection() const
Definition: MCObjectFileInfo.h:260
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:2504
llvm::DITemplateValueParameter
Definition: DebugInfoMetadata.h:2439
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:286
llvm::DIGenericSubrange::getLowerBound
BoundType getLowerBound() const
Definition: DebugInfoMetadata.cpp:480
llvm::AsmPrinter::getObjFileLowering
const TargetLoweringObjectFile & getObjFileLowering() const
Return information about object file lowering.
Definition: AsmPrinter.cpp:224
N
#define N
MCStreamer.h
llvm::DICompositeType::getAllocated
DIVariable * getAllocated() const
Definition: DebugInfoMetadata.h:1215
llvm::DwarfDebug::addAccelType
void addAccelType(const DICompileUnit &CU, StringRef Name, const DIE &Die, char Flags)
Definition: DwarfDebug.cpp:3507
llvm::AsmPrinter::getDataLayout
const DataLayout & getDataLayout() const
Return information about data layout.
Definition: AsmPrinter.cpp:228
llvm::DwarfDebug::useDWARF2Bitfields
bool useDWARF2Bitfields() const
Returns whether to use the DWARF2 format for bitfields instyead of the DWARF4 format.
Definition: DwarfDebug.h:701
llvm::DwarfUnit::applySubprogramDefinitionAttributes
bool applySubprogramDefinitionAttributes(const DISubprogram *SP, DIE &SPDie, bool Minimal)
Definition: DwarfUnit.cpp:1132
llvm::DISubprogram
Subprogram description.
Definition: DebugInfoMetadata.h:1802
MachineOperand.h
llvm::DIModule
Represents a module in the programming language, for example, a Clang module, or a Fortran module.
Definition: DebugInfoMetadata.h:2299
llvm::HexStyle::Asm
@ Asm
0ffh
Definition: MCInstPrinter.h:34
llvm::DwarfDebug::getDwarfVersion
uint16_t getDwarfVersion() const
Returns the Dwarf Version.
Definition: DwarfDebug.cpp:3512
llvm::DILabel
Label.
Definition: DebugInfoMetadata.h:3133
llvm::DwarfUnit
This dwarf writer support class manages information associated with a source file.
Definition: DwarfUnit.h:37
llvm::DebugHandlerBase::isUnsignedDIType
static bool isUnsignedDIType(const DIType *Ty)
Return true if type encoding is unsigned.
Definition: DebugHandlerBase.cpp:176
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:1218
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:71
llvm::DIType::isArtificial
bool isArtificial() const
Definition: DebugInfoMetadata.h:733
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:1777
llvm::DwarfUnit::addConstantFPValue
void addConstantFPValue(DIE &Die, const ConstantFP *CFP)
Add constant value entry in variable DIE.
Definition: DwarfUnit.cpp:458
CU
Definition: AArch64AsmBackend.cpp:499
llvm::DIELabel
A label DIE.
Definition: DIE.h:218
llvm::DIType::isRValueReference
bool isRValueReference() const
Definition: DebugInfoMetadata.h:742
llvm::DwarfUnit::getLanguage
uint16_t getLanguage() const
Definition: DwarfUnit.h:100
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::AsmPrinter::emitInt16
void emitInt16(int Value) const
Emit a short directive and value.
Definition: AsmPrinter.cpp:2405
TargetRegisterInfo.h
File
Instrumentation for Order File
Definition: InstrOrderFile.cpp:206
llvm::DIEUnit::getUnitDie
DIE & getUnitDie()
Definition: DIE.h:911
llvm::DIObjCProperty::getLine
unsigned getLine() const
Definition: DebugInfoMetadata.h:3252
llvm::DICompositeType::getAssociatedExp
DIExpression * getAssociatedExp() const
Definition: DebugInfoMetadata.h:1211
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:268
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:359
llvm::DIGenericSubrange::getUpperBound
BoundType getUpperBound() const
Definition: DebugInfoMetadata.cpp:497