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