DebugInfo: Simplify solution to avoid DW_AT_artificial on inlined parameters.
[opencl/llvm.git] / lib / CodeGen / AsmPrinter / DwarfUnit.cpp
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 //===----------------------------------------------------------------------===//
14 #include "DwarfUnit.h"
15 #include "DwarfAccelTable.h"
16 #include "DwarfDebug.h"
17 #include "llvm/ADT/APFloat.h"
18 #include "llvm/IR/Constants.h"
19 #include "llvm/IR/DIBuilder.h"
20 #include "llvm/IR/DataLayout.h"
21 #include "llvm/IR/GlobalVariable.h"
22 #include "llvm/IR/Instructions.h"
23 #include "llvm/IR/Mangler.h"
24 #include "llvm/MC/MCAsmInfo.h"
25 #include "llvm/MC/MCContext.h"
26 #include "llvm/MC/MCSection.h"
27 #include "llvm/MC/MCStreamer.h"
28 #include "llvm/Support/CommandLine.h"
29 #include "llvm/Target/TargetFrameLowering.h"
30 #include "llvm/Target/TargetLoweringObjectFile.h"
31 #include "llvm/Target/TargetMachine.h"
32 #include "llvm/Target/TargetRegisterInfo.h"
34 using namespace llvm;
36 #define DEBUG_TYPE "dwarfdebug"
38 static cl::opt<bool>
39 GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
40                        cl::desc("Generate DWARF4 type units."),
41                        cl::init(false));
43 /// Unit - Unit constructor.
44 DwarfUnit::DwarfUnit(unsigned UID, dwarf::Tag UnitTag, DICompileUnit Node,
45                      AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
46     : UniqueID(UID), CUNode(Node), UnitDie(UnitTag), DebugInfoOffset(0), Asm(A),
47       DD(DW), DU(DWU), IndexTyDie(nullptr), Section(nullptr),
48       Skeleton(nullptr) {
49   assert(UnitTag == dwarf::DW_TAG_compile_unit ||
50          UnitTag == dwarf::DW_TAG_type_unit);
51   DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
52 }
54 DwarfCompileUnit::DwarfCompileUnit(unsigned UID, DICompileUnit Node,
55                                    AsmPrinter *A, DwarfDebug *DW,
56                                    DwarfFile *DWU)
57     : DwarfUnit(UID, dwarf::DW_TAG_compile_unit, Node, A, DW, DWU) {
58   insertDIE(Node, &getUnitDie());
59 }
61 DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DwarfCompileUnit &CU, AsmPrinter *A,
62                              DwarfDebug *DW, DwarfFile *DWU,
63                              MCDwarfDwoLineTable *SplitLineTable)
64     : DwarfUnit(UID, dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU),
65       CU(CU), SplitLineTable(SplitLineTable) {
66   if (SplitLineTable)
67     addSectionOffset(UnitDie, dwarf::DW_AT_stmt_list, 0);
68 }
70 /// ~Unit - Destructor for compile unit.
71 DwarfUnit::~DwarfUnit() {
72   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
73     DIEBlocks[j]->~DIEBlock();
74   for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
75     DIELocs[j]->~DIELoc();
76 }
78 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
79 /// information entry.
80 DIEEntry *DwarfUnit::createDIEEntry(DIE &Entry) {
81   DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
82   return Value;
83 }
85 /// getDefaultLowerBound - Return the default lower bound for an array. If the
86 /// DWARF version doesn't handle the language, return -1.
87 int64_t DwarfUnit::getDefaultLowerBound() const {
88   switch (getLanguage()) {
89   default:
90     break;
92   case dwarf::DW_LANG_C89:
93   case dwarf::DW_LANG_C99:
94   case dwarf::DW_LANG_C:
95   case dwarf::DW_LANG_C_plus_plus:
96   case dwarf::DW_LANG_ObjC:
97   case dwarf::DW_LANG_ObjC_plus_plus:
98     return 0;
100   case dwarf::DW_LANG_Fortran77:
101   case dwarf::DW_LANG_Fortran90:
102   case dwarf::DW_LANG_Fortran95:
103     return 1;
105   // The languages below have valid values only if the DWARF version >= 4.
106   case dwarf::DW_LANG_Java:
107   case dwarf::DW_LANG_Python:
108   case dwarf::DW_LANG_UPC:
109   case dwarf::DW_LANG_D:
110     if (dwarf::DWARF_VERSION >= 4)
111       return 0;
112     break;
114   case dwarf::DW_LANG_Ada83:
115   case dwarf::DW_LANG_Ada95:
116   case dwarf::DW_LANG_Cobol74:
117   case dwarf::DW_LANG_Cobol85:
118   case dwarf::DW_LANG_Modula2:
119   case dwarf::DW_LANG_Pascal83:
120   case dwarf::DW_LANG_PLI:
121     if (dwarf::DWARF_VERSION >= 4)
122       return 1;
123     break;
124   }
126   return -1;
129 /// Check whether the DIE for this MDNode can be shared across CUs.
130 static bool isShareableAcrossCUs(DIDescriptor D) {
131   // When the MDNode can be part of the type system, the DIE can be shared
132   // across CUs.
133   // Combining type units and cross-CU DIE sharing is lower value (since
134   // cross-CU DIE sharing is used in LTO and removes type redundancy at that
135   // level already) but may be implementable for some value in projects
136   // building multiple independent libraries with LTO and then linking those
137   // together.
138   return (D.isType() ||
139           (D.isSubprogram() && !DISubprogram(D).isDefinition())) &&
140          !GenerateDwarfTypeUnits;
143 /// getDIE - Returns the debug information entry map slot for the
144 /// specified debug variable. We delegate the request to DwarfDebug
145 /// when the DIE for this MDNode can be shared across CUs. The mappings
146 /// will be kept in DwarfDebug for shareable DIEs.
147 DIE *DwarfUnit::getDIE(DIDescriptor D) const {
148   if (isShareableAcrossCUs(D))
149     return DD->getDIE(D);
150   return MDNodeToDieMap.lookup(D);
153 /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
154 /// when the DIE for this MDNode can be shared across CUs. The mappings
155 /// will be kept in DwarfDebug for shareable DIEs.
156 void DwarfUnit::insertDIE(DIDescriptor Desc, DIE *D) {
157   if (isShareableAcrossCUs(Desc)) {
158     DD->insertDIE(Desc, D);
159     return;
160   }
161   MDNodeToDieMap.insert(std::make_pair(Desc, D));
164 /// addFlag - Add a flag that is true.
165 void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
166   if (DD->getDwarfVersion() >= 4)
167     Die.addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
168   else
169     Die.addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
172 /// addUInt - Add an unsigned integer attribute data and value.
173 ///
174 void DwarfUnit::addUInt(DIE &Die, dwarf::Attribute Attribute,
175                         Optional<dwarf::Form> Form, uint64_t Integer) {
176   if (!Form)
177     Form = DIEInteger::BestForm(false, Integer);
178   DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
179                         DIEInteger(Integer);
180   Die.addValue(Attribute, *Form, Value);
183 void DwarfUnit::addUInt(DIE &Block, dwarf::Form Form, uint64_t Integer) {
184   addUInt(Block, (dwarf::Attribute)0, Form, Integer);
187 /// addSInt - Add an signed integer attribute data and value.
188 ///
189 void DwarfUnit::addSInt(DIE &Die, dwarf::Attribute Attribute,
190                         Optional<dwarf::Form> Form, int64_t Integer) {
191   if (!Form)
192     Form = DIEInteger::BestForm(true, Integer);
193   DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
194   Die.addValue(Attribute, *Form, Value);
197 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
198                         int64_t Integer) {
199   addSInt(Die, (dwarf::Attribute)0, Form, Integer);
202 /// addString - Add a string attribute data and value. We always emit a
203 /// reference to the string pool instead of immediate strings so that DIEs have
204 /// more predictable sizes. In the case of split dwarf we emit an index
205 /// into another table which gets us the static offset into the string
206 /// table.
207 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
208                           StringRef String) {
210   if (!DD->useSplitDwarf())
211     return addLocalString(Die, Attribute, String);
213   unsigned idx = DU->getStringPool().getIndex(*Asm, String);
214   DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
215   DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
216   Die.addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Str);
219 /// addLocalString - Add a string attribute data and value. This is guaranteed
220 /// to be in the local string pool instead of indirected.
221 void DwarfUnit::addLocalString(DIE &Die, dwarf::Attribute Attribute,
222                                StringRef String) {
223   MCSymbol *Symb = DU->getStringPool().getSymbol(*Asm, String);
224   DIEValue *Value;
225   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
226     Value = new (DIEValueAllocator) DIELabel(Symb);
227   else {
228     MCSymbol *StringPool = DU->getStringPool().getSectionSymbol();
229     Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
230   }
231   DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
232   Die.addValue(Attribute, dwarf::DW_FORM_strp, Str);
235 /// addExpr - Add a Dwarf expression attribute data and value.
236 ///
237 void DwarfUnit::addExpr(DIELoc &Die, dwarf::Form Form, const MCExpr *Expr) {
238   DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr);
239   Die.addValue((dwarf::Attribute)0, Form, Value);
242 /// addLocationList - Add a Dwarf loclistptr attribute data and value.
243 ///
244 void DwarfUnit::addLocationList(DIE &Die, dwarf::Attribute Attribute,
245                                 unsigned Index) {
246   DIEValue *Value = new (DIEValueAllocator) DIELocList(Index);
247   dwarf::Form Form = DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
248                                                 : dwarf::DW_FORM_data4;
249   Die.addValue(Attribute, Form, Value);
252 /// addLabel - Add a Dwarf label attribute data and value.
253 ///
254 void DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form,
255                          const MCSymbol *Label) {
256   DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
257   Die.addValue(Attribute, Form, Value);
260 void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
261   addLabel(Die, (dwarf::Attribute)0, Form, Label);
264 /// addSectionLabel - Add a Dwarf section label attribute data and value.
265 ///
266 void DwarfUnit::addSectionLabel(DIE &Die, dwarf::Attribute Attribute,
267                                 const MCSymbol *Label) {
268   if (DD->getDwarfVersion() >= 4)
269     addLabel(Die, Attribute, dwarf::DW_FORM_sec_offset, Label);
270   else
271     addLabel(Die, Attribute, dwarf::DW_FORM_data4, Label);
274 /// addSectionOffset - Add an offset into a section attribute data and value.
275 ///
276 void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
277                                  uint64_t Integer) {
278   if (DD->getDwarfVersion() >= 4)
279     addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
280   else
281     addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
284 /// addLabelAddress - Add a dwarf label attribute data and value using
285 /// DW_FORM_addr or DW_FORM_GNU_addr_index.
286 ///
287 void DwarfCompileUnit::addLabelAddress(DIE &Die, dwarf::Attribute Attribute,
288                                        const MCSymbol *Label) {
290   if (!DD->useSplitDwarf())
291     return addLocalLabelAddress(Die, Attribute, Label);
293   if (Label)
294     DD->addArangeLabel(SymbolCU(this, Label));
296   unsigned idx = DD->getAddressPool().getIndex(Label);
297   DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
298   Die.addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value);
301 void DwarfCompileUnit::addLocalLabelAddress(DIE &Die,
302                                             dwarf::Attribute Attribute,
303                                             const MCSymbol *Label) {
304   if (Label)
305     DD->addArangeLabel(SymbolCU(this, Label));
307   Die.addValue(Attribute, dwarf::DW_FORM_addr,
308                Label ? (DIEValue *)new (DIEValueAllocator) DIELabel(Label)
309                      : new (DIEValueAllocator) DIEInteger(0));
312 unsigned DwarfCompileUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
313   // If we print assembly, we can't separate .file entries according to
314   // compile units. Thus all files will belong to the default compile unit.
316   // FIXME: add a better feature test than hasRawTextSupport. Even better,
317   // extend .file to support this.
318   return Asm->OutStreamer.EmitDwarfFileDirective(
319       0, DirName, FileName,
320       Asm->OutStreamer.hasRawTextSupport() ? 0 : getUniqueID());
323 unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
324   return SplitLineTable ? SplitLineTable->getFile(DirName, FileName)
325                         : getCU().getOrCreateSourceID(FileName, DirName);
328 /// addOpAddress - Add a dwarf op address data and value using the
329 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
330 ///
331 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
332   if (!DD->useSplitDwarf()) {
333     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
334     addLabel(Die, dwarf::DW_FORM_udata, Sym);
335   } else {
336     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
337     addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
338             DD->getAddressPool().getIndex(Sym));
339   }
342 /// addSectionDelta - Add a section label delta attribute data and value.
343 ///
344 void DwarfUnit::addSectionDelta(DIE &Die, dwarf::Attribute Attribute,
345                                 const MCSymbol *Hi, const MCSymbol *Lo) {
346   DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
347   Die.addValue(Attribute, DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
348                                                      : dwarf::DW_FORM_data4,
349                Value);
352 void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
353                               const MCSymbol *Hi, const MCSymbol *Lo) {
354   DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
355   Die.addValue(Attribute, dwarf::DW_FORM_data4, Value);
358 /// addDIEEntry - Add a DIE attribute data and value.
359 ///
360 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
361   addDIEEntry(Die, Attribute, createDIEEntry(Entry));
364 void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) {
365   // Flag the type unit reference as a declaration so that if it contains
366   // members (implicit special members, static data member definitions, member
367   // declarations for definitions in this CU, etc) consumers don't get confused
368   // and think this is a full definition.
369   addFlag(Die, dwarf::DW_AT_declaration);
371   Die.addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
372                new (DIEValueAllocator) DIETypeSignature(Type));
375 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
376                             DIEEntry *Entry) {
377   const DIE *DieCU = Die.getUnitOrNull();
378   const DIE *EntryCU = Entry->getEntry().getUnitOrNull();
379   if (!DieCU)
380     // We assume that Die belongs to this CU, if it is not linked to any CU yet.
381     DieCU = &getUnitDie();
382   if (!EntryCU)
383     EntryCU = &getUnitDie();
384   Die.addValue(Attribute,
385                EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
386                Entry);
389 /// Create a DIE with the given Tag, add the DIE to its parent, and
390 /// call insertDIE if MD is not null.
391 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) {
392   assert(Tag != dwarf::DW_TAG_auto_variable &&
393          Tag != dwarf::DW_TAG_arg_variable);
394   Parent.addChild(make_unique<DIE>((dwarf::Tag)Tag));
395   DIE &Die = *Parent.getChildren().back();
396   if (N)
397     insertDIE(N, &Die);
398   return Die;
401 /// addBlock - Add block data.
402 ///
403 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
404   Loc->ComputeSize(Asm);
405   DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
406   Die.addValue(Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
409 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
410                          DIEBlock *Block) {
411   Block->ComputeSize(Asm);
412   DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
413   Die.addValue(Attribute, Block->BestForm(), Block);
416 /// addSourceLine - Add location information to specified debug information
417 /// entry.
418 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File,
419                               StringRef Directory) {
420   if (Line == 0)
421     return;
423   unsigned FileID = getOrCreateSourceID(File, Directory);
424   assert(FileID && "Invalid file id");
425   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
426   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
429 /// addSourceLine - Add location information to specified debug information
430 /// entry.
431 void DwarfUnit::addSourceLine(DIE &Die, DIVariable V) {
432   assert(V.isVariable());
434   addSourceLine(Die, V.getLineNumber(), V.getContext().getFilename(),
435                 V.getContext().getDirectory());
438 /// addSourceLine - Add location information to specified debug information
439 /// entry.
440 void DwarfUnit::addSourceLine(DIE &Die, DIGlobalVariable G) {
441   assert(G.isGlobalVariable());
443   addSourceLine(Die, G.getLineNumber(), G.getFilename(), G.getDirectory());
446 /// addSourceLine - Add location information to specified debug information
447 /// entry.
448 void DwarfUnit::addSourceLine(DIE &Die, DISubprogram SP) {
449   assert(SP.isSubprogram());
451   addSourceLine(Die, SP.getLineNumber(), SP.getFilename(), SP.getDirectory());
454 /// addSourceLine - Add location information to specified debug information
455 /// entry.
456 void DwarfUnit::addSourceLine(DIE &Die, DIType Ty) {
457   assert(Ty.isType());
459   addSourceLine(Die, Ty.getLineNumber(), Ty.getFilename(), Ty.getDirectory());
462 /// addSourceLine - Add location information to specified debug information
463 /// entry.
464 void DwarfUnit::addSourceLine(DIE &Die, DIObjCProperty Ty) {
465   assert(Ty.isObjCProperty());
467   DIFile File = Ty.getFile();
468   addSourceLine(Die, Ty.getLineNumber(), File.getFilename(),
469                 File.getDirectory());
472 /// addSourceLine - Add location information to specified debug information
473 /// entry.
474 void DwarfUnit::addSourceLine(DIE &Die, DINameSpace NS) {
475   assert(NS.Verify());
477   addSourceLine(Die, NS.getLineNumber(), NS.getFilename(), NS.getDirectory());
480 /// addVariableAddress - Add DW_AT_location attribute for a
481 /// DbgVariable based on provided MachineLocation.
482 void DwarfUnit::addVariableAddress(const DbgVariable &DV, DIE &Die,
483                                    MachineLocation Location) {
484   if (DV.variableHasComplexAddress())
485     addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
486   else if (DV.isBlockByrefVariable())
487     addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
488   else
489     addAddress(Die, dwarf::DW_AT_location, Location,
490                DV.getVariable().isIndirect());
493 /// addRegisterOp - Add register operand.
494 void DwarfUnit::addRegisterOp(DIELoc &TheDie, unsigned Reg) {
495   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
496   int DWReg = RI->getDwarfRegNum(Reg, false);
497   bool isSubRegister = DWReg < 0;
499   unsigned Idx = 0;
501   // Go up the super-register chain until we hit a valid dwarf register number.
502   for (MCSuperRegIterator SR(Reg, RI); SR.isValid() && DWReg < 0; ++SR) {
503     DWReg = RI->getDwarfRegNum(*SR, false);
504     if (DWReg >= 0)
505       Idx = RI->getSubRegIndex(*SR, Reg);
506   }
508   if (DWReg < 0) {
509     DEBUG(dbgs() << "Invalid Dwarf register number.\n");
510     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_nop);
511     return;
512   }
514   // Emit register
515   if (DWReg < 32)
516     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
517   else {
518     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
519     addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
520   }
522   // Emit Mask
523   if (isSubRegister) {
524     unsigned Size = RI->getSubRegIdxSize(Idx);
525     unsigned Offset = RI->getSubRegIdxOffset(Idx);
526     if (Offset > 0) {
527       addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bit_piece);
528       addUInt(TheDie, dwarf::DW_FORM_data1, Size);
529       addUInt(TheDie, dwarf::DW_FORM_data1, Offset);
530     } else {
531       unsigned ByteSize = Size / 8; // Assuming 8 bits per byte.
532       addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_piece);
533       addUInt(TheDie, dwarf::DW_FORM_data1, ByteSize);
534     }
535   }
538 /// addRegisterOffset - Add register offset.
539 void DwarfUnit::addRegisterOffset(DIELoc &TheDie, unsigned Reg,
540                                   int64_t Offset) {
541   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
542   unsigned DWReg = RI->getDwarfRegNum(Reg, false);
543   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
544   if (Reg == TRI->getFrameRegister(*Asm->MF))
545     // If variable offset is based in frame register then use fbreg.
546     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
547   else if (DWReg < 32)
548     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
549   else {
550     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
551     addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
552   }
553   addSInt(TheDie, dwarf::DW_FORM_sdata, Offset);
556 /// addAddress - Add an address attribute to a die based on the location
557 /// provided.
558 void DwarfUnit::addAddress(DIE &Die, dwarf::Attribute Attribute,
559                            const MachineLocation &Location, bool Indirect) {
560   DIELoc *Loc = new (DIEValueAllocator) DIELoc();
562   if (Location.isReg() && !Indirect)
563     addRegisterOp(*Loc, Location.getReg());
564   else {
565     addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
566     if (Indirect && !Location.isReg()) {
567       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
568     }
569   }
571   // Now attach the location information to the DIE.
572   addBlock(Die, Attribute, Loc);
575 /// addComplexAddress - Start with the address based on the location provided,
576 /// and generate the DWARF information necessary to find the actual variable
577 /// given the extra address information encoded in the DbgVariable, starting
578 /// from the starting location.  Add the DWARF information to the die.
579 ///
580 void DwarfUnit::addComplexAddress(const DbgVariable &DV, DIE &Die,
581                                   dwarf::Attribute Attribute,
582                                   const MachineLocation &Location) {
583   DIELoc *Loc = new (DIEValueAllocator) DIELoc();
584   unsigned N = DV.getNumAddrElements();
585   unsigned i = 0;
586   if (Location.isReg()) {
587     if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
588       // If first address element is OpPlus then emit
589       // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
590       addRegisterOffset(*Loc, Location.getReg(), DV.getAddrElement(1));
591       i = 2;
592     } else
593       addRegisterOp(*Loc, Location.getReg());
594   } else
595     addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
597   for (; i < N; ++i) {
598     uint64_t Element = DV.getAddrElement(i);
599     if (Element == DIBuilder::OpPlus) {
600       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
601       addUInt(*Loc, dwarf::DW_FORM_udata, DV.getAddrElement(++i));
602     } else if (Element == DIBuilder::OpDeref) {
603       if (!Location.isReg())
604         addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
605     } else
606       llvm_unreachable("unknown DIBuilder Opcode");
607   }
609   // Now attach the location information to the DIE.
610   addBlock(Die, Attribute, Loc);
613 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
614    VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
615    gives the variable VarName either the struct, or a pointer to the struct, as
616    its type.  This is necessary for various behind-the-scenes things the
617    compiler needs to do with by-reference variables in Blocks.
619    However, as far as the original *programmer* is concerned, the variable
620    should still have type 'SomeType', as originally declared.
622    The function getBlockByrefType dives into the __Block_byref_x_VarName
623    struct to find the original type of the variable, which is then assigned to
624    the variable's Debug Information Entry as its real type.  So far, so good.
625    However now the debugger will expect the variable VarName to have the type
626    SomeType.  So we need the location attribute for the variable to be an
627    expression that explains to the debugger how to navigate through the
628    pointers and struct to find the actual variable of type SomeType.
630    The following function does just that.  We start by getting
631    the "normal" location for the variable. This will be the location
632    of either the struct __Block_byref_x_VarName or the pointer to the
633    struct __Block_byref_x_VarName.
635    The struct will look something like:
637    struct __Block_byref_x_VarName {
638      ... <various fields>
639      struct __Block_byref_x_VarName *forwarding;
640      ... <various other fields>
641      SomeType VarName;
642      ... <maybe more fields>
643    };
645    If we are given the struct directly (as our starting point) we
646    need to tell the debugger to:
648    1).  Add the offset of the forwarding field.
650    2).  Follow that pointer to get the real __Block_byref_x_VarName
651    struct to use (the real one may have been copied onto the heap).
653    3).  Add the offset for the field VarName, to find the actual variable.
655    If we started with a pointer to the struct, then we need to
656    dereference that pointer first, before the other steps.
657    Translating this into DWARF ops, we will need to append the following
658    to the current location description for the variable:
660    DW_OP_deref                    -- optional, if we start with a pointer
661    DW_OP_plus_uconst <forward_fld_offset>
662    DW_OP_deref
663    DW_OP_plus_uconst <varName_fld_offset>
665    That is what this function does.  */
667 /// addBlockByrefAddress - Start with the address based on the location
668 /// provided, and generate the DWARF information necessary to find the
669 /// actual Block variable (navigating the Block struct) based on the
670 /// starting location.  Add the DWARF information to the die.  For
671 /// more information, read large comment just above here.
672 ///
673 void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die,
674                                      dwarf::Attribute Attribute,
675                                      const MachineLocation &Location) {
676   DIType Ty = DV.getType();
677   DIType TmpTy = Ty;
678   uint16_t Tag = Ty.getTag();
679   bool isPointer = false;
681   StringRef varName = DV.getName();
683   if (Tag == dwarf::DW_TAG_pointer_type) {
684     DIDerivedType DTy(Ty);
685     TmpTy = resolve(DTy.getTypeDerivedFrom());
686     isPointer = true;
687   }
689   DICompositeType blockStruct(TmpTy);
691   // Find the __forwarding field and the variable field in the __Block_byref
692   // struct.
693   DIArray Fields = blockStruct.getTypeArray();
694   DIDerivedType varField;
695   DIDerivedType forwardingField;
697   for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
698     DIDerivedType DT(Fields.getElement(i));
699     StringRef fieldName = DT.getName();
700     if (fieldName == "__forwarding")
701       forwardingField = DT;
702     else if (fieldName == varName)
703       varField = DT;
704   }
706   // Get the offsets for the forwarding field and the variable field.
707   unsigned forwardingFieldOffset = forwardingField.getOffsetInBits() >> 3;
708   unsigned varFieldOffset = varField.getOffsetInBits() >> 2;
710   // Decode the original location, and use that as the start of the byref
711   // variable's location.
712   DIELoc *Loc = new (DIEValueAllocator) DIELoc();
714   if (Location.isReg())
715     addRegisterOp(*Loc, Location.getReg());
716   else
717     addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
719   // If we started with a pointer to the __Block_byref... struct, then
720   // the first thing we need to do is dereference the pointer (DW_OP_deref).
721   if (isPointer)
722     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
724   // Next add the offset for the '__forwarding' field:
725   // DW_OP_plus_uconst ForwardingFieldOffset.  Note there's no point in
726   // adding the offset if it's 0.
727   if (forwardingFieldOffset > 0) {
728     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
729     addUInt(*Loc, dwarf::DW_FORM_udata, forwardingFieldOffset);
730   }
732   // Now dereference the __forwarding field to get to the real __Block_byref
733   // struct:  DW_OP_deref.
734   addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
736   // Now that we've got the real __Block_byref... struct, add the offset
737   // for the variable's field to get to the location of the actual variable:
738   // DW_OP_plus_uconst varFieldOffset.  Again, don't add if it's 0.
739   if (varFieldOffset > 0) {
740     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
741     addUInt(*Loc, dwarf::DW_FORM_udata, varFieldOffset);
742   }
744   // Now attach the location information to the DIE.
745   addBlock(Die, Attribute, Loc);
748 /// Return true if type encoding is unsigned.
749 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
750   DIDerivedType DTy(Ty);
751   if (DTy.isDerivedType()) {
752     dwarf::Tag T = (dwarf::Tag)Ty.getTag();
753     // Encode pointer constants as unsigned bytes. This is used at least for
754     // null pointer constant emission.
755     // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
756     // here, but accept them for now due to a bug in SROA producing bogus
757     // dbg.values.
758     if (T == dwarf::DW_TAG_pointer_type ||
759         T == dwarf::DW_TAG_ptr_to_member_type ||
760         T == dwarf::DW_TAG_reference_type ||
761         T == dwarf::DW_TAG_rvalue_reference_type)
762       return true;
763     assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
764            T == dwarf::DW_TAG_volatile_type ||
765            T == dwarf::DW_TAG_restrict_type ||
766            T == dwarf::DW_TAG_enumeration_type);
767     if (DITypeRef Deriv = DTy.getTypeDerivedFrom())
768       return isUnsignedDIType(DD, DD->resolve(Deriv));
769     // FIXME: Enums without a fixed underlying type have unknown signedness
770     // here, leading to incorrectly emitted constants.
771     assert(DTy.getTag() == dwarf::DW_TAG_enumeration_type);
772     return false;
773   }
775   DIBasicType BTy(Ty);
776   assert(BTy.isBasicType());
777   unsigned Encoding = BTy.getEncoding();
778   assert((Encoding == dwarf::DW_ATE_unsigned ||
779           Encoding == dwarf::DW_ATE_unsigned_char ||
780           Encoding == dwarf::DW_ATE_signed ||
781           Encoding == dwarf::DW_ATE_signed_char ||
782           Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean) &&
783          "Unsupported encoding");
784   return (Encoding == dwarf::DW_ATE_unsigned ||
785           Encoding == dwarf::DW_ATE_unsigned_char ||
786           Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean);
789 /// If this type is derived from a base type then return base type size.
790 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
791   unsigned Tag = Ty.getTag();
793   if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
794       Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
795       Tag != dwarf::DW_TAG_restrict_type)
796     return Ty.getSizeInBits();
798   DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
800   // If this type is not derived from any type or the type is a declaration then
801   // take conservative approach.
802   if (!BaseType.isValid() || BaseType.isForwardDecl())
803     return Ty.getSizeInBits();
805   // If this is a derived type, go ahead and get the base type, unless it's a
806   // reference then it's just the size of the field. Pointer types have no need
807   // of this since they're a different type of qualification on the type.
808   if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
809       BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
810     return Ty.getSizeInBits();
812   if (BaseType.isDerivedType())
813     return getBaseTypeSize(DD, DIDerivedType(BaseType));
815   return BaseType.getSizeInBits();
818 /// addConstantFPValue - Add constant value entry in variable DIE.
819 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
820   assert(MO.isFPImm() && "Invalid machine operand!");
821   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
822   APFloat FPImm = MO.getFPImm()->getValueAPF();
824   // Get the raw data form of the floating point.
825   const APInt FltVal = FPImm.bitcastToAPInt();
826   const char *FltPtr = (const char *)FltVal.getRawData();
828   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
829   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
830   int Incr = (LittleEndian ? 1 : -1);
831   int Start = (LittleEndian ? 0 : NumBytes - 1);
832   int Stop = (LittleEndian ? NumBytes : -1);
834   // Output the constant to DWARF one byte at a time.
835   for (; Start != Stop; Start += Incr)
836     addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
838   addBlock(Die, dwarf::DW_AT_const_value, Block);
841 /// addConstantFPValue - Add constant value entry in variable DIE.
842 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
843   // Pass this down to addConstantValue as an unsigned bag of bits.
844   addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
847 /// addConstantValue - Add constant value entry in variable DIE.
848 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI, DIType Ty) {
849   addConstantValue(Die, CI->getValue(), Ty);
852 /// addConstantValue - Add constant value entry in variable DIE.
853 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
854                                  DIType Ty) {
855   assert(MO.isImm() && "Invalid machine operand!");
857   addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
860 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
861   // FIXME: This is a bit conservative/simple - it emits negative values always
862   // sign extended to 64 bits rather than minimizing the number of bytes.
863   addUInt(Die, dwarf::DW_AT_const_value,
864           Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
867 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, DIType Ty) {
868   addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
871 // addConstantValue - Add constant value entry in variable DIE.
872 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
873   unsigned CIBitWidth = Val.getBitWidth();
874   if (CIBitWidth <= 64) {
875     addConstantValue(Die, Unsigned,
876                      Unsigned ? Val.getZExtValue() : Val.getSExtValue());
877     return;
878   }
880   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
882   // Get the raw data form of the large APInt.
883   const uint64_t *Ptr64 = Val.getRawData();
885   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
886   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
888   // Output the constant to DWARF one byte at a time.
889   for (int i = 0; i < NumBytes; i++) {
890     uint8_t c;
891     if (LittleEndian)
892       c = Ptr64[i / 8] >> (8 * (i & 7));
893     else
894       c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
895     addUInt(*Block, dwarf::DW_FORM_data1, c);
896   }
898   addBlock(Die, dwarf::DW_AT_const_value, Block);
901 /// addTemplateParams - Add template parameters into buffer.
902 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
903   // Add template parameters.
904   for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
905     DIDescriptor Element = TParams.getElement(i);
906     if (Element.isTemplateTypeParameter())
907       constructTemplateTypeParameterDIE(Buffer,
908                                         DITemplateTypeParameter(Element));
909     else if (Element.isTemplateValueParameter())
910       constructTemplateValueParameterDIE(Buffer,
911                                          DITemplateValueParameter(Element));
912   }
915 /// getOrCreateContextDIE - Get context owner's DIE.
916 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
917   if (!Context || Context.isFile())
918     return &getUnitDie();
919   if (Context.isType())
920     return getOrCreateTypeDIE(DIType(Context));
921   if (Context.isNameSpace())
922     return getOrCreateNameSpace(DINameSpace(Context));
923   if (Context.isSubprogram())
924     return getOrCreateSubprogramDIE(DISubprogram(Context));
925   return getDIE(Context);
928 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
929   DIScope Context = resolve(Ty.getContext());
930   DIE *ContextDIE = getOrCreateContextDIE(Context);
932   if (DIE *TyDIE = getDIE(Ty))
933     return TyDIE;
935   // Create new type.
936   DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
938   constructTypeDIE(TyDIE, Ty);
940   updateAcceleratorTables(Context, Ty, TyDIE);
941   return &TyDIE;
944 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
945 /// given DIType.
946 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
947   if (!TyNode)
948     return nullptr;
950   DIType Ty(TyNode);
951   assert(Ty.isType());
952   assert(Ty == resolve(Ty.getRef()) &&
953          "type was not uniqued, possible ODR violation.");
955   // DW_TAG_restrict_type is not supported in DWARF2
956   if (Ty.getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
957     return getOrCreateTypeDIE(resolve(DIDerivedType(Ty).getTypeDerivedFrom()));
959   // Construct the context before querying for the existence of the DIE in case
960   // such construction creates the DIE.
961   DIScope Context = resolve(Ty.getContext());
962   DIE *ContextDIE = getOrCreateContextDIE(Context);
963   assert(ContextDIE);
965   if (DIE *TyDIE = getDIE(Ty))
966     return TyDIE;
968   // Create new type.
969   DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
971   updateAcceleratorTables(Context, Ty, TyDIE);
973   if (Ty.isBasicType())
974     constructTypeDIE(TyDIE, DIBasicType(Ty));
975   else if (Ty.isCompositeType()) {
976     DICompositeType CTy(Ty);
977     if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
978       if (MDString *TypeId = CTy.getIdentifier()) {
979         DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
980         // Skip updating the accelerator tables since this is not the full type.
981         return &TyDIE;
982       }
983     constructTypeDIE(TyDIE, CTy);
984   } else {
985     assert(Ty.isDerivedType() && "Unknown kind of DIType");
986     constructTypeDIE(TyDIE, DIDerivedType(Ty));
987   }
989   return &TyDIE;
992 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
993                                         const DIE &TyDIE) {
994   if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
995     bool IsImplementation = 0;
996     if (Ty.isCompositeType()) {
997       DICompositeType CT(Ty);
998       // A runtime language of 0 actually means C/C++ and that any
999       // non-negative value is some version of Objective-C/C++.
1000       IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
1001     }
1002     unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
1003     DD->addAccelType(Ty.getName(), TyDIE, Flags);
1005     if ((!Context || Context.isCompileUnit() || Context.isFile() ||
1006          Context.isNameSpace()) &&
1007         getCUNode().getEmissionKind() != DIBuilder::LineTablesOnly)
1008       GlobalTypes[getParentContextString(Context) + Ty.getName().str()] =
1009           &TyDIE;
1010   }
1013 /// addType - Add a new type attribute to the specified entity.
1014 void DwarfUnit::addType(DIE &Entity, DIType Ty, dwarf::Attribute Attribute) {
1015   assert(Ty && "Trying to add a type that doesn't exist?");
1017   // Check for pre-existence.
1018   DIEEntry *Entry = getDIEEntry(Ty);
1019   // If it exists then use the existing value.
1020   if (Entry) {
1021     addDIEEntry(Entity, Attribute, Entry);
1022     return;
1023   }
1025   // Construct type.
1026   DIE *Buffer = getOrCreateTypeDIE(Ty);
1028   // Set up proxy.
1029   Entry = createDIEEntry(*Buffer);
1030   insertDIEEntry(Ty, Entry);
1031   addDIEEntry(Entity, Attribute, Entry);
1034 /// addGlobalName - Add a new global name to the compile unit.
1035 void DwarfUnit::addGlobalName(StringRef Name, DIE &Die, DIScope Context) {
1036   if (getCUNode().getEmissionKind() == DIBuilder::LineTablesOnly)
1037     return;
1038   std::string FullName = getParentContextString(Context) + Name.str();
1039   GlobalNames[FullName] = &Die;
1042 /// getParentContextString - Walks the metadata parent chain in a language
1043 /// specific manner (using the compile unit language) and returns
1044 /// it as a string. This is done at the metadata level because DIEs may
1045 /// not currently have been added to the parent context and walking the
1046 /// DIEs looking for names is more expensive than walking the metadata.
1047 std::string DwarfUnit::getParentContextString(DIScope Context) const {
1048   if (!Context)
1049     return "";
1051   // FIXME: Decide whether to implement this for non-C++ languages.
1052   if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
1053     return "";
1055   std::string CS;
1056   SmallVector<DIScope, 1> Parents;
1057   while (!Context.isCompileUnit()) {
1058     Parents.push_back(Context);
1059     if (Context.getContext())
1060       Context = resolve(Context.getContext());
1061     else
1062       // Structure, etc types will have a NULL context if they're at the top
1063       // level.
1064       break;
1065   }
1067   // Reverse iterate over our list to go from the outermost construct to the
1068   // innermost.
1069   for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
1070                                                   E = Parents.rend();
1071        I != E; ++I) {
1072     DIScope Ctx = *I;
1073     StringRef Name = Ctx.getName();
1074     if (!Name.empty()) {
1075       CS += Name;
1076       CS += "::";
1077     }
1078   }
1079   return CS;
1082 /// constructTypeDIE - Construct basic type die from DIBasicType.
1083 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
1084   // Get core information.
1085   StringRef Name = BTy.getName();
1086   // Add name if not anonymous or intermediate type.
1087   if (!Name.empty())
1088     addString(Buffer, dwarf::DW_AT_name, Name);
1090   // An unspecified type only has a name attribute.
1091   if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
1092     return;
1094   addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1095           BTy.getEncoding());
1097   uint64_t Size = BTy.getSizeInBits() >> 3;
1098   addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1101 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1102 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1103   // Get core information.
1104   StringRef Name = DTy.getName();
1105   uint64_t Size = DTy.getSizeInBits() >> 3;
1106   uint16_t Tag = Buffer.getTag();
1108   // Map to main type, void will not have a type.
1109   DIType FromTy = resolve(DTy.getTypeDerivedFrom());
1110   if (FromTy)
1111     addType(Buffer, FromTy);
1113   // Add name if not anonymous or intermediate type.
1114   if (!Name.empty())
1115     addString(Buffer, dwarf::DW_AT_name, Name);
1117   // Add size if non-zero (derived types might be zero-sized.)
1118   if (Size && Tag != dwarf::DW_TAG_pointer_type)
1119     addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1121   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
1122     addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1123                 *getOrCreateTypeDIE(resolve(DTy.getClassType())));
1124   // Add source line info if available and TyDesc is not a forward declaration.
1125   if (!DTy.isForwardDecl())
1126     addSourceLine(Buffer, DTy);
1129 /// constructSubprogramArguments - Construct function argument DIEs.
1130 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DIArray Args) {
1131   for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1132     DIDescriptor Ty = Args.getElement(i);
1133     if (Ty.isUnspecifiedParameter()) {
1134       assert(i == N-1 && "Unspecified parameter must be the last argument");
1135       createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1136     } else {
1137       DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1138       addType(Arg, DIType(Ty));
1139       if (DIType(Ty).isArtificial())
1140         addFlag(Arg, dwarf::DW_AT_artificial);
1141     }
1142   }
1145 /// constructTypeDIE - Construct type DIE from DICompositeType.
1146 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1147   // Add name if not anonymous or intermediate type.
1148   StringRef Name = CTy.getName();
1150   uint64_t Size = CTy.getSizeInBits() >> 3;
1151   uint16_t Tag = Buffer.getTag();
1153   switch (Tag) {
1154   case dwarf::DW_TAG_array_type:
1155     constructArrayTypeDIE(Buffer, CTy);
1156     break;
1157   case dwarf::DW_TAG_enumeration_type:
1158     constructEnumTypeDIE(Buffer, CTy);
1159     break;
1160   case dwarf::DW_TAG_subroutine_type: {
1161     // Add return type. A void return won't have a type.
1162     DIArray Elements = CTy.getTypeArray();
1163     DIType RTy(Elements.getElement(0));
1164     if (RTy)
1165       addType(Buffer, RTy);
1167     bool isPrototyped = true;
1168     if (Elements.getNumElements() == 2 &&
1169         Elements.getElement(1).isUnspecifiedParameter())
1170       isPrototyped = false;
1172     constructSubprogramArguments(Buffer, Elements);
1174     // Add prototype flag if we're dealing with a C language and the
1175     // function has been prototyped.
1176     uint16_t Language = getLanguage();
1177     if (isPrototyped &&
1178         (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1179          Language == dwarf::DW_LANG_ObjC))
1180       addFlag(Buffer, dwarf::DW_AT_prototyped);
1182     if (CTy.isLValueReference())
1183       addFlag(Buffer, dwarf::DW_AT_reference);
1185     if (CTy.isRValueReference())
1186       addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
1187   } break;
1188   case dwarf::DW_TAG_structure_type:
1189   case dwarf::DW_TAG_union_type:
1190   case dwarf::DW_TAG_class_type: {
1191     // Add elements to structure type.
1192     DIArray Elements = CTy.getTypeArray();
1193     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1194       DIDescriptor Element = Elements.getElement(i);
1195       if (Element.isSubprogram())
1196         getOrCreateSubprogramDIE(DISubprogram(Element));
1197       else if (Element.isDerivedType()) {
1198         DIDerivedType DDTy(Element);
1199         if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1200           DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1201           addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1202                   dwarf::DW_AT_friend);
1203         } else if (DDTy.isStaticMember()) {
1204           getOrCreateStaticMemberDIE(DDTy);
1205         } else {
1206           constructMemberDIE(Buffer, DDTy);
1207         }
1208       } else if (Element.isObjCProperty()) {
1209         DIObjCProperty Property(Element);
1210         DIE &ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1211         StringRef PropertyName = Property.getObjCPropertyName();
1212         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1213         if (Property.getType())
1214           addType(ElemDie, Property.getType());
1215         addSourceLine(ElemDie, Property);
1216         StringRef GetterName = Property.getObjCPropertyGetterName();
1217         if (!GetterName.empty())
1218           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1219         StringRef SetterName = Property.getObjCPropertySetterName();
1220         if (!SetterName.empty())
1221           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1222         unsigned PropertyAttributes = 0;
1223         if (Property.isReadOnlyObjCProperty())
1224           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1225         if (Property.isReadWriteObjCProperty())
1226           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1227         if (Property.isAssignObjCProperty())
1228           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1229         if (Property.isRetainObjCProperty())
1230           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1231         if (Property.isCopyObjCProperty())
1232           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1233         if (Property.isNonAtomicObjCProperty())
1234           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1235         if (PropertyAttributes)
1236           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1237                   PropertyAttributes);
1239         DIEEntry *Entry = getDIEEntry(Element);
1240         if (!Entry) {
1241           Entry = createDIEEntry(ElemDie);
1242           insertDIEEntry(Element, Entry);
1243         }
1244       } else
1245         continue;
1246     }
1248     if (CTy.isAppleBlockExtension())
1249       addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1251     DICompositeType ContainingType(resolve(CTy.getContainingType()));
1252     if (ContainingType)
1253       addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1254                   *getOrCreateTypeDIE(ContainingType));
1256     if (CTy.isObjcClassComplete())
1257       addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1259     // Add template parameters to a class, structure or union types.
1260     // FIXME: The support isn't in the metadata for this yet.
1261     if (Tag == dwarf::DW_TAG_class_type ||
1262         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1263       addTemplateParams(Buffer, CTy.getTemplateParams());
1265     break;
1266   }
1267   default:
1268     break;
1269   }
1271   // Add name if not anonymous or intermediate type.
1272   if (!Name.empty())
1273     addString(Buffer, dwarf::DW_AT_name, Name);
1275   if (Tag == dwarf::DW_TAG_enumeration_type ||
1276       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1277       Tag == dwarf::DW_TAG_union_type) {
1278     // Add size if non-zero (derived types might be zero-sized.)
1279     // TODO: Do we care about size for enum forward declarations?
1280     if (Size)
1281       addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1282     else if (!CTy.isForwardDecl())
1283       // Add zero size if it is not a forward declaration.
1284       addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1286     // If we're a forward decl, say so.
1287     if (CTy.isForwardDecl())
1288       addFlag(Buffer, dwarf::DW_AT_declaration);
1290     // Add source line info if available.
1291     if (!CTy.isForwardDecl())
1292       addSourceLine(Buffer, CTy);
1294     // No harm in adding the runtime language to the declaration.
1295     unsigned RLang = CTy.getRunTimeLang();
1296     if (RLang)
1297       addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1298               RLang);
1299   }
1302 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1303 /// DITemplateTypeParameter.
1304 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1305                                                   DITemplateTypeParameter TP) {
1306   DIE &ParamDIE =
1307       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1308   // Add the type if it exists, it could be void and therefore no type.
1309   if (TP.getType())
1310     addType(ParamDIE, resolve(TP.getType()));
1311   if (!TP.getName().empty())
1312     addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1315 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1316 /// DITemplateValueParameter.
1317 void
1318 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1319                                               DITemplateValueParameter VP) {
1320   DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1322   // Add the type if there is one, template template and template parameter
1323   // packs will not have a type.
1324   if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1325     addType(ParamDIE, resolve(VP.getType()));
1326   if (!VP.getName().empty())
1327     addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1328   if (Value *Val = VP.getValue()) {
1329     if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1330       addConstantValue(ParamDIE, CI, resolve(VP.getType()));
1331     else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1332       // For declaration non-type template parameters (such as global values and
1333       // functions)
1334       DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1335       addOpAddress(*Loc, Asm->getSymbol(GV));
1336       // Emit DW_OP_stack_value to use the address as the immediate value of the
1337       // parameter, rather than a pointer to it.
1338       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1339       addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1340     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1341       assert(isa<MDString>(Val));
1342       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1343                 cast<MDString>(Val)->getString());
1344     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1345       assert(isa<MDNode>(Val));
1346       DIArray A(cast<MDNode>(Val));
1347       addTemplateParams(ParamDIE, A);
1348     }
1349   }
1352 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1353 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1354   // Construct the context before querying for the existence of the DIE in case
1355   // such construction creates the DIE.
1356   DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1358   if (DIE *NDie = getDIE(NS))
1359     return NDie;
1360   DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1362   if (!NS.getName().empty()) {
1363     addString(NDie, dwarf::DW_AT_name, NS.getName());
1364     DD->addAccelNamespace(NS.getName(), NDie);
1365     addGlobalName(NS.getName(), NDie, NS.getContext());
1366   } else
1367     DD->addAccelNamespace("(anonymous namespace)", NDie);
1368   addSourceLine(NDie, NS);
1369   return &NDie;
1372 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1373 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1374   // Construct the context before querying for the existence of the DIE in case
1375   // such construction creates the DIE (as is the case for member function
1376   // declarations).
1377   DIE *ContextDIE = getOrCreateContextDIE(resolve(SP.getContext()));
1379   if (DIE *SPDie = getDIE(SP))
1380     return SPDie;
1382   if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1383     // Add subprogram definitions to the CU die directly.
1384     ContextDIE = &getUnitDie();
1385     // Build the decl now to ensure it preceeds the definition.
1386     getOrCreateSubprogramDIE(SPDecl);
1387   }
1389   // DW_TAG_inlined_subroutine may refer to this DIE.
1390   DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1392   // Abort here and fill this in later, depending on whether or not this
1393   // subprogram turns out to have inlined instances or not.
1394   if (SP.isDefinition())
1395     return &SPDie;
1397   applySubprogramAttributes(SP, SPDie);
1398   return &SPDie;
1401 void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie) {
1402   DIE *DeclDie = nullptr;
1403   StringRef DeclLinkageName;
1404   if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1405     DeclDie = getDIE(SPDecl);
1406     assert(DeclDie);
1407     DeclLinkageName = SPDecl.getLinkageName();
1408   }
1410   // Add function template parameters.
1411   addTemplateParams(SPDie, SP.getTemplateParams());
1413   // Add the linkage name if we have one and it isn't in the Decl.
1414   StringRef LinkageName = SP.getLinkageName();
1415   assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1416           LinkageName == DeclLinkageName) &&
1417          "decl has a linkage name and it is different");
1418   if (!LinkageName.empty() && DeclLinkageName.empty())
1419     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1420               GlobalValue::getRealLinkageName(LinkageName));
1422   if (DeclDie) {
1423     // Refer to the function declaration where all the other attributes will be
1424     // found.
1425     addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1426     return;
1427   }
1429   // Constructors and operators for anonymous aggregates do not have names.
1430   if (!SP.getName().empty())
1431     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1433   addSourceLine(SPDie, SP);
1435   // Add the prototype if we have a prototype and we have a C like
1436   // language.
1437   uint16_t Language = getLanguage();
1438   if (SP.isPrototyped() &&
1439       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1440        Language == dwarf::DW_LANG_ObjC))
1441     addFlag(SPDie, dwarf::DW_AT_prototyped);
1443   DICompositeType SPTy = SP.getType();
1444   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1445          "the type of a subprogram should be a subroutine");
1447   DIArray Args = SPTy.getTypeArray();
1448   // Add a return type. If this is a type like a C/C++ void type we don't add a
1449   // return type.
1450   if (Args.getElement(0))
1451     addType(SPDie, DIType(Args.getElement(0)));
1453   unsigned VK = SP.getVirtuality();
1454   if (VK) {
1455     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1456     DIELoc *Block = getDIELoc();
1457     addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1458     addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1459     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1460     ContainingTypeMap.insert(
1461         std::make_pair(&SPDie, resolve(SP.getContainingType())));
1462   }
1464   if (!SP.isDefinition()) {
1465     addFlag(SPDie, dwarf::DW_AT_declaration);
1467     // Add arguments. Do not add arguments for subprogram definition. They will
1468     // be handled while processing variables.
1469     constructSubprogramArguments(SPDie, Args);
1470   }
1472   if (SP.isArtificial())
1473     addFlag(SPDie, dwarf::DW_AT_artificial);
1475   if (!SP.isLocalToUnit())
1476     addFlag(SPDie, dwarf::DW_AT_external);
1478   if (SP.isOptimized())
1479     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1481   if (unsigned isa = Asm->getISAEncoding()) {
1482     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1483   }
1485   if (SP.isLValueReference())
1486     addFlag(SPDie, dwarf::DW_AT_reference);
1488   if (SP.isRValueReference())
1489     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1491   if (SP.isProtected())
1492     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1493             dwarf::DW_ACCESS_protected);
1494   else if (SP.isPrivate())
1495     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1496             dwarf::DW_ACCESS_private);
1497   else
1498     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1499             dwarf::DW_ACCESS_public);
1501   if (SP.isExplicit())
1502     addFlag(SPDie, dwarf::DW_AT_explicit);
1505 // Return const expression if value is a GEP to access merged global
1506 // constant. e.g.
1507 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1508 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1509   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1510   if (!CE || CE->getNumOperands() != 3 ||
1511       CE->getOpcode() != Instruction::GetElementPtr)
1512     return nullptr;
1514   // First operand points to a global struct.
1515   Value *Ptr = CE->getOperand(0);
1516   if (!isa<GlobalValue>(Ptr) ||
1517       !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1518     return nullptr;
1520   // Second operand is zero.
1521   const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1522   if (!CI || !CI->isZero())
1523     return nullptr;
1525   // Third operand is offset.
1526   if (!isa<ConstantInt>(CE->getOperand(2)))
1527     return nullptr;
1529   return CE;
1532 /// createGlobalVariableDIE - create global variable DIE.
1533 void DwarfCompileUnit::createGlobalVariableDIE(DIGlobalVariable GV) {
1534   // Check for pre-existence.
1535   if (getDIE(GV))
1536     return;
1538   assert(GV.isGlobalVariable());
1540   DIScope GVContext = GV.getContext();
1541   DIType GTy = DD->resolve(GV.getType());
1543   // If this is a static data member definition, some attributes belong
1544   // to the declaration DIE.
1545   DIE *VariableDIE = nullptr;
1546   bool IsStaticMember = false;
1547   DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1548   if (SDMDecl.Verify()) {
1549     assert(SDMDecl.isStaticMember() && "Expected static member decl");
1550     // We need the declaration DIE that is in the static member's class.
1551     VariableDIE = getOrCreateStaticMemberDIE(SDMDecl);
1552     IsStaticMember = true;
1553   }
1555   // If this is not a static data member definition, create the variable
1556   // DIE and add the initial set of attributes to it.
1557   if (!VariableDIE) {
1558     // Construct the context before querying for the existence of the DIE in
1559     // case such construction creates the DIE.
1560     DIE *ContextDIE = getOrCreateContextDIE(GVContext);
1562     // Add to map.
1563     VariableDIE = &createAndAddDIE(GV.getTag(), *ContextDIE, GV);
1565     // Add name and type.
1566     addString(*VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1567     addType(*VariableDIE, GTy);
1569     // Add scoping info.
1570     if (!GV.isLocalToUnit())
1571       addFlag(*VariableDIE, dwarf::DW_AT_external);
1573     // Add line number info.
1574     addSourceLine(*VariableDIE, GV);
1575   }
1577   // Add location.
1578   bool addToAccelTable = false;
1579   DIE *VariableSpecDIE = nullptr;
1580   bool isGlobalVariable = GV.getGlobal() != nullptr;
1581   if (isGlobalVariable) {
1582     addToAccelTable = true;
1583     DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1584     const MCSymbol *Sym = Asm->getSymbol(GV.getGlobal());
1585     if (GV.getGlobal()->isThreadLocal()) {
1586       // FIXME: Make this work with -gsplit-dwarf.
1587       unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1588       assert((PointerSize == 4 || PointerSize == 8) &&
1589              "Add support for other sizes if necessary");
1590       // Based on GCC's support for TLS:
1591       if (!DD->useSplitDwarf()) {
1592         // 1) Start with a constNu of the appropriate pointer size
1593         addUInt(*Loc, dwarf::DW_FORM_data1,
1594                 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1595         // 2) containing the (relocated) offset of the TLS variable
1596         //    within the module's TLS block.
1597         addExpr(*Loc, dwarf::DW_FORM_udata,
1598                 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym));
1599       } else {
1600         addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1601         addUInt(*Loc, dwarf::DW_FORM_udata,
1602                 DD->getAddressPool().getIndex(Sym, /* TLS */ true));
1603       }
1604       // 3) followed by a custom OP to make the debugger do a TLS lookup.
1605       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_push_tls_address);
1606     } else {
1607       DD->addArangeLabel(SymbolCU(this, Sym));
1608       addOpAddress(*Loc, Sym);
1609     }
1610     // Do not create specification DIE if context is either compile unit
1611     // or a subprogram.
1612     if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1613         !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1614       // Create specification DIE.
1615       VariableSpecDIE = &createAndAddDIE(dwarf::DW_TAG_variable, UnitDie);
1616       addDIEEntry(*VariableSpecDIE, dwarf::DW_AT_specification, *VariableDIE);
1617       addBlock(*VariableSpecDIE, dwarf::DW_AT_location, Loc);
1618       // A static member's declaration is already flagged as such.
1619       if (!SDMDecl.Verify())
1620         addFlag(*VariableDIE, dwarf::DW_AT_declaration);
1621     } else {
1622       addBlock(*VariableDIE, dwarf::DW_AT_location, Loc);
1623     }
1624     // Add the linkage name.
1625     StringRef LinkageName = GV.getLinkageName();
1626     if (!LinkageName.empty())
1627       // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1628       // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1629       // TAG_variable.
1630       addString(IsStaticMember && VariableSpecDIE ? *VariableSpecDIE
1631                                                   : *VariableDIE,
1632                 DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
1633                                            : dwarf::DW_AT_MIPS_linkage_name,
1634                 GlobalValue::getRealLinkageName(LinkageName));
1635   } else if (const ConstantInt *CI =
1636                  dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1637     // AT_const_value was added when the static member was created. To avoid
1638     // emitting AT_const_value multiple times, we only add AT_const_value when
1639     // it is not a static member.
1640     if (!IsStaticMember)
1641       addConstantValue(*VariableDIE, CI, GTy);
1642   } else if (const ConstantExpr *CE = getMergedGlobalExpr(GV->getOperand(11))) {
1643     addToAccelTable = true;
1644     // GV is a merged global.
1645     DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1646     Value *Ptr = CE->getOperand(0);
1647     MCSymbol *Sym = Asm->getSymbol(cast<GlobalValue>(Ptr));
1648     DD->addArangeLabel(SymbolCU(this, Sym));
1649     addOpAddress(*Loc, Sym);
1650     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1651     SmallVector<Value *, 3> Idx(CE->op_begin() + 1, CE->op_end());
1652     addUInt(*Loc, dwarf::DW_FORM_udata,
1653             Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1654     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1655     addBlock(*VariableDIE, dwarf::DW_AT_location, Loc);
1656   }
1658   if (addToAccelTable) {
1659     DIE &AddrDIE = VariableSpecDIE ? *VariableSpecDIE : *VariableDIE;
1660     DD->addAccelName(GV.getName(), AddrDIE);
1662     // If the linkage name is different than the name, go ahead and output
1663     // that as well into the name table.
1664     if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1665       DD->addAccelName(GV.getLinkageName(), AddrDIE);
1666   }
1668   if (!GV.isLocalToUnit())
1669     addGlobalName(GV.getName(),
1670                   VariableSpecDIE ? *VariableSpecDIE : *VariableDIE,
1671                   GV.getContext());
1674 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1675 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1676   DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1677   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1679   // The LowerBound value defines the lower bounds which is typically zero for
1680   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1681   // Count == -1 then the array is unbounded and we do not emit
1682   // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1683   // Count == 0, then the array has zero elements in which case we do not emit
1684   // an upper bound.
1685   int64_t LowerBound = SR.getLo();
1686   int64_t DefaultLowerBound = getDefaultLowerBound();
1687   int64_t Count = SR.getCount();
1689   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1690     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1692   if (Count != -1 && Count != 0)
1693     // FIXME: An unbounded array should reference the expression that defines
1694     // the array.
1695     addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, None,
1696             LowerBound + Count - 1);
1699 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1700 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1701   if (CTy.isVector())
1702     addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1704   // Emit the element type.
1705   addType(Buffer, resolve(CTy.getTypeDerivedFrom()));
1707   // Get an anonymous type for index type.
1708   // FIXME: This type should be passed down from the front end
1709   // as different languages may have different sizes for indexes.
1710   DIE *IdxTy = getIndexTyDie();
1711   if (!IdxTy) {
1712     // Construct an integer type to use for indexes.
1713     IdxTy = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1714     addString(*IdxTy, dwarf::DW_AT_name, "sizetype");
1715     addUInt(*IdxTy, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1716     addUInt(*IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1717             dwarf::DW_ATE_unsigned);
1718     setIndexTyDie(IdxTy);
1719   }
1721   // Add subranges to array type.
1722   DIArray Elements = CTy.getTypeArray();
1723   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1724     DIDescriptor Element = Elements.getElement(i);
1725     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1726       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1727   }
1730 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1731 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1732   DIArray Elements = CTy.getTypeArray();
1734   // Add enumerators to enumeration type.
1735   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1736     DIEnumerator Enum(Elements.getElement(i));
1737     if (Enum.isEnumerator()) {
1738       DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1739       StringRef Name = Enum.getName();
1740       addString(Enumerator, dwarf::DW_AT_name, Name);
1741       int64_t Value = Enum.getEnumValue();
1742       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1743               Value);
1744     }
1745   }
1746   DIType DTy = resolve(CTy.getTypeDerivedFrom());
1747   if (DTy) {
1748     addType(Buffer, DTy);
1749     addFlag(Buffer, dwarf::DW_AT_enum_class);
1750   }
1753 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1754 /// vtables.
1755 void DwarfUnit::constructContainingTypeDIEs() {
1756   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1757                                                  CE = ContainingTypeMap.end();
1758        CI != CE; ++CI) {
1759     DIE &SPDie = *CI->first;
1760     DIDescriptor D(CI->second);
1761     if (!D)
1762       continue;
1763     DIE *NDie = getDIE(D);
1764     if (!NDie)
1765       continue;
1766     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1767   }
1770 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1771 std::unique_ptr<DIE> DwarfUnit::constructVariableDIE(DbgVariable &DV,
1772                                                      bool Abstract) {
1773   auto D = constructVariableDIEImpl(DV, Abstract);
1774   DV.setDIE(*D);
1775   return D;
1778 std::unique_ptr<DIE> DwarfUnit::constructVariableDIEImpl(const DbgVariable &DV,
1779                                                          bool Abstract) {
1780   StringRef Name = DV.getName();
1782   // Define variable debug information entry.
1783   auto VariableDie = make_unique<DIE>(DV.getTag());
1784   if (DbgVariable *AbsVar = DV.getAbstractVariable())
1785     addDIEEntry(*VariableDie, dwarf::DW_AT_abstract_origin, *AbsVar->getDIE());
1786   else {
1787     if (!Name.empty())
1788       addString(*VariableDie, dwarf::DW_AT_name, Name);
1789     addSourceLine(*VariableDie, DV.getVariable());
1790     addType(*VariableDie, DV.getType());
1791     if (DV.isArtificial())
1792       addFlag(*VariableDie, dwarf::DW_AT_artificial);
1793   }
1795   if (Abstract)
1796     return VariableDie;
1798   // Add variable address.
1800   unsigned Offset = DV.getDotDebugLocOffset();
1801   if (Offset != ~0U) {
1802     addLocationList(*VariableDie, dwarf::DW_AT_location, Offset);
1803     return VariableDie;
1804   }
1806   // Check if variable is described by a DBG_VALUE instruction.
1807   if (const MachineInstr *DVInsn = DV.getMInsn()) {
1808     assert(DVInsn->getNumOperands() == 3);
1809     if (DVInsn->getOperand(0).isReg()) {
1810       const MachineOperand RegOp = DVInsn->getOperand(0);
1811       // If the second operand is an immediate, this is an indirect value.
1812       if (DVInsn->getOperand(1).isImm()) {
1813         MachineLocation Location(RegOp.getReg(),
1814                                  DVInsn->getOperand(1).getImm());
1815         addVariableAddress(DV, *VariableDie, Location);
1816       } else if (RegOp.getReg())
1817         addVariableAddress(DV, *VariableDie, MachineLocation(RegOp.getReg()));
1818     } else if (DVInsn->getOperand(0).isImm())
1819       addConstantValue(*VariableDie, DVInsn->getOperand(0), DV.getType());
1820     else if (DVInsn->getOperand(0).isFPImm())
1821       addConstantFPValue(*VariableDie, DVInsn->getOperand(0));
1822     else if (DVInsn->getOperand(0).isCImm())
1823       addConstantValue(*VariableDie, DVInsn->getOperand(0).getCImm(),
1824                        DV.getType());
1826     return VariableDie;
1827   }
1829   // .. else use frame index.
1830   int FI = DV.getFrameIndex();
1831   if (FI != ~0) {
1832     unsigned FrameReg = 0;
1833     const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1834     int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1835     MachineLocation Location(FrameReg, Offset);
1836     addVariableAddress(DV, *VariableDie, Location);
1837   }
1839   return VariableDie;
1842 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1843 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1844   DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1845   StringRef Name = DT.getName();
1846   if (!Name.empty())
1847     addString(MemberDie, dwarf::DW_AT_name, Name);
1849   addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1851   addSourceLine(MemberDie, DT);
1853   if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1855     // For C++, virtual base classes are not at fixed offset. Use following
1856     // expression to extract appropriate offset from vtable.
1857     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1859     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1860     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1861     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1862     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1863     addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1864     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1865     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1866     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1868     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1869   } else {
1870     uint64_t Size = DT.getSizeInBits();
1871     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1872     uint64_t OffsetInBytes;
1874     if (Size != FieldSize) {
1875       // Handle bitfield, assume bytes are 8 bits.
1876       addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1877       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1879       uint64_t Offset = DT.getOffsetInBits();
1880       uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1881       uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1882       uint64_t FieldOffset = (HiMark - FieldSize);
1883       Offset -= FieldOffset;
1885       // Maybe we need to work from the other end.
1886       if (Asm->getDataLayout().isLittleEndian())
1887         Offset = FieldSize - (Offset + Size);
1888       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1890       // Here DW_AT_data_member_location points to the anonymous
1891       // field that includes this bit field.
1892       OffsetInBytes = FieldOffset >> 3;
1893     } else
1894       // This is not a bitfield.
1895       OffsetInBytes = DT.getOffsetInBits() >> 3;
1897     if (DD->getDwarfVersion() <= 2) {
1898       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1899       addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1900       addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1901       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1902     } else
1903       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1904               OffsetInBytes);
1905   }
1907   if (DT.isProtected())
1908     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1909             dwarf::DW_ACCESS_protected);
1910   else if (DT.isPrivate())
1911     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1912             dwarf::DW_ACCESS_private);
1913   // Otherwise C++ member and base classes are considered public.
1914   else
1915     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1916             dwarf::DW_ACCESS_public);
1917   if (DT.isVirtual())
1918     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1919             dwarf::DW_VIRTUALITY_virtual);
1921   // Objective-C properties.
1922   if (MDNode *PNode = DT.getObjCProperty())
1923     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1924       MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1925                          PropertyDie);
1927   if (DT.isArtificial())
1928     addFlag(MemberDie, dwarf::DW_AT_artificial);
1931 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1932 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1933   if (!DT.Verify())
1934     return nullptr;
1936   // Construct the context before querying for the existence of the DIE in case
1937   // such construction creates the DIE.
1938   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1939   assert(dwarf::isType(ContextDIE->getTag()) &&
1940          "Static member should belong to a type.");
1942   if (DIE *StaticMemberDIE = getDIE(DT))
1943     return StaticMemberDIE;
1945   DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1947   DIType Ty = resolve(DT.getTypeDerivedFrom());
1949   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1950   addType(StaticMemberDIE, Ty);
1951   addSourceLine(StaticMemberDIE, DT);
1952   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1953   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1955   // FIXME: We could omit private if the parent is a class_type, and
1956   // public if the parent is something else.
1957   if (DT.isProtected())
1958     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1959             dwarf::DW_ACCESS_protected);
1960   else if (DT.isPrivate())
1961     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1962             dwarf::DW_ACCESS_private);
1963   else
1964     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1965             dwarf::DW_ACCESS_public);
1967   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1968     addConstantValue(StaticMemberDIE, CI, Ty);
1969   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1970     addConstantFPValue(StaticMemberDIE, CFP);
1972   return &StaticMemberDIE;
1975 void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const {
1976   Asm->OutStreamer.AddComment("DWARF version number");
1977   Asm->EmitInt16(DD->getDwarfVersion());
1978   Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1979   // We share one abbreviations table across all units so it's always at the
1980   // start of the section. Use a relocatable offset where needed to ensure
1981   // linking doesn't invalidate that offset.
1982   if (ASectionSym)
1983     Asm->EmitSectionOffset(ASectionSym, ASectionSym);
1984   else
1985     // Use a constant value when no symbol is provided.
1986     Asm->EmitInt32(0);
1987   Asm->OutStreamer.AddComment("Address Size (in bytes)");
1988   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1991 void DwarfUnit::addRange(RangeSpan Range) {
1992   // Only add a range for this unit if we're emitting full debug.
1993   if (getCUNode().getEmissionKind() == DIBuilder::FullDebug) {
1994     // If we have no current ranges just add the range and return, otherwise,
1995     // check the current section and CU against the previous section and CU we
1996     // emitted into and the subprogram was contained within. If these are the
1997     // same then extend our current range, otherwise add this as a new range.
1998     if (CURanges.size() == 0 ||
1999         this != DD->getPrevCU() ||
2000         Asm->getCurrentSection() != DD->getPrevSection()) {
2001       CURanges.push_back(Range);
2002       return;
2003     }
2005     assert(&(CURanges.back().getEnd()->getSection()) ==
2006                &(Range.getEnd()->getSection()) &&
2007            "We can only append to a range in the same section!");
2008     CURanges.back().setEnd(Range.getEnd());
2009   }
2012 void DwarfCompileUnit::initStmtList(MCSymbol *DwarfLineSectionSym) {
2013   // Define start line table label for each Compile Unit.
2014   MCSymbol *LineTableStartSym =
2015       Asm->OutStreamer.getDwarfLineTableSymbol(getUniqueID());
2017   stmtListIndex = UnitDie.getValues().size();
2019   // DW_AT_stmt_list is a offset of line number information for this
2020   // compile unit in debug_line section. For split dwarf this is
2021   // left in the skeleton CU and so not included.
2022   // The line table entries are not always emitted in assembly, so it
2023   // is not okay to use line_table_start here.
2024   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2025     addSectionLabel(UnitDie, dwarf::DW_AT_stmt_list, LineTableStartSym);
2026   else
2027     addSectionDelta(UnitDie, dwarf::DW_AT_stmt_list, LineTableStartSym,
2028                     DwarfLineSectionSym);
2031 void DwarfCompileUnit::applyStmtList(DIE &D) {
2032   D.addValue(dwarf::DW_AT_stmt_list,
2033              UnitDie.getAbbrev().getData()[stmtListIndex].getForm(),
2034              UnitDie.getValues()[stmtListIndex]);
2037 void DwarfTypeUnit::emitHeader(const MCSymbol *ASectionSym) const {
2038   DwarfUnit::emitHeader(ASectionSym);
2039   Asm->OutStreamer.AddComment("Type Signature");
2040   Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
2041   Asm->OutStreamer.AddComment("Type DIE Offset");
2042   // In a skeleton type unit there is no type DIE so emit a zero offset.
2043   Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
2044                                 sizeof(Ty->getOffset()));
2047 void DwarfTypeUnit::initSection(const MCSection *Section) {
2048   assert(!this->Section);
2049   this->Section = Section;
2050   // Since each type unit is contained in its own COMDAT section, the begin
2051   // label and the section label are the same. Using the begin label emission in
2052   // DwarfDebug to emit the section label as well is slightly subtle/sneaky, but
2053   // the only other alternative of lazily constructing start-of-section labels
2054   // and storing a mapping in DwarfDebug (or AsmPrinter).
2055   this->SectionSym = this->LabelBegin =
2056       Asm->GetTempSymbol(Section->getLabelBeginName(), getUniqueID());
2057   this->LabelEnd =
2058       Asm->GetTempSymbol(Section->getLabelEndName(), getUniqueID());