Debug info: (bugfix) C++ C/Dtors can be compiled to multiple functions,
[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 #define DEBUG_TYPE "dwarfdebug"
16 #include "DwarfUnit.h"
17 #include "DwarfAccelTable.h"
18 #include "DwarfDebug.h"
19 #include "llvm/ADT/APFloat.h"
20 #include "llvm/IR/Constants.h"
21 #include "llvm/IR/DIBuilder.h"
22 #include "llvm/IR/DataLayout.h"
23 #include "llvm/IR/GlobalVariable.h"
24 #include "llvm/IR/Instructions.h"
25 #include "llvm/IR/Mangler.h"
26 #include "llvm/MC/MCAsmInfo.h"
27 #include "llvm/MC/MCContext.h"
28 #include "llvm/MC/MCSection.h"
29 #include "llvm/MC/MCStreamer.h"
30 #include "llvm/Support/CommandLine.h"
31 #include "llvm/Target/TargetFrameLowering.h"
32 #include "llvm/Target/TargetLoweringObjectFile.h"
33 #include "llvm/Target/TargetMachine.h"
34 #include "llvm/Target/TargetRegisterInfo.h"
36 using namespace llvm;
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, DIE *D, DICompileUnit Node, AsmPrinter *A,
45                      DwarfDebug *DW, DwarfFile *DWU)
46     : UniqueID(UID), CUNode(Node), UnitDie(D), DebugInfoOffset(0), Asm(A),
47       DD(DW), DU(DWU), IndexTyDie(0), Section(0), Skeleton(0) {
48   DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
49 }
51 DwarfCompileUnit::DwarfCompileUnit(unsigned UID, DIE *D, DICompileUnit Node,
52                                    AsmPrinter *A, DwarfDebug *DW,
53                                    DwarfFile *DWU)
54     : DwarfUnit(UID, D, Node, A, DW, DWU) {
55   insertDIE(Node, D);
56 }
58 DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DIE *D, DwarfCompileUnit &CU,
59                              AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU,
60                              MCDwarfDwoLineTable *SplitLineTable)
61     : DwarfUnit(UID, D, CU.getCUNode(), A, DW, DWU), CU(CU),
62       SplitLineTable(SplitLineTable) {
63   if (SplitLineTable)
64     addSectionOffset(UnitDie.get(), dwarf::DW_AT_stmt_list, 0);
65 }
67 /// ~Unit - Destructor for compile unit.
68 DwarfUnit::~DwarfUnit() {
69   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
70     DIEBlocks[j]->~DIEBlock();
71   for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
72     DIELocs[j]->~DIELoc();
73 }
75 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
76 /// information entry.
77 DIEEntry *DwarfUnit::createDIEEntry(DIE *Entry) {
78   DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
79   return Value;
80 }
82 /// getDefaultLowerBound - Return the default lower bound for an array. If the
83 /// DWARF version doesn't handle the language, return -1.
84 int64_t DwarfUnit::getDefaultLowerBound() const {
85   switch (getLanguage()) {
86   default:
87     break;
89   case dwarf::DW_LANG_C89:
90   case dwarf::DW_LANG_C99:
91   case dwarf::DW_LANG_C:
92   case dwarf::DW_LANG_C_plus_plus:
93   case dwarf::DW_LANG_ObjC:
94   case dwarf::DW_LANG_ObjC_plus_plus:
95     return 0;
97   case dwarf::DW_LANG_Fortran77:
98   case dwarf::DW_LANG_Fortran90:
99   case dwarf::DW_LANG_Fortran95:
100     return 1;
102   // The languages below have valid values only if the DWARF version >= 4.
103   case dwarf::DW_LANG_Java:
104   case dwarf::DW_LANG_Python:
105   case dwarf::DW_LANG_UPC:
106   case dwarf::DW_LANG_D:
107     if (dwarf::DWARF_VERSION >= 4)
108       return 0;
109     break;
111   case dwarf::DW_LANG_Ada83:
112   case dwarf::DW_LANG_Ada95:
113   case dwarf::DW_LANG_Cobol74:
114   case dwarf::DW_LANG_Cobol85:
115   case dwarf::DW_LANG_Modula2:
116   case dwarf::DW_LANG_Pascal83:
117   case dwarf::DW_LANG_PLI:
118     if (dwarf::DWARF_VERSION >= 4)
119       return 1;
120     break;
121   }
123   return -1;
126 /// Check whether the DIE for this MDNode can be shared across CUs.
127 static bool isShareableAcrossCUs(DIDescriptor D) {
128   // When the MDNode can be part of the type system, the DIE can be shared
129   // across CUs.
130   // Combining type units and cross-CU DIE sharing is lower value (since
131   // cross-CU DIE sharing is used in LTO and removes type redundancy at that
132   // level already) but may be implementable for some value in projects
133   // building multiple independent libraries with LTO and then linking those
134   // together.
135   return (D.isType() ||
136           (D.isSubprogram() && !DISubprogram(D).isDefinition())) &&
137          !GenerateDwarfTypeUnits;
140 /// getDIE - Returns the debug information entry map slot for the
141 /// specified debug variable. We delegate the request to DwarfDebug
142 /// when the DIE for this MDNode can be shared across CUs. The mappings
143 /// will be kept in DwarfDebug for shareable DIEs.
144 DIE *DwarfUnit::getDIE(DIDescriptor D) const {
145   if (isShareableAcrossCUs(D))
146     return DD->getDIE(D);
147   return MDNodeToDieMap.lookup(D);
150 /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
151 /// when the DIE for this MDNode can be shared across CUs. The mappings
152 /// will be kept in DwarfDebug for shareable DIEs.
153 void DwarfUnit::insertDIE(DIDescriptor Desc, DIE *D) {
154   if (isShareableAcrossCUs(Desc)) {
155     DD->insertDIE(Desc, D);
156     return;
157   }
158   MDNodeToDieMap.insert(std::make_pair(Desc, D));
161 /// addFlag - Add a flag that is true.
162 void DwarfUnit::addFlag(DIE *Die, dwarf::Attribute Attribute) {
163   if (DD->getDwarfVersion() >= 4)
164     Die->addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
165   else
166     Die->addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
169 /// addUInt - Add an unsigned integer attribute data and value.
170 ///
171 void DwarfUnit::addUInt(DIE *Die, dwarf::Attribute Attribute,
172                         Optional<dwarf::Form> Form, uint64_t Integer) {
173   if (!Form)
174     Form = DIEInteger::BestForm(false, Integer);
175   DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
176                         DIEInteger(Integer);
177   Die->addValue(Attribute, *Form, Value);
180 void DwarfUnit::addUInt(DIE *Block, dwarf::Form Form, uint64_t Integer) {
181   addUInt(Block, (dwarf::Attribute)0, Form, Integer);
184 /// addSInt - Add an signed integer attribute data and value.
185 ///
186 void DwarfUnit::addSInt(DIE *Die, dwarf::Attribute Attribute,
187                         Optional<dwarf::Form> Form, int64_t Integer) {
188   if (!Form)
189     Form = DIEInteger::BestForm(true, Integer);
190   DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
191   Die->addValue(Attribute, *Form, Value);
194 void DwarfUnit::addSInt(DIELoc *Die, Optional<dwarf::Form> Form,
195                         int64_t Integer) {
196   addSInt(Die, (dwarf::Attribute)0, Form, Integer);
199 /// addString - Add a string attribute data and value. We always emit a
200 /// reference to the string pool instead of immediate strings so that DIEs have
201 /// more predictable sizes. In the case of split dwarf we emit an index
202 /// into another table which gets us the static offset into the string
203 /// table.
204 void DwarfUnit::addString(DIE *Die, dwarf::Attribute Attribute,
205                           StringRef String) {
207   if (!DD->useSplitDwarf())
208     return addLocalString(Die, Attribute, String);
210   unsigned idx = DU->getStringPoolIndex(String);
211   DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
212   DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
213   Die->addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Str);
216 /// addLocalString - Add a string attribute data and value. This is guaranteed
217 /// to be in the local string pool instead of indirected.
218 void DwarfUnit::addLocalString(DIE *Die, dwarf::Attribute Attribute,
219                                StringRef String) {
220   MCSymbol *Symb = DU->getStringPoolEntry(String);
221   DIEValue *Value;
222   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
223     Value = new (DIEValueAllocator) DIELabel(Symb);
224   else {
225     MCSymbol *StringPool = DU->getStringPoolSym();
226     Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
227   }
228   DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
229   Die->addValue(Attribute, dwarf::DW_FORM_strp, Str);
232 /// addExpr - Add a Dwarf expression attribute data and value.
233 ///
234 void DwarfUnit::addExpr(DIELoc *Die, dwarf::Form Form, const MCExpr *Expr) {
235   DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr);
236   Die->addValue((dwarf::Attribute)0, Form, Value);
239 /// addLocationList - Add a Dwarf loclistptr attribute data and value.
240 ///
241 void DwarfUnit::addLocationList(DIE *Die, dwarf::Attribute Attribute,
242                                 unsigned Index) {
243   DIEValue *Value = new (DIEValueAllocator) DIELocList(Index);
244   dwarf::Form Form = DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
245                                                 : dwarf::DW_FORM_data4;
246   Die->addValue(Attribute, Form, Value);
249 /// addLabel - Add a Dwarf label attribute data and value.
250 ///
251 void DwarfUnit::addLabel(DIE *Die, dwarf::Attribute Attribute, dwarf::Form Form,
252                          const MCSymbol *Label) {
253   DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
254   Die->addValue(Attribute, Form, Value);
257 void DwarfUnit::addLabel(DIELoc *Die, dwarf::Form Form, const MCSymbol *Label) {
258   addLabel(Die, (dwarf::Attribute)0, Form, Label);
261 /// addSectionLabel - Add a Dwarf section label attribute data and value.
262 ///
263 void DwarfUnit::addSectionLabel(DIE *Die, dwarf::Attribute Attribute,
264                                 const MCSymbol *Label) {
265   if (DD->getDwarfVersion() >= 4)
266     addLabel(Die, Attribute, dwarf::DW_FORM_sec_offset, Label);
267   else
268     addLabel(Die, Attribute, dwarf::DW_FORM_data4, Label);
271 /// addSectionOffset - Add an offset into a section attribute data and value.
272 ///
273 void DwarfUnit::addSectionOffset(DIE *Die, dwarf::Attribute Attribute,
274                                  uint64_t Integer) {
275   if (DD->getDwarfVersion() >= 4)
276     addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
277   else
278     addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
281 /// addLabelAddress - Add a dwarf label attribute data and value using
282 /// DW_FORM_addr or DW_FORM_GNU_addr_index.
283 ///
284 void DwarfCompileUnit::addLabelAddress(DIE *Die, dwarf::Attribute Attribute,
285                                        const MCSymbol *Label) {
287   if (!DD->useSplitDwarf())
288     return addLocalLabelAddress(Die, Attribute, Label);
290   if (Label)
291     DD->addArangeLabel(SymbolCU(this, Label));
293   unsigned idx = DU->getAddrPoolIndex(Label);
294   DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
295   Die->addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value);
298 void DwarfCompileUnit::addLocalLabelAddress(DIE *Die,
299                                             dwarf::Attribute Attribute,
300                                             const MCSymbol *Label) {
301   if (Label)
302     DD->addArangeLabel(SymbolCU(this, Label));
304   if (Label) {
305     DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
306     Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
307   } else {
308     DIEValue *Value = new (DIEValueAllocator) DIEInteger(0);
309     Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
310   }
313 unsigned DwarfCompileUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
314   // If we print assembly, we can't separate .file entries according to
315   // compile units. Thus all files will belong to the default compile unit.
317   // FIXME: add a better feature test than hasRawTextSupport. Even better,
318   // extend .file to support this.
319   return Asm->OutStreamer.EmitDwarfFileDirective(
320       0, DirName, FileName,
321       Asm->OutStreamer.hasRawTextSupport() ? 0 : getUniqueID());
324 unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
325   return SplitLineTable ? SplitLineTable->getFile(DirName, FileName)
326                         : getCU().getOrCreateSourceID(FileName, DirName);
329 /// addOpAddress - Add a dwarf op address data and value using the
330 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
331 ///
332 void DwarfUnit::addOpAddress(DIELoc *Die, const MCSymbol *Sym) {
333   if (!DD->useSplitDwarf()) {
334     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
335     addLabel(Die, dwarf::DW_FORM_udata, Sym);
336   } else {
337     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
338     addUInt(Die, dwarf::DW_FORM_GNU_addr_index, DU->getAddrPoolIndex(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   if (DD->getDwarfVersion() >= 4)
348     Die->addValue(Attribute, dwarf::DW_FORM_sec_offset, Value);
349   else
350     Die->addValue(Attribute, dwarf::DW_FORM_data4, Value);
353 void DwarfUnit::addLabelDelta(DIE *Die, dwarf::Attribute Attribute,
354                               const MCSymbol *Hi, const MCSymbol *Lo) {
355   DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
356   Die->addValue(Attribute, dwarf::DW_FORM_data4, Value);
359 /// addDIEEntry - Add a DIE attribute data and value.
360 ///
361 void DwarfUnit::addDIEEntry(DIE *Die, dwarf::Attribute Attribute, DIE *Entry) {
362   addDIEEntry(Die, Attribute, createDIEEntry(Entry));
365 void DwarfUnit::addDIETypeSignature(DIE *Die, const DwarfTypeUnit &Type) {
366   Die->addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
367                 new (DIEValueAllocator) DIETypeSignature(Type));
370 void DwarfUnit::addDIEEntry(DIE *Die, dwarf::Attribute Attribute,
371                             DIEEntry *Entry) {
372   const DIE *DieCU = Die->getUnitOrNull();
373   const DIE *EntryCU = Entry->getEntry()->getUnitOrNull();
374   if (!DieCU)
375     // We assume that Die belongs to this CU, if it is not linked to any CU yet.
376     DieCU = getUnitDie();
377   if (!EntryCU)
378     EntryCU = getUnitDie();
379   Die->addValue(Attribute, EntryCU == DieCU ? dwarf::DW_FORM_ref4
380                                             : dwarf::DW_FORM_ref_addr,
381                 Entry);
384 /// Create a DIE with the given Tag, add the DIE to its parent, and
385 /// call insertDIE if MD is not null.
386 DIE *DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) {
387   DIE *Die = new DIE(Tag);
388   Parent.addChild(Die);
389   if (N)
390     insertDIE(N, Die);
391   return Die;
394 /// addBlock - Add block data.
395 ///
396 void DwarfUnit::addBlock(DIE *Die, dwarf::Attribute Attribute, DIELoc *Loc) {
397   Loc->ComputeSize(Asm);
398   DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
399   Die->addValue(Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
402 void DwarfUnit::addBlock(DIE *Die, dwarf::Attribute Attribute,
403                          DIEBlock *Block) {
404   Block->ComputeSize(Asm);
405   DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
406   Die->addValue(Attribute, Block->BestForm(), Block);
409 /// addSourceLine - Add location information to specified debug information
410 /// entry.
411 void DwarfUnit::addSourceLine(DIE *Die, unsigned Line, StringRef File,
412                               StringRef Directory) {
413   if (Line == 0)
414     return;
416   unsigned FileID = getOrCreateSourceID(File, Directory);
417   assert(FileID && "Invalid file id");
418   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
419   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
422 /// addSourceLine - Add location information to specified debug information
423 /// entry.
424 void DwarfUnit::addSourceLine(DIE *Die, DIVariable V) {
425   assert(V.isVariable());
427   addSourceLine(Die, V.getLineNumber(), V.getContext().getFilename(),
428                 V.getContext().getDirectory());
431 /// addSourceLine - Add location information to specified debug information
432 /// entry.
433 void DwarfUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
434   assert(G.isGlobalVariable());
436   addSourceLine(Die, G.getLineNumber(), G.getFilename(), G.getDirectory());
439 /// addSourceLine - Add location information to specified debug information
440 /// entry.
441 void DwarfUnit::addSourceLine(DIE *Die, DISubprogram SP) {
442   assert(SP.isSubprogram());
444   addSourceLine(Die, SP.getLineNumber(), SP.getFilename(), SP.getDirectory());
447 /// addSourceLine - Add location information to specified debug information
448 /// entry.
449 void DwarfUnit::addSourceLine(DIE *Die, DIType Ty) {
450   assert(Ty.isType());
452   addSourceLine(Die, Ty.getLineNumber(), Ty.getFilename(), Ty.getDirectory());
455 /// addSourceLine - Add location information to specified debug information
456 /// entry.
457 void DwarfUnit::addSourceLine(DIE *Die, DIObjCProperty Ty) {
458   assert(Ty.isObjCProperty());
460   DIFile File = Ty.getFile();
461   addSourceLine(Die, Ty.getLineNumber(), File.getFilename(),
462                 File.getDirectory());
465 /// addSourceLine - Add location information to specified debug information
466 /// entry.
467 void DwarfUnit::addSourceLine(DIE *Die, DINameSpace NS) {
468   assert(NS.Verify());
470   addSourceLine(Die, NS.getLineNumber(), NS.getFilename(), NS.getDirectory());
473 /// addVariableAddress - Add DW_AT_location attribute for a
474 /// DbgVariable based on provided MachineLocation.
475 void DwarfUnit::addVariableAddress(const DbgVariable &DV, DIE *Die,
476                                    MachineLocation Location) {
477   if (DV.variableHasComplexAddress())
478     addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
479   else if (DV.isBlockByrefVariable())
480     addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
481   else
482     addAddress(Die, dwarf::DW_AT_location, Location,
483                DV.getVariable().isIndirect());
486 /// addRegisterOp - Add register operand.
487 void DwarfUnit::addRegisterOp(DIELoc *TheDie, unsigned Reg) {
488   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
489   int DWReg = RI->getDwarfRegNum(Reg, false);
490   bool isSubRegister = DWReg < 0;
492   unsigned Idx = 0;
494   // Go up the super-register chain until we hit a valid dwarf register number.
495   for (MCSuperRegIterator SR(Reg, RI); SR.isValid() && DWReg < 0; ++SR) {
496     DWReg = RI->getDwarfRegNum(*SR, false);
497     if (DWReg >= 0)
498       Idx = RI->getSubRegIndex(*SR, Reg);
499   }
501   if (DWReg < 0) {
502     DEBUG(dbgs() << "Invalid Dwarf register number.\n");
503     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_nop);
504     return;
505   }
507   // Emit register
508   if (DWReg < 32)
509     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
510   else {
511     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
512     addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
513   }
515   // Emit Mask
516   if (isSubRegister) {
517     unsigned Size = RI->getSubRegIdxSize(Idx);
518     unsigned Offset = RI->getSubRegIdxOffset(Idx);
519     if (Offset > 0) {
520       addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bit_piece);
521       addUInt(TheDie, dwarf::DW_FORM_data1, Size);
522       addUInt(TheDie, dwarf::DW_FORM_data1, Offset);
523     } else {
524       unsigned ByteSize = Size / 8; // Assuming 8 bits per byte.
525       addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_piece);
526       addUInt(TheDie, dwarf::DW_FORM_data1, ByteSize);
527     }
528   }
531 /// addRegisterOffset - Add register offset.
532 void DwarfUnit::addRegisterOffset(DIELoc *TheDie, unsigned Reg,
533                                   int64_t Offset) {
534   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
535   unsigned DWReg = RI->getDwarfRegNum(Reg, false);
536   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
537   if (Reg == TRI->getFrameRegister(*Asm->MF))
538     // If variable offset is based in frame register then use fbreg.
539     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
540   else if (DWReg < 32)
541     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
542   else {
543     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
544     addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
545   }
546   addSInt(TheDie, dwarf::DW_FORM_sdata, Offset);
549 /// addAddress - Add an address attribute to a die based on the location
550 /// provided.
551 void DwarfUnit::addAddress(DIE *Die, dwarf::Attribute Attribute,
552                            const MachineLocation &Location, bool Indirect) {
553   DIELoc *Loc = new (DIEValueAllocator) DIELoc();
555   if (Location.isReg() && !Indirect)
556     addRegisterOp(Loc, Location.getReg());
557   else {
558     addRegisterOffset(Loc, Location.getReg(), Location.getOffset());
559     if (Indirect && !Location.isReg()) {
560       addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
561     }
562   }
564   // Now attach the location information to the DIE.
565   addBlock(Die, Attribute, Loc);
568 /// addComplexAddress - Start with the address based on the location provided,
569 /// and generate the DWARF information necessary to find the actual variable
570 /// given the extra address information encoded in the DbgVariable, starting
571 /// from the starting location.  Add the DWARF information to the die.
572 ///
573 void DwarfUnit::addComplexAddress(const DbgVariable &DV, DIE *Die,
574                                   dwarf::Attribute Attribute,
575                                   const MachineLocation &Location) {
576   DIELoc *Loc = new (DIEValueAllocator) DIELoc();
577   unsigned N = DV.getNumAddrElements();
578   unsigned i = 0;
579   if (Location.isReg()) {
580     if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
581       // If first address element is OpPlus then emit
582       // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
583       addRegisterOffset(Loc, Location.getReg(), DV.getAddrElement(1));
584       i = 2;
585     } else
586       addRegisterOp(Loc, Location.getReg());
587   } else
588     addRegisterOffset(Loc, Location.getReg(), Location.getOffset());
590   for (; i < N; ++i) {
591     uint64_t Element = DV.getAddrElement(i);
592     if (Element == DIBuilder::OpPlus) {
593       addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
594       addUInt(Loc, dwarf::DW_FORM_udata, DV.getAddrElement(++i));
595     } else if (Element == DIBuilder::OpDeref) {
596       if (!Location.isReg())
597         addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
598     } else
599       llvm_unreachable("unknown DIBuilder Opcode");
600   }
602   // Now attach the location information to the DIE.
603   addBlock(Die, Attribute, Loc);
606 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
607    VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
608    gives the variable VarName either the struct, or a pointer to the struct, as
609    its type.  This is necessary for various behind-the-scenes things the
610    compiler needs to do with by-reference variables in Blocks.
612    However, as far as the original *programmer* is concerned, the variable
613    should still have type 'SomeType', as originally declared.
615    The function getBlockByrefType dives into the __Block_byref_x_VarName
616    struct to find the original type of the variable, which is then assigned to
617    the variable's Debug Information Entry as its real type.  So far, so good.
618    However now the debugger will expect the variable VarName to have the type
619    SomeType.  So we need the location attribute for the variable to be an
620    expression that explains to the debugger how to navigate through the
621    pointers and struct to find the actual variable of type SomeType.
623    The following function does just that.  We start by getting
624    the "normal" location for the variable. This will be the location
625    of either the struct __Block_byref_x_VarName or the pointer to the
626    struct __Block_byref_x_VarName.
628    The struct will look something like:
630    struct __Block_byref_x_VarName {
631      ... <various fields>
632      struct __Block_byref_x_VarName *forwarding;
633      ... <various other fields>
634      SomeType VarName;
635      ... <maybe more fields>
636    };
638    If we are given the struct directly (as our starting point) we
639    need to tell the debugger to:
641    1).  Add the offset of the forwarding field.
643    2).  Follow that pointer to get the real __Block_byref_x_VarName
644    struct to use (the real one may have been copied onto the heap).
646    3).  Add the offset for the field VarName, to find the actual variable.
648    If we started with a pointer to the struct, then we need to
649    dereference that pointer first, before the other steps.
650    Translating this into DWARF ops, we will need to append the following
651    to the current location description for the variable:
653    DW_OP_deref                    -- optional, if we start with a pointer
654    DW_OP_plus_uconst <forward_fld_offset>
655    DW_OP_deref
656    DW_OP_plus_uconst <varName_fld_offset>
658    That is what this function does.  */
660 /// addBlockByrefAddress - Start with the address based on the location
661 /// provided, and generate the DWARF information necessary to find the
662 /// actual Block variable (navigating the Block struct) based on the
663 /// starting location.  Add the DWARF information to the die.  For
664 /// more information, read large comment just above here.
665 ///
666 void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE *Die,
667                                      dwarf::Attribute Attribute,
668                                      const MachineLocation &Location) {
669   DIType Ty = DV.getType();
670   DIType TmpTy = Ty;
671   uint16_t Tag = Ty.getTag();
672   bool isPointer = false;
674   StringRef varName = DV.getName();
676   if (Tag == dwarf::DW_TAG_pointer_type) {
677     DIDerivedType DTy(Ty);
678     TmpTy = resolve(DTy.getTypeDerivedFrom());
679     isPointer = true;
680   }
682   DICompositeType blockStruct(TmpTy);
684   // Find the __forwarding field and the variable field in the __Block_byref
685   // struct.
686   DIArray Fields = blockStruct.getTypeArray();
687   DIDerivedType varField;
688   DIDerivedType forwardingField;
690   for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
691     DIDerivedType DT(Fields.getElement(i));
692     StringRef fieldName = DT.getName();
693     if (fieldName == "__forwarding")
694       forwardingField = DT;
695     else if (fieldName == varName)
696       varField = DT;
697   }
699   // Get the offsets for the forwarding field and the variable field.
700   unsigned forwardingFieldOffset = forwardingField.getOffsetInBits() >> 3;
701   unsigned varFieldOffset = varField.getOffsetInBits() >> 2;
703   // Decode the original location, and use that as the start of the byref
704   // variable's location.
705   DIELoc *Loc = new (DIEValueAllocator) DIELoc();
707   if (Location.isReg())
708     addRegisterOp(Loc, Location.getReg());
709   else
710     addRegisterOffset(Loc, Location.getReg(), Location.getOffset());
712   // If we started with a pointer to the __Block_byref... struct, then
713   // the first thing we need to do is dereference the pointer (DW_OP_deref).
714   if (isPointer)
715     addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
717   // Next add the offset for the '__forwarding' field:
718   // DW_OP_plus_uconst ForwardingFieldOffset.  Note there's no point in
719   // adding the offset if it's 0.
720   if (forwardingFieldOffset > 0) {
721     addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
722     addUInt(Loc, dwarf::DW_FORM_udata, forwardingFieldOffset);
723   }
725   // Now dereference the __forwarding field to get to the real __Block_byref
726   // struct:  DW_OP_deref.
727   addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
729   // Now that we've got the real __Block_byref... struct, add the offset
730   // for the variable's field to get to the location of the actual variable:
731   // DW_OP_plus_uconst varFieldOffset.  Again, don't add if it's 0.
732   if (varFieldOffset > 0) {
733     addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
734     addUInt(Loc, dwarf::DW_FORM_udata, varFieldOffset);
735   }
737   // Now attach the location information to the DIE.
738   addBlock(Die, Attribute, Loc);
741 /// isTypeSigned - Return true if the type is signed.
742 static bool isTypeSigned(DwarfDebug *DD, DIType Ty, int *SizeInBits) {
743   if (Ty.isDerivedType())
744     return isTypeSigned(DD, DD->resolve(DIDerivedType(Ty).getTypeDerivedFrom()),
745                         SizeInBits);
746   if (Ty.isBasicType())
747     if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed ||
748         DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
749       *SizeInBits = Ty.getSizeInBits();
750       return true;
751     }
752   return false;
755 /// Return true if type encoding is unsigned.
756 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
757   DIDerivedType DTy(Ty);
758   if (DTy.isDerivedType())
759     return isUnsignedDIType(DD, DD->resolve(DTy.getTypeDerivedFrom()));
761   DIBasicType BTy(Ty);
762   if (BTy.isBasicType()) {
763     unsigned Encoding = BTy.getEncoding();
764     if (Encoding == dwarf::DW_ATE_unsigned ||
765         Encoding == dwarf::DW_ATE_unsigned_char ||
766         Encoding == dwarf::DW_ATE_boolean)
767       return true;
768   }
769   return false;
772 /// If this type is derived from a base type then return base type size.
773 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
774   unsigned Tag = Ty.getTag();
776   if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
777       Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
778       Tag != dwarf::DW_TAG_restrict_type)
779     return Ty.getSizeInBits();
781   DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
783   // If this type is not derived from any type or the type is a declaration then
784   // take conservative approach.
785   if (!BaseType.isValid() || BaseType.isForwardDecl())
786     return Ty.getSizeInBits();
788   // If this is a derived type, go ahead and get the base type, unless it's a
789   // reference then it's just the size of the field. Pointer types have no need
790   // of this since they're a different type of qualification on the type.
791   if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
792       BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
793     return Ty.getSizeInBits();
795   if (BaseType.isDerivedType())
796     return getBaseTypeSize(DD, DIDerivedType(BaseType));
798   return BaseType.getSizeInBits();
801 /// addConstantValue - Add constant value entry in variable DIE.
802 void DwarfUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
803                                  DIType Ty) {
804   // FIXME: This is a bit conservative/simple - it emits negative values at
805   // their maximum bit width which is a bit unfortunate (& doesn't prefer
806   // udata/sdata over dataN as suggested by the DWARF spec)
807   assert(MO.isImm() && "Invalid machine operand!");
808   int SizeInBits = -1;
809   bool SignedConstant = isTypeSigned(DD, Ty, &SizeInBits);
810   dwarf::Form Form;
812   // If we're a signed constant definitely use sdata.
813   if (SignedConstant) {
814     addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, MO.getImm());
815     return;
816   }
818   // Else use data for now unless it's larger than we can deal with.
819   switch (SizeInBits) {
820   case 8:
821     Form = dwarf::DW_FORM_data1;
822     break;
823   case 16:
824     Form = dwarf::DW_FORM_data2;
825     break;
826   case 32:
827     Form = dwarf::DW_FORM_data4;
828     break;
829   case 64:
830     Form = dwarf::DW_FORM_data8;
831     break;
832   default:
833     Form = dwarf::DW_FORM_udata;
834     addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
835     return;
836   }
837   addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
840 /// addConstantFPValue - Add constant value entry in variable DIE.
841 void DwarfUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
842   assert(MO.isFPImm() && "Invalid machine operand!");
843   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
844   APFloat FPImm = MO.getFPImm()->getValueAPF();
846   // Get the raw data form of the floating point.
847   const APInt FltVal = FPImm.bitcastToAPInt();
848   const char *FltPtr = (const char *)FltVal.getRawData();
850   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
851   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
852   int Incr = (LittleEndian ? 1 : -1);
853   int Start = (LittleEndian ? 0 : NumBytes - 1);
854   int Stop = (LittleEndian ? NumBytes : -1);
856   // Output the constant to DWARF one byte at a time.
857   for (; Start != Stop; Start += Incr)
858     addUInt(Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
860   addBlock(Die, dwarf::DW_AT_const_value, Block);
863 /// addConstantFPValue - Add constant value entry in variable DIE.
864 void DwarfUnit::addConstantFPValue(DIE *Die, const ConstantFP *CFP) {
865   // Pass this down to addConstantValue as an unsigned bag of bits.
866   addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
869 /// addConstantValue - Add constant value entry in variable DIE.
870 void DwarfUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
871                                  bool Unsigned) {
872   addConstantValue(Die, CI->getValue(), Unsigned);
875 // addConstantValue - Add constant value entry in variable DIE.
876 void DwarfUnit::addConstantValue(DIE *Die, const APInt &Val, bool Unsigned) {
877   unsigned CIBitWidth = Val.getBitWidth();
878   if (CIBitWidth <= 64) {
879     // If we're a signed constant definitely use sdata.
880     if (!Unsigned) {
881       addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
882               Val.getSExtValue());
883       return;
884     }
886     // Else use data for now unless it's larger than we can deal with.
887     dwarf::Form Form;
888     switch (CIBitWidth) {
889     case 8:
890       Form = dwarf::DW_FORM_data1;
891       break;
892     case 16:
893       Form = dwarf::DW_FORM_data2;
894       break;
895     case 32:
896       Form = dwarf::DW_FORM_data4;
897       break;
898     case 64:
899       Form = dwarf::DW_FORM_data8;
900       break;
901     default:
902       addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
903               Val.getZExtValue());
904       return;
905     }
906     addUInt(Die, dwarf::DW_AT_const_value, Form, Val.getZExtValue());
907     return;
908   }
910   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
912   // Get the raw data form of the large APInt.
913   const uint64_t *Ptr64 = Val.getRawData();
915   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
916   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
918   // Output the constant to DWARF one byte at a time.
919   for (int i = 0; i < NumBytes; i++) {
920     uint8_t c;
921     if (LittleEndian)
922       c = Ptr64[i / 8] >> (8 * (i & 7));
923     else
924       c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
925     addUInt(Block, dwarf::DW_FORM_data1, c);
926   }
928   addBlock(Die, dwarf::DW_AT_const_value, Block);
931 /// addTemplateParams - Add template parameters into buffer.
932 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
933   // Add template parameters.
934   for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
935     DIDescriptor Element = TParams.getElement(i);
936     if (Element.isTemplateTypeParameter())
937       constructTemplateTypeParameterDIE(Buffer,
938                                         DITemplateTypeParameter(Element));
939     else if (Element.isTemplateValueParameter())
940       constructTemplateValueParameterDIE(Buffer,
941                                          DITemplateValueParameter(Element));
942   }
945 /// getOrCreateContextDIE - Get context owner's DIE.
946 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
947   if (!Context || Context.isFile())
948     return getUnitDie();
949   if (Context.isType())
950     return getOrCreateTypeDIE(DIType(Context));
951   if (Context.isNameSpace())
952     return getOrCreateNameSpace(DINameSpace(Context));
953   if (Context.isSubprogram())
954     return getOrCreateSubprogramDIE(DISubprogram(Context));
955   return getDIE(Context);
958 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
959   DIScope Context = resolve(Ty.getContext());
960   DIE *ContextDIE = getOrCreateContextDIE(Context);
962   DIE *TyDIE = getDIE(Ty);
963   if (TyDIE)
964     return TyDIE;
966   // Create new type.
967   TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
969   constructTypeDIE(*TyDIE, Ty);
971   updateAcceleratorTables(Context, Ty, TyDIE);
972   return TyDIE;
975 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
976 /// given DIType.
977 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
978   if (!TyNode)
979     return NULL;
981   DIType Ty(TyNode);
982   assert(Ty.isType());
983   assert(Ty == resolve(Ty.getRef()) &&
984          "type was not uniqued, possible ODR violation.");
986   // Construct the context before querying for the existence of the DIE in case
987   // such construction creates the DIE.
988   DIScope Context = resolve(Ty.getContext());
989   DIE *ContextDIE = getOrCreateContextDIE(Context);
990   assert(ContextDIE);
992   DIE *TyDIE = getDIE(Ty);
993   if (TyDIE)
994     return TyDIE;
996   // Create new type.
997   TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
999   updateAcceleratorTables(Context, Ty, TyDIE);
1001   if (Ty.isBasicType())
1002     constructTypeDIE(*TyDIE, DIBasicType(Ty));
1003   else if (Ty.isCompositeType()) {
1004     DICompositeType CTy(Ty);
1005     if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
1006       if (MDString *TypeId = CTy.getIdentifier()) {
1007         DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
1008         // Skip updating the accelerator tables since this is not the full type.
1009         return TyDIE;
1010       }
1011     constructTypeDIE(*TyDIE, CTy);
1012   } else {
1013     assert(Ty.isDerivedType() && "Unknown kind of DIType");
1014     constructTypeDIE(*TyDIE, DIDerivedType(Ty));
1015   }
1017   return TyDIE;
1020 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
1021                                         const DIE *TyDIE) {
1022   if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
1023     bool IsImplementation = 0;
1024     if (Ty.isCompositeType()) {
1025       DICompositeType CT(Ty);
1026       // A runtime language of 0 actually means C/C++ and that any
1027       // non-negative value is some version of Objective-C/C++.
1028       IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
1029     }
1030     unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
1031     addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
1033     if ((!Context || Context.isCompileUnit() || Context.isFile() ||
1034          Context.isNameSpace()) &&
1035         getCUNode().getEmissionKind() != DIBuilder::LineTablesOnly)
1036       GlobalTypes[getParentContextString(Context) + Ty.getName().str()] = TyDIE;
1037   }
1040 /// addType - Add a new type attribute to the specified entity.
1041 void DwarfUnit::addType(DIE *Entity, DIType Ty, dwarf::Attribute Attribute) {
1042   assert(Ty && "Trying to add a type that doesn't exist?");
1044   // Check for pre-existence.
1045   DIEEntry *Entry = getDIEEntry(Ty);
1046   // If it exists then use the existing value.
1047   if (Entry) {
1048     addDIEEntry(Entity, Attribute, Entry);
1049     return;
1050   }
1052   // Construct type.
1053   DIE *Buffer = getOrCreateTypeDIE(Ty);
1055   // Set up proxy.
1056   Entry = createDIEEntry(Buffer);
1057   insertDIEEntry(Ty, Entry);
1058   addDIEEntry(Entity, Attribute, Entry);
1061 // Accelerator table mutators - add each name along with its companion
1062 // DIE to the proper table while ensuring that the name that we're going
1063 // to reference is in the string table. We do this since the names we
1064 // add may not only be identical to the names in the DIE.
1065 void DwarfUnit::addAccelName(StringRef Name, const DIE *Die) {
1066   if (!DD->useDwarfAccelTables())
1067     return;
1068   DU->getStringPoolEntry(Name);
1069   std::vector<const DIE *> &DIEs = AccelNames[Name];
1070   DIEs.push_back(Die);
1073 void DwarfUnit::addAccelObjC(StringRef Name, const DIE *Die) {
1074   if (!DD->useDwarfAccelTables())
1075     return;
1076   DU->getStringPoolEntry(Name);
1077   std::vector<const DIE *> &DIEs = AccelObjC[Name];
1078   DIEs.push_back(Die);
1081 void DwarfUnit::addAccelNamespace(StringRef Name, const DIE *Die) {
1082   if (!DD->useDwarfAccelTables())
1083     return;
1084   DU->getStringPoolEntry(Name);
1085   std::vector<const DIE *> &DIEs = AccelNamespace[Name];
1086   DIEs.push_back(Die);
1089 void DwarfUnit::addAccelType(StringRef Name,
1090                              std::pair<const DIE *, unsigned> Die) {
1091   if (!DD->useDwarfAccelTables())
1092     return;
1093   DU->getStringPoolEntry(Name);
1094   std::vector<std::pair<const DIE *, unsigned> > &DIEs = AccelTypes[Name];
1095   DIEs.push_back(Die);
1098 /// addGlobalName - Add a new global name to the compile unit.
1099 void DwarfUnit::addGlobalName(StringRef Name, DIE *Die, DIScope Context) {
1100   if (getCUNode().getEmissionKind() == DIBuilder::LineTablesOnly)
1101     return;
1102   std::string FullName = getParentContextString(Context) + Name.str();
1103   GlobalNames[FullName] = Die;
1106 /// getParentContextString - Walks the metadata parent chain in a language
1107 /// specific manner (using the compile unit language) and returns
1108 /// it as a string. This is done at the metadata level because DIEs may
1109 /// not currently have been added to the parent context and walking the
1110 /// DIEs looking for names is more expensive than walking the metadata.
1111 std::string DwarfUnit::getParentContextString(DIScope Context) const {
1112   if (!Context)
1113     return "";
1115   // FIXME: Decide whether to implement this for non-C++ languages.
1116   if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
1117     return "";
1119   std::string CS;
1120   SmallVector<DIScope, 1> Parents;
1121   while (!Context.isCompileUnit()) {
1122     Parents.push_back(Context);
1123     if (Context.getContext())
1124       Context = resolve(Context.getContext());
1125     else
1126       // Structure, etc types will have a NULL context if they're at the top
1127       // level.
1128       break;
1129   }
1131   // Reverse iterate over our list to go from the outermost construct to the
1132   // innermost.
1133   for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
1134                                                   E = Parents.rend();
1135        I != E; ++I) {
1136     DIScope Ctx = *I;
1137     StringRef Name = Ctx.getName();
1138     if (!Name.empty()) {
1139       CS += Name;
1140       CS += "::";
1141     }
1142   }
1143   return CS;
1146 /// constructTypeDIE - Construct basic type die from DIBasicType.
1147 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
1148   // Get core information.
1149   StringRef Name = BTy.getName();
1150   // Add name if not anonymous or intermediate type.
1151   if (!Name.empty())
1152     addString(&Buffer, dwarf::DW_AT_name, Name);
1154   // An unspecified type only has a name attribute.
1155   if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
1156     return;
1158   addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1159           BTy.getEncoding());
1161   uint64_t Size = BTy.getSizeInBits() >> 3;
1162   addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1165 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1166 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1167   // Get core information.
1168   StringRef Name = DTy.getName();
1169   uint64_t Size = DTy.getSizeInBits() >> 3;
1170   uint16_t Tag = Buffer.getTag();
1172   // Map to main type, void will not have a type.
1173   DIType FromTy = resolve(DTy.getTypeDerivedFrom());
1174   if (FromTy)
1175     addType(&Buffer, FromTy);
1177   // Add name if not anonymous or intermediate type.
1178   if (!Name.empty())
1179     addString(&Buffer, dwarf::DW_AT_name, Name);
1181   // Add size if non-zero (derived types might be zero-sized.)
1182   if (Size && Tag != dwarf::DW_TAG_pointer_type)
1183     addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1185   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
1186     addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1187                 getOrCreateTypeDIE(resolve(DTy.getClassType())));
1188   // Add source line info if available and TyDesc is not a forward declaration.
1189   if (!DTy.isForwardDecl())
1190     addSourceLine(&Buffer, DTy);
1193 /// constructSubprogramArguments - Construct function argument DIEs.
1194 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DIArray Args) {
1195   for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1196     DIDescriptor Ty = Args.getElement(i);
1197     if (Ty.isUnspecifiedParameter()) {
1198       assert(i == N-1 && "Unspecified parameter must be the last argument");
1199       createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1200     } else {
1201       DIE *Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1202       addType(Arg, DIType(Ty));
1203       if (DIType(Ty).isArtificial())
1204         addFlag(Arg, dwarf::DW_AT_artificial);
1205     }
1206   }
1209 /// constructTypeDIE - Construct type DIE from DICompositeType.
1210 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1211   // Add name if not anonymous or intermediate type.
1212   StringRef Name = CTy.getName();
1214   uint64_t Size = CTy.getSizeInBits() >> 3;
1215   uint16_t Tag = Buffer.getTag();
1217   switch (Tag) {
1218   case dwarf::DW_TAG_array_type:
1219     constructArrayTypeDIE(Buffer, CTy);
1220     break;
1221   case dwarf::DW_TAG_enumeration_type:
1222     constructEnumTypeDIE(Buffer, CTy);
1223     break;
1224   case dwarf::DW_TAG_subroutine_type: {
1225     // Add return type. A void return won't have a type.
1226     DIArray Elements = CTy.getTypeArray();
1227     DIType RTy(Elements.getElement(0));
1228     if (RTy)
1229       addType(&Buffer, RTy);
1231     bool isPrototyped = true;
1232     if (Elements.getNumElements() == 2 &&
1233         Elements.getElement(1).isUnspecifiedParameter())
1234       isPrototyped = false;
1236     constructSubprogramArguments(Buffer, Elements);
1238     // Add prototype flag if we're dealing with a C language and the
1239     // function has been prototyped.
1240     uint16_t Language = getLanguage();
1241     if (isPrototyped &&
1242         (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1243          Language == dwarf::DW_LANG_ObjC))
1244       addFlag(&Buffer, dwarf::DW_AT_prototyped);
1246     if (CTy.isLValueReference())
1247       addFlag(&Buffer, dwarf::DW_AT_reference);
1249     if (CTy.isRValueReference())
1250       addFlag(&Buffer, dwarf::DW_AT_rvalue_reference);
1251   } break;
1252   case dwarf::DW_TAG_structure_type:
1253   case dwarf::DW_TAG_union_type:
1254   case dwarf::DW_TAG_class_type: {
1255     // Add elements to structure type.
1256     DIArray Elements = CTy.getTypeArray();
1257     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1258       DIDescriptor Element = Elements.getElement(i);
1259       DIE *ElemDie = NULL;
1260       if (Element.isSubprogram())
1261         ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
1262       else if (Element.isDerivedType()) {
1263         DIDerivedType DDTy(Element);
1264         if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1265           ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1266           addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1267                   dwarf::DW_AT_friend);
1268         } else if (DDTy.isStaticMember()) {
1269           getOrCreateStaticMemberDIE(DDTy);
1270         } else {
1271           constructMemberDIE(Buffer, DDTy);
1272         }
1273       } else if (Element.isObjCProperty()) {
1274         DIObjCProperty Property(Element);
1275         ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1276         StringRef PropertyName = Property.getObjCPropertyName();
1277         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1278         if (Property.getType())
1279           addType(ElemDie, Property.getType());
1280         addSourceLine(ElemDie, Property);
1281         StringRef GetterName = Property.getObjCPropertyGetterName();
1282         if (!GetterName.empty())
1283           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1284         StringRef SetterName = Property.getObjCPropertySetterName();
1285         if (!SetterName.empty())
1286           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1287         unsigned PropertyAttributes = 0;
1288         if (Property.isReadOnlyObjCProperty())
1289           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1290         if (Property.isReadWriteObjCProperty())
1291           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1292         if (Property.isAssignObjCProperty())
1293           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1294         if (Property.isRetainObjCProperty())
1295           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1296         if (Property.isCopyObjCProperty())
1297           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1298         if (Property.isNonAtomicObjCProperty())
1299           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1300         if (PropertyAttributes)
1301           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1302                   PropertyAttributes);
1304         DIEEntry *Entry = getDIEEntry(Element);
1305         if (!Entry) {
1306           Entry = createDIEEntry(ElemDie);
1307           insertDIEEntry(Element, Entry);
1308         }
1309       } else
1310         continue;
1311     }
1313     if (CTy.isAppleBlockExtension())
1314       addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
1316     DICompositeType ContainingType(resolve(CTy.getContainingType()));
1317     if (ContainingType)
1318       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1319                   getOrCreateTypeDIE(ContainingType));
1321     if (CTy.isObjcClassComplete())
1322       addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1324     // Add template parameters to a class, structure or union types.
1325     // FIXME: The support isn't in the metadata for this yet.
1326     if (Tag == dwarf::DW_TAG_class_type ||
1327         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1328       addTemplateParams(Buffer, CTy.getTemplateParams());
1330     break;
1331   }
1332   default:
1333     break;
1334   }
1336   // Add name if not anonymous or intermediate type.
1337   if (!Name.empty())
1338     addString(&Buffer, dwarf::DW_AT_name, Name);
1340   if (Tag == dwarf::DW_TAG_enumeration_type ||
1341       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1342       Tag == dwarf::DW_TAG_union_type) {
1343     // Add size if non-zero (derived types might be zero-sized.)
1344     // TODO: Do we care about size for enum forward declarations?
1345     if (Size)
1346       addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1347     else if (!CTy.isForwardDecl())
1348       // Add zero size if it is not a forward declaration.
1349       addUInt(&Buffer, dwarf::DW_AT_byte_size, None, 0);
1351     // If we're a forward decl, say so.
1352     if (CTy.isForwardDecl())
1353       addFlag(&Buffer, dwarf::DW_AT_declaration);
1355     // Add source line info if available.
1356     if (!CTy.isForwardDecl())
1357       addSourceLine(&Buffer, CTy);
1359     // No harm in adding the runtime language to the declaration.
1360     unsigned RLang = CTy.getRunTimeLang();
1361     if (RLang)
1362       addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1363               RLang);
1364   }
1367 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1368 /// DITemplateTypeParameter.
1369 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1370                                                   DITemplateTypeParameter TP) {
1371   DIE *ParamDIE =
1372       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1373   // Add the type if it exists, it could be void and therefore no type.
1374   if (TP.getType())
1375     addType(ParamDIE, resolve(TP.getType()));
1376   if (!TP.getName().empty())
1377     addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1380 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1381 /// DITemplateValueParameter.
1382 void
1383 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1384                                               DITemplateValueParameter VP) {
1385   DIE *ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1387   // Add the type if there is one, template template and template parameter
1388   // packs will not have a type.
1389   if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1390     addType(ParamDIE, resolve(VP.getType()));
1391   if (!VP.getName().empty())
1392     addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1393   if (Value *Val = VP.getValue()) {
1394     if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1395       addConstantValue(ParamDIE, CI,
1396                        isUnsignedDIType(DD, resolve(VP.getType())));
1397     else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1398       // For declaration non-type template parameters (such as global values and
1399       // functions)
1400       DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1401       addOpAddress(Loc, Asm->getSymbol(GV));
1402       // Emit DW_OP_stack_value to use the address as the immediate value of the
1403       // parameter, rather than a pointer to it.
1404       addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1405       addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1406     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1407       assert(isa<MDString>(Val));
1408       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1409                 cast<MDString>(Val)->getString());
1410     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1411       assert(isa<MDNode>(Val));
1412       DIArray A(cast<MDNode>(Val));
1413       addTemplateParams(*ParamDIE, A);
1414     }
1415   }
1418 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1419 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1420   // Construct the context before querying for the existence of the DIE in case
1421   // such construction creates the DIE.
1422   DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1424   DIE *NDie = getDIE(NS);
1425   if (NDie)
1426     return NDie;
1427   NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1429   if (!NS.getName().empty()) {
1430     addString(NDie, dwarf::DW_AT_name, NS.getName());
1431     addAccelNamespace(NS.getName(), NDie);
1432     addGlobalName(NS.getName(), NDie, NS.getContext());
1433   } else
1434     addAccelNamespace("(anonymous namespace)", NDie);
1435   addSourceLine(NDie, NS);
1436   return NDie;
1439 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1440 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1441   // Construct the context before querying for the existence of the DIE in case
1442   // such construction creates the DIE (as is the case for member function
1443   // declarations).
1444   DIScope Context = resolve(SP.getContext());
1445   DIE *ContextDIE = getOrCreateContextDIE(Context);
1447   // Unique declarations based on the ODR, where applicable.
1448   SP = DISubprogram(DD->resolve(SP.getRef()));
1449   assert(SP.Verify());
1451   DIE *SPDie = getDIE(SP);
1452   if (SPDie)
1453     return SPDie;
1455   DISubprogram SPDecl = SP.getFunctionDeclaration();
1456   if (SPDecl.isSubprogram())
1457     // Add subprogram definitions to the CU die directly.
1458     ContextDIE = UnitDie.get();
1460   // DW_TAG_inlined_subroutine may refer to this DIE.
1461   SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1463   DIE *DeclDie = NULL;
1464   if (SPDecl.isSubprogram())
1465     DeclDie = getOrCreateSubprogramDIE(SPDecl);
1467   // Add function template parameters.
1468   addTemplateParams(*SPDie, SP.getTemplateParams());
1470   if (DeclDie)
1471     // Refer function declaration directly.
1472     addDIEEntry(SPDie, dwarf::DW_AT_specification, DeclDie);
1474   // Add the linkage name if we have one and it isn't in the Decl.
1475   StringRef LinkageName = SP.getLinkageName();
1476   if (!LinkageName.empty()) {
1477     if (SPDecl.isSubprogram() && !SPDecl.getLinkageName().empty())
1478       assert(SPDecl.getLinkageName() == SP.getLinkageName() &&
1479              "decl has a linkage name and it is different");
1480     else
1481       addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1482                 GlobalValue::getRealLinkageName(LinkageName));
1483   }
1485   // If this DIE is going to refer declaration info using AT_specification
1486   // then there is no need to add other attributes.
1487   if (DeclDie)
1488     return SPDie;
1490   // Constructors and operators for anonymous aggregates do not have names.
1491   if (!SP.getName().empty())
1492     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1494   addSourceLine(SPDie, SP);
1496   // Add the prototype if we have a prototype and we have a C like
1497   // language.
1498   uint16_t Language = getLanguage();
1499   if (SP.isPrototyped() &&
1500       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1501        Language == dwarf::DW_LANG_ObjC))
1502     addFlag(SPDie, dwarf::DW_AT_prototyped);
1504   DICompositeType SPTy = SP.getType();
1505   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1506          "the type of a subprogram should be a subroutine");
1508   DIArray Args = SPTy.getTypeArray();
1509   // Add a return type. If this is a type like a C/C++ void type we don't add a
1510   // return type.
1511   if (Args.getElement(0))
1512     addType(SPDie, DIType(Args.getElement(0)));
1514   unsigned VK = SP.getVirtuality();
1515   if (VK) {
1516     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1517     DIELoc *Block = getDIELoc();
1518     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1519     addUInt(Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1520     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1521     ContainingTypeMap.insert(
1522         std::make_pair(SPDie, resolve(SP.getContainingType())));
1523   }
1525   if (!SP.isDefinition()) {
1526     addFlag(SPDie, dwarf::DW_AT_declaration);
1528     // Add arguments. Do not add arguments for subprogram definition. They will
1529     // be handled while processing variables.
1530     constructSubprogramArguments(*SPDie, Args);
1531   }
1533   if (SP.isArtificial())
1534     addFlag(SPDie, dwarf::DW_AT_artificial);
1536   if (!SP.isLocalToUnit())
1537     addFlag(SPDie, dwarf::DW_AT_external);
1539   if (SP.isOptimized())
1540     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1542   if (unsigned isa = Asm->getISAEncoding()) {
1543     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1544   }
1546   if (SP.isLValueReference())
1547     addFlag(SPDie, dwarf::DW_AT_reference);
1549   if (SP.isRValueReference())
1550     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1552   if (SP.isProtected())
1553     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1554             dwarf::DW_ACCESS_protected);
1555   else if (SP.isPrivate())
1556     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1557             dwarf::DW_ACCESS_private);
1558   else
1559     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1560             dwarf::DW_ACCESS_public);
1562   if (SP.isExplicit())
1563     addFlag(SPDie, dwarf::DW_AT_explicit);
1565   return SPDie;
1568 // Return const expression if value is a GEP to access merged global
1569 // constant. e.g.
1570 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1571 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1572   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1573   if (!CE || CE->getNumOperands() != 3 ||
1574       CE->getOpcode() != Instruction::GetElementPtr)
1575     return NULL;
1577   // First operand points to a global struct.
1578   Value *Ptr = CE->getOperand(0);
1579   if (!isa<GlobalValue>(Ptr) ||
1580       !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1581     return NULL;
1583   // Second operand is zero.
1584   const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1585   if (!CI || !CI->isZero())
1586     return NULL;
1588   // Third operand is offset.
1589   if (!isa<ConstantInt>(CE->getOperand(2)))
1590     return NULL;
1592   return CE;
1595 /// createGlobalVariableDIE - create global variable DIE.
1596 void DwarfCompileUnit::createGlobalVariableDIE(DIGlobalVariable GV) {
1597   // Check for pre-existence.
1598   if (getDIE(GV))
1599     return;
1601   assert(GV.isGlobalVariable());
1603   DIScope GVContext = GV.getContext();
1604   DIType GTy = DD->resolve(GV.getType());
1606   // If this is a static data member definition, some attributes belong
1607   // to the declaration DIE.
1608   DIE *VariableDIE = NULL;
1609   bool IsStaticMember = false;
1610   DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1611   if (SDMDecl.Verify()) {
1612     assert(SDMDecl.isStaticMember() && "Expected static member decl");
1613     // We need the declaration DIE that is in the static member's class.
1614     VariableDIE = getOrCreateStaticMemberDIE(SDMDecl);
1615     IsStaticMember = true;
1616   }
1618   // If this is not a static data member definition, create the variable
1619   // DIE and add the initial set of attributes to it.
1620   if (!VariableDIE) {
1621     // Construct the context before querying for the existence of the DIE in
1622     // case such construction creates the DIE.
1623     DIE *ContextDIE = getOrCreateContextDIE(GVContext);
1625     // Add to map.
1626     VariableDIE = createAndAddDIE(GV.getTag(), *ContextDIE, GV);
1628     // Add name and type.
1629     addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1630     addType(VariableDIE, GTy);
1632     // Add scoping info.
1633     if (!GV.isLocalToUnit())
1634       addFlag(VariableDIE, dwarf::DW_AT_external);
1636     // Add line number info.
1637     addSourceLine(VariableDIE, GV);
1638   }
1640   // Add location.
1641   bool addToAccelTable = false;
1642   DIE *VariableSpecDIE = NULL;
1643   bool isGlobalVariable = GV.getGlobal() != NULL;
1644   if (isGlobalVariable) {
1645     addToAccelTable = true;
1646     DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1647     const MCSymbol *Sym = Asm->getSymbol(GV.getGlobal());
1648     if (GV.getGlobal()->isThreadLocal()) {
1649       // FIXME: Make this work with -gsplit-dwarf.
1650       unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1651       assert((PointerSize == 4 || PointerSize == 8) &&
1652              "Add support for other sizes if necessary");
1653       // Based on GCC's support for TLS:
1654       if (!DD->useSplitDwarf()) {
1655         // 1) Start with a constNu of the appropriate pointer size
1656         addUInt(Loc, dwarf::DW_FORM_data1,
1657                 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1658         // 2) containing the (relocated) offset of the TLS variable
1659         //    within the module's TLS block.
1660         addExpr(Loc, dwarf::DW_FORM_udata,
1661                 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym));
1662       } else {
1663         addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1664         addUInt(Loc, dwarf::DW_FORM_udata,
1665                 DU->getAddrPoolIndex(Sym, /* TLS */ true));
1666       }
1667       // 3) followed by a custom OP to make the debugger do a TLS lookup.
1668       addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_push_tls_address);
1669     } else {
1670       DD->addArangeLabel(SymbolCU(this, Sym));
1671       addOpAddress(Loc, Sym);
1672     }
1673     // Do not create specification DIE if context is either compile unit
1674     // or a subprogram.
1675     if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1676         !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1677       // Create specification DIE.
1678       VariableSpecDIE = createAndAddDIE(dwarf::DW_TAG_variable, *UnitDie);
1679       addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, VariableDIE);
1680       addBlock(VariableSpecDIE, dwarf::DW_AT_location, Loc);
1681       // A static member's declaration is already flagged as such.
1682       if (!SDMDecl.Verify())
1683         addFlag(VariableDIE, dwarf::DW_AT_declaration);
1684     } else {
1685       addBlock(VariableDIE, dwarf::DW_AT_location, Loc);
1686     }
1687     // Add the linkage name.
1688     StringRef LinkageName = GV.getLinkageName();
1689     if (!LinkageName.empty())
1690       // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1691       // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1692       // TAG_variable.
1693       addString(IsStaticMember && VariableSpecDIE ? VariableSpecDIE
1694                                                   : VariableDIE,
1695                 DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
1696                                            : dwarf::DW_AT_MIPS_linkage_name,
1697                 GlobalValue::getRealLinkageName(LinkageName));
1698   } else if (const ConstantInt *CI =
1699                  dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1700     // AT_const_value was added when the static member was created. To avoid
1701     // emitting AT_const_value multiple times, we only add AT_const_value when
1702     // it is not a static member.
1703     if (!IsStaticMember)
1704       addConstantValue(VariableDIE, CI, isUnsignedDIType(DD, GTy));
1705   } else if (const ConstantExpr *CE = getMergedGlobalExpr(GV->getOperand(11))) {
1706     addToAccelTable = true;
1707     // GV is a merged global.
1708     DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1709     Value *Ptr = CE->getOperand(0);
1710     MCSymbol *Sym = Asm->getSymbol(cast<GlobalValue>(Ptr));
1711     DD->addArangeLabel(SymbolCU(this, Sym));
1712     addOpAddress(Loc, Sym);
1713     addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1714     SmallVector<Value *, 3> Idx(CE->op_begin() + 1, CE->op_end());
1715     addUInt(Loc, dwarf::DW_FORM_udata,
1716             Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1717     addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1718     addBlock(VariableDIE, dwarf::DW_AT_location, Loc);
1719   }
1721   if (addToAccelTable) {
1722     DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1723     addAccelName(GV.getName(), AddrDIE);
1725     // If the linkage name is different than the name, go ahead and output
1726     // that as well into the name table.
1727     if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1728       addAccelName(GV.getLinkageName(), AddrDIE);
1729   }
1731   if (!GV.isLocalToUnit())
1732     addGlobalName(GV.getName(), VariableSpecDIE ? VariableSpecDIE : VariableDIE,
1733                   GV.getContext());
1736 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1737 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1738   DIE *DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1739   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, IndexTy);
1741   // The LowerBound value defines the lower bounds which is typically zero for
1742   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1743   // Count == -1 then the array is unbounded and we do not emit
1744   // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1745   // Count == 0, then the array has zero elements in which case we do not emit
1746   // an upper bound.
1747   int64_t LowerBound = SR.getLo();
1748   int64_t DefaultLowerBound = getDefaultLowerBound();
1749   int64_t Count = SR.getCount();
1751   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1752     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1754   if (Count != -1 && Count != 0)
1755     // FIXME: An unbounded array should reference the expression that defines
1756     // the array.
1757     addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, None,
1758             LowerBound + Count - 1);
1761 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1762 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1763   if (CTy.isVector())
1764     addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1766   // Emit the element type.
1767   addType(&Buffer, resolve(CTy.getTypeDerivedFrom()));
1769   // Get an anonymous type for index type.
1770   // FIXME: This type should be passed down from the front end
1771   // as different languages may have different sizes for indexes.
1772   DIE *IdxTy = getIndexTyDie();
1773   if (!IdxTy) {
1774     // Construct an integer type to use for indexes.
1775     IdxTy = createAndAddDIE(dwarf::DW_TAG_base_type, *UnitDie);
1776     addString(IdxTy, dwarf::DW_AT_name, "sizetype");
1777     addUInt(IdxTy, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1778     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1779             dwarf::DW_ATE_unsigned);
1780     setIndexTyDie(IdxTy);
1781   }
1783   // Add subranges to array type.
1784   DIArray Elements = CTy.getTypeArray();
1785   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1786     DIDescriptor Element = Elements.getElement(i);
1787     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1788       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1789   }
1792 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1793 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1794   DIArray Elements = CTy.getTypeArray();
1796   // Add enumerators to enumeration type.
1797   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1798     DIEnumerator Enum(Elements.getElement(i));
1799     if (Enum.isEnumerator()) {
1800       DIE *Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1801       StringRef Name = Enum.getName();
1802       addString(Enumerator, dwarf::DW_AT_name, Name);
1803       int64_t Value = Enum.getEnumValue();
1804       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1805               Value);
1806     }
1807   }
1808   DIType DTy = resolve(CTy.getTypeDerivedFrom());
1809   if (DTy) {
1810     addType(&Buffer, DTy);
1811     addFlag(&Buffer, dwarf::DW_AT_enum_class);
1812   }
1815 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1816 /// vtables.
1817 void DwarfUnit::constructContainingTypeDIEs() {
1818   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1819                                                  CE = ContainingTypeMap.end();
1820        CI != CE; ++CI) {
1821     DIE *SPDie = CI->first;
1822     DIDescriptor D(CI->second);
1823     if (!D)
1824       continue;
1825     DIE *NDie = getDIE(D);
1826     if (!NDie)
1827       continue;
1828     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, NDie);
1829   }
1832 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1833 DIE *DwarfUnit::constructVariableDIE(DbgVariable &DV, bool isScopeAbstract) {
1834   StringRef Name = DV.getName();
1836   // Define variable debug information entry.
1837   DIE *VariableDie = new DIE(DV.getTag());
1838   DbgVariable *AbsVar = DV.getAbstractVariable();
1839   DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1840   if (AbsDIE)
1841     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin, AbsDIE);
1842   else {
1843     if (!Name.empty())
1844       addString(VariableDie, dwarf::DW_AT_name, Name);
1845     addSourceLine(VariableDie, DV.getVariable());
1846     addType(VariableDie, DV.getType());
1847   }
1849   if (DV.isArtificial())
1850     addFlag(VariableDie, dwarf::DW_AT_artificial);
1852   if (isScopeAbstract) {
1853     DV.setDIE(VariableDie);
1854     return VariableDie;
1855   }
1857   // Add variable address.
1859   unsigned Offset = DV.getDotDebugLocOffset();
1860   if (Offset != ~0U) {
1861     addLocationList(VariableDie, dwarf::DW_AT_location, Offset);
1862     DV.setDIE(VariableDie);
1863     return VariableDie;
1864   }
1866   // Check if variable is described by a DBG_VALUE instruction.
1867   if (const MachineInstr *DVInsn = DV.getMInsn()) {
1868     assert(DVInsn->getNumOperands() == 3);
1869     if (DVInsn->getOperand(0).isReg()) {
1870       const MachineOperand RegOp = DVInsn->getOperand(0);
1871       // If the second operand is an immediate, this is an indirect value.
1872       if (DVInsn->getOperand(1).isImm()) {
1873         MachineLocation Location(RegOp.getReg(),
1874                                  DVInsn->getOperand(1).getImm());
1875         addVariableAddress(DV, VariableDie, Location);
1876       } else if (RegOp.getReg())
1877         addVariableAddress(DV, VariableDie, MachineLocation(RegOp.getReg()));
1878     } else if (DVInsn->getOperand(0).isImm())
1879       addConstantValue(VariableDie, DVInsn->getOperand(0), DV.getType());
1880     else if (DVInsn->getOperand(0).isFPImm())
1881       addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1882     else if (DVInsn->getOperand(0).isCImm())
1883       addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
1884                        isUnsignedDIType(DD, DV.getType()));
1886     DV.setDIE(VariableDie);
1887     return VariableDie;
1888   } else {
1889     // .. else use frame index.
1890     int FI = DV.getFrameIndex();
1891     if (FI != ~0) {
1892       unsigned FrameReg = 0;
1893       const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1894       int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1895       MachineLocation Location(FrameReg, Offset);
1896       addVariableAddress(DV, VariableDie, Location);
1897     }
1898   }
1900   DV.setDIE(VariableDie);
1901   return VariableDie;
1904 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1905 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1906   DIE *MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1907   StringRef Name = DT.getName();
1908   if (!Name.empty())
1909     addString(MemberDie, dwarf::DW_AT_name, Name);
1911   addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1913   addSourceLine(MemberDie, DT);
1915   if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1917     // For C++, virtual base classes are not at fixed offset. Use following
1918     // expression to extract appropriate offset from vtable.
1919     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1921     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1922     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1923     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1924     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1925     addUInt(VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1926     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1927     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1928     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1930     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1931   } else {
1932     uint64_t Size = DT.getSizeInBits();
1933     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1934     uint64_t OffsetInBytes;
1936     if (Size != FieldSize) {
1937       // Handle bitfield, assume bytes are 8 bits.
1938       addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1939       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1941       uint64_t Offset = DT.getOffsetInBits();
1942       uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1943       uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1944       uint64_t FieldOffset = (HiMark - FieldSize);
1945       Offset -= FieldOffset;
1947       // Maybe we need to work from the other end.
1948       if (Asm->getDataLayout().isLittleEndian())
1949         Offset = FieldSize - (Offset + Size);
1950       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1952       // Here DW_AT_data_member_location points to the anonymous
1953       // field that includes this bit field.
1954       OffsetInBytes = FieldOffset >> 3;
1955     } else
1956       // This is not a bitfield.
1957       OffsetInBytes = DT.getOffsetInBits() >> 3;
1959     if (DD->getDwarfVersion() <= 2) {
1960       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1961       addUInt(MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1962       addUInt(MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1963       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1964     } else
1965       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1966               OffsetInBytes);
1967   }
1969   if (DT.isProtected())
1970     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1971             dwarf::DW_ACCESS_protected);
1972   else if (DT.isPrivate())
1973     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1974             dwarf::DW_ACCESS_private);
1975   // Otherwise C++ member and base classes are considered public.
1976   else
1977     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1978             dwarf::DW_ACCESS_public);
1979   if (DT.isVirtual())
1980     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1981             dwarf::DW_VIRTUALITY_virtual);
1983   // Objective-C properties.
1984   if (MDNode *PNode = DT.getObjCProperty())
1985     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1986       MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1987                           PropertyDie);
1989   if (DT.isArtificial())
1990     addFlag(MemberDie, dwarf::DW_AT_artificial);
1993 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1994 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1995   if (!DT.Verify())
1996     return NULL;
1998   // Construct the context before querying for the existence of the DIE in case
1999   // such construction creates the DIE.
2000   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
2001   assert(dwarf::isType(ContextDIE->getTag()) &&
2002          "Static member should belong to a type.");
2004   DIE *StaticMemberDIE = getDIE(DT);
2005   if (StaticMemberDIE)
2006     return StaticMemberDIE;
2008   StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
2010   DIType Ty = resolve(DT.getTypeDerivedFrom());
2012   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
2013   addType(StaticMemberDIE, Ty);
2014   addSourceLine(StaticMemberDIE, DT);
2015   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
2016   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
2018   // FIXME: We could omit private if the parent is a class_type, and
2019   // public if the parent is something else.
2020   if (DT.isProtected())
2021     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
2022             dwarf::DW_ACCESS_protected);
2023   else if (DT.isPrivate())
2024     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
2025             dwarf::DW_ACCESS_private);
2026   else
2027     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
2028             dwarf::DW_ACCESS_public);
2030   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
2031     addConstantValue(StaticMemberDIE, CI, isUnsignedDIType(DD, Ty));
2032   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
2033     addConstantFPValue(StaticMemberDIE, CFP);
2035   return StaticMemberDIE;
2038 void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const {
2039   Asm->OutStreamer.AddComment("DWARF version number");
2040   Asm->EmitInt16(DD->getDwarfVersion());
2041   Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2042   // We share one abbreviations table across all units so it's always at the
2043   // start of the section. Use a relocatable offset where needed to ensure
2044   // linking doesn't invalidate that offset.
2045   if (ASectionSym)
2046     Asm->EmitSectionOffset(ASectionSym, ASectionSym);
2047   else
2048     // Use a constant value when no symbol is provided.
2049     Asm->EmitInt32(0);
2050   Asm->OutStreamer.AddComment("Address Size (in bytes)");
2051   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2054 void DwarfUnit::addRange(RangeSpan Range) {
2055   // Only add a range for this unit if we're emitting full debug.
2056   if (getCUNode().getEmissionKind() == DIBuilder::FullDebug) {
2057     // If we have no current ranges just add the range and return, otherwise,
2058     // check the current section and CU against the previous section and CU we
2059     // emitted into and the subprogram was contained within. If these are the
2060     // same then extend our current range, otherwise add this as a new range.
2061     if (CURanges.size() == 0 ||
2062         this != DD->getPrevCU() ||
2063         Asm->getCurrentSection() != DD->getPrevSection()) {
2064       CURanges.push_back(Range);
2065       return;
2066     }
2068     assert(&(CURanges.back().getEnd()->getSection()) ==
2069                &(Range.getEnd()->getSection()) &&
2070            "We can only append to a range in the same section!");
2071     CURanges.back().setEnd(Range.getEnd());
2072   }
2075 void DwarfCompileUnit::initStmtList(MCSymbol *DwarfLineSectionSym) {
2076   // Define start line table label for each Compile Unit.
2077   MCSymbol *LineTableStartSym =
2078       Asm->OutStreamer.getDwarfLineTableSymbol(getUniqueID());
2080   stmtListIndex = UnitDie->getValues().size();
2082   // DW_AT_stmt_list is a offset of line number information for this
2083   // compile unit in debug_line section. For split dwarf this is
2084   // left in the skeleton CU and so not included.
2085   // The line table entries are not always emitted in assembly, so it
2086   // is not okay to use line_table_start here.
2087   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2088     addSectionLabel(UnitDie.get(), dwarf::DW_AT_stmt_list, LineTableStartSym);
2089   else
2090     addSectionDelta(UnitDie.get(), dwarf::DW_AT_stmt_list, LineTableStartSym,
2091                     DwarfLineSectionSym);
2094 void DwarfCompileUnit::applyStmtList(DIE &D) {
2095   D.addValue(dwarf::DW_AT_stmt_list,
2096              UnitDie->getAbbrev().getData()[stmtListIndex].getForm(),
2097              UnitDie->getValues()[stmtListIndex]);
2100 void DwarfTypeUnit::emitHeader(const MCSymbol *ASectionSym) const {
2101   DwarfUnit::emitHeader(ASectionSym);
2102   Asm->OutStreamer.AddComment("Type Signature");
2103   Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
2104   Asm->OutStreamer.AddComment("Type DIE Offset");
2105   // In a skeleton type unit there is no type DIE so emit a zero offset.
2106   Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
2107                                 sizeof(Ty->getOffset()));
2110 void DwarfTypeUnit::initSection(const MCSection *Section) {
2111   assert(!this->Section);
2112   this->Section = Section;
2113   // Since each type unit is contained in its own COMDAT section, the begin
2114   // label and the section label are the same. Using the begin label emission in
2115   // DwarfDebug to emit the section label as well is slightly subtle/sneaky, but
2116   // the only other alternative of lazily constructing start-of-section labels
2117   // and storing a mapping in DwarfDebug (or AsmPrinter).
2118   this->SectionSym = this->LabelBegin =
2119       Asm->GetTempSymbol(Section->getLabelBeginName(), getUniqueID());
2120   this->LabelEnd =
2121       Asm->GetTempSymbol(Section->getLabelEndName(), getUniqueID());
2122   this->LabelRange = Asm->GetTempSymbol("gnu_ranges", getUniqueID());