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