Get rid of an unnecessary use of the * and & operators.
[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 this DIE is going to refer declaration info using AT_specification
1471   // then there is no need to add other attributes.
1472   if (DeclDie) {
1473     // Refer function declaration directly.
1474     addDIEEntry(SPDie, dwarf::DW_AT_specification, DeclDie);
1476     return SPDie;
1477   }
1479   // Add the linkage name if we have one.
1480   StringRef LinkageName = SP.getLinkageName();
1481   if (!LinkageName.empty())
1482     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1483               GlobalValue::getRealLinkageName(LinkageName));
1485   // Constructors and operators for anonymous aggregates do not have names.
1486   if (!SP.getName().empty())
1487     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1489   addSourceLine(SPDie, SP);
1491   // Add the prototype if we have a prototype and we have a C like
1492   // language.
1493   uint16_t Language = getLanguage();
1494   if (SP.isPrototyped() &&
1495       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1496        Language == dwarf::DW_LANG_ObjC))
1497     addFlag(SPDie, dwarf::DW_AT_prototyped);
1499   DICompositeType SPTy = SP.getType();
1500   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1501          "the type of a subprogram should be a subroutine");
1503   DIArray Args = SPTy.getTypeArray();
1504   // Add a return type. If this is a type like a C/C++ void type we don't add a
1505   // return type.
1506   if (Args.getElement(0))
1507     addType(SPDie, DIType(Args.getElement(0)));
1509   unsigned VK = SP.getVirtuality();
1510   if (VK) {
1511     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1512     DIELoc *Block = getDIELoc();
1513     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1514     addUInt(Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1515     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1516     ContainingTypeMap.insert(
1517         std::make_pair(SPDie, resolve(SP.getContainingType())));
1518   }
1520   if (!SP.isDefinition()) {
1521     addFlag(SPDie, dwarf::DW_AT_declaration);
1523     // Add arguments. Do not add arguments for subprogram definition. They will
1524     // be handled while processing variables.
1525     constructSubprogramArguments(*SPDie, Args);
1526   }
1528   if (SP.isArtificial())
1529     addFlag(SPDie, dwarf::DW_AT_artificial);
1531   if (!SP.isLocalToUnit())
1532     addFlag(SPDie, dwarf::DW_AT_external);
1534   if (SP.isOptimized())
1535     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1537   if (unsigned isa = Asm->getISAEncoding()) {
1538     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1539   }
1541   if (SP.isLValueReference())
1542     addFlag(SPDie, dwarf::DW_AT_reference);
1544   if (SP.isRValueReference())
1545     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1547   if (SP.isProtected())
1548     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1549             dwarf::DW_ACCESS_protected);
1550   else if (SP.isPrivate())
1551     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1552             dwarf::DW_ACCESS_private);
1553   else
1554     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1555             dwarf::DW_ACCESS_public);
1557   if (SP.isExplicit())
1558     addFlag(SPDie, dwarf::DW_AT_explicit);
1560   return SPDie;
1563 // Return const expression if value is a GEP to access merged global
1564 // constant. e.g.
1565 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1566 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1567   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1568   if (!CE || CE->getNumOperands() != 3 ||
1569       CE->getOpcode() != Instruction::GetElementPtr)
1570     return NULL;
1572   // First operand points to a global struct.
1573   Value *Ptr = CE->getOperand(0);
1574   if (!isa<GlobalValue>(Ptr) ||
1575       !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1576     return NULL;
1578   // Second operand is zero.
1579   const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1580   if (!CI || !CI->isZero())
1581     return NULL;
1583   // Third operand is offset.
1584   if (!isa<ConstantInt>(CE->getOperand(2)))
1585     return NULL;
1587   return CE;
1590 /// createGlobalVariableDIE - create global variable DIE.
1591 void DwarfCompileUnit::createGlobalVariableDIE(DIGlobalVariable GV) {
1592   // Check for pre-existence.
1593   if (getDIE(GV))
1594     return;
1596   assert(GV.isGlobalVariable());
1598   DIScope GVContext = GV.getContext();
1599   DIType GTy = DD->resolve(GV.getType());
1601   // If this is a static data member definition, some attributes belong
1602   // to the declaration DIE.
1603   DIE *VariableDIE = NULL;
1604   bool IsStaticMember = false;
1605   DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1606   if (SDMDecl.Verify()) {
1607     assert(SDMDecl.isStaticMember() && "Expected static member decl");
1608     // We need the declaration DIE that is in the static member's class.
1609     VariableDIE = getOrCreateStaticMemberDIE(SDMDecl);
1610     IsStaticMember = true;
1611   }
1613   // If this is not a static data member definition, create the variable
1614   // DIE and add the initial set of attributes to it.
1615   if (!VariableDIE) {
1616     // Construct the context before querying for the existence of the DIE in
1617     // case such construction creates the DIE.
1618     DIE *ContextDIE = getOrCreateContextDIE(GVContext);
1620     // Add to map.
1621     VariableDIE = createAndAddDIE(GV.getTag(), *ContextDIE, GV);
1623     // Add name and type.
1624     addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1625     addType(VariableDIE, GTy);
1627     // Add scoping info.
1628     if (!GV.isLocalToUnit())
1629       addFlag(VariableDIE, dwarf::DW_AT_external);
1631     // Add line number info.
1632     addSourceLine(VariableDIE, GV);
1633   }
1635   // Add location.
1636   bool addToAccelTable = false;
1637   DIE *VariableSpecDIE = NULL;
1638   bool isGlobalVariable = GV.getGlobal() != NULL;
1639   if (isGlobalVariable) {
1640     addToAccelTable = true;
1641     DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1642     const MCSymbol *Sym = Asm->getSymbol(GV.getGlobal());
1643     if (GV.getGlobal()->isThreadLocal()) {
1644       // FIXME: Make this work with -gsplit-dwarf.
1645       unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1646       assert((PointerSize == 4 || PointerSize == 8) &&
1647              "Add support for other sizes if necessary");
1648       // Based on GCC's support for TLS:
1649       if (!DD->useSplitDwarf()) {
1650         // 1) Start with a constNu of the appropriate pointer size
1651         addUInt(Loc, dwarf::DW_FORM_data1,
1652                 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1653         // 2) containing the (relocated) offset of the TLS variable
1654         //    within the module's TLS block.
1655         addExpr(Loc, dwarf::DW_FORM_udata,
1656                 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym));
1657       } else {
1658         addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1659         addUInt(Loc, dwarf::DW_FORM_udata,
1660                 DU->getAddrPoolIndex(Sym, /* TLS */ true));
1661       }
1662       // 3) followed by a custom OP to make the debugger do a TLS lookup.
1663       addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_push_tls_address);
1664     } else {
1665       DD->addArangeLabel(SymbolCU(this, Sym));
1666       addOpAddress(Loc, Sym);
1667     }
1668     // Do not create specification DIE if context is either compile unit
1669     // or a subprogram.
1670     if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1671         !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1672       // Create specification DIE.
1673       VariableSpecDIE = createAndAddDIE(dwarf::DW_TAG_variable, *UnitDie);
1674       addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, VariableDIE);
1675       addBlock(VariableSpecDIE, dwarf::DW_AT_location, Loc);
1676       // A static member's declaration is already flagged as such.
1677       if (!SDMDecl.Verify())
1678         addFlag(VariableDIE, dwarf::DW_AT_declaration);
1679     } else {
1680       addBlock(VariableDIE, dwarf::DW_AT_location, Loc);
1681     }
1682     // Add the linkage name.
1683     StringRef LinkageName = GV.getLinkageName();
1684     if (!LinkageName.empty())
1685       // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1686       // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1687       // TAG_variable.
1688       addString(IsStaticMember && VariableSpecDIE ? VariableSpecDIE
1689                                                   : VariableDIE,
1690                 DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
1691                                            : dwarf::DW_AT_MIPS_linkage_name,
1692                 GlobalValue::getRealLinkageName(LinkageName));
1693   } else if (const ConstantInt *CI =
1694                  dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1695     // AT_const_value was added when the static member was created. To avoid
1696     // emitting AT_const_value multiple times, we only add AT_const_value when
1697     // it is not a static member.
1698     if (!IsStaticMember)
1699       addConstantValue(VariableDIE, CI, isUnsignedDIType(DD, GTy));
1700   } else if (const ConstantExpr *CE = getMergedGlobalExpr(GV->getOperand(11))) {
1701     addToAccelTable = true;
1702     // GV is a merged global.
1703     DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1704     Value *Ptr = CE->getOperand(0);
1705     MCSymbol *Sym = Asm->getSymbol(cast<GlobalValue>(Ptr));
1706     DD->addArangeLabel(SymbolCU(this, Sym));
1707     addOpAddress(Loc, Sym);
1708     addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1709     SmallVector<Value *, 3> Idx(CE->op_begin() + 1, CE->op_end());
1710     addUInt(Loc, dwarf::DW_FORM_udata,
1711             Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1712     addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1713     addBlock(VariableDIE, dwarf::DW_AT_location, Loc);
1714   }
1716   if (addToAccelTable) {
1717     DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1718     addAccelName(GV.getName(), AddrDIE);
1720     // If the linkage name is different than the name, go ahead and output
1721     // that as well into the name table.
1722     if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1723       addAccelName(GV.getLinkageName(), AddrDIE);
1724   }
1726   if (!GV.isLocalToUnit())
1727     addGlobalName(GV.getName(), VariableSpecDIE ? VariableSpecDIE : VariableDIE,
1728                   GV.getContext());
1731 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1732 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1733   DIE *DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1734   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, IndexTy);
1736   // The LowerBound value defines the lower bounds which is typically zero for
1737   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1738   // Count == -1 then the array is unbounded and we do not emit
1739   // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1740   // Count == 0, then the array has zero elements in which case we do not emit
1741   // an upper bound.
1742   int64_t LowerBound = SR.getLo();
1743   int64_t DefaultLowerBound = getDefaultLowerBound();
1744   int64_t Count = SR.getCount();
1746   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1747     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1749   if (Count != -1 && Count != 0)
1750     // FIXME: An unbounded array should reference the expression that defines
1751     // the array.
1752     addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, None,
1753             LowerBound + Count - 1);
1756 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1757 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1758   if (CTy.isVector())
1759     addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1761   // Emit the element type.
1762   addType(&Buffer, resolve(CTy.getTypeDerivedFrom()));
1764   // Get an anonymous type for index type.
1765   // FIXME: This type should be passed down from the front end
1766   // as different languages may have different sizes for indexes.
1767   DIE *IdxTy = getIndexTyDie();
1768   if (!IdxTy) {
1769     // Construct an anonymous type for index type.
1770     IdxTy = createAndAddDIE(dwarf::DW_TAG_base_type, *UnitDie);
1771     addString(IdxTy, dwarf::DW_AT_name, "int");
1772     addUInt(IdxTy, dwarf::DW_AT_byte_size, None, sizeof(int32_t));
1773     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1774             dwarf::DW_ATE_signed);
1775     setIndexTyDie(IdxTy);
1776   }
1778   // Add subranges to array type.
1779   DIArray Elements = CTy.getTypeArray();
1780   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1781     DIDescriptor Element = Elements.getElement(i);
1782     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1783       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1784   }
1787 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1788 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1789   DIArray Elements = CTy.getTypeArray();
1791   // Add enumerators to enumeration type.
1792   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1793     DIEnumerator Enum(Elements.getElement(i));
1794     if (Enum.isEnumerator()) {
1795       DIE *Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1796       StringRef Name = Enum.getName();
1797       addString(Enumerator, dwarf::DW_AT_name, Name);
1798       int64_t Value = Enum.getEnumValue();
1799       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1800               Value);
1801     }
1802   }
1803   DIType DTy = resolve(CTy.getTypeDerivedFrom());
1804   if (DTy) {
1805     addType(&Buffer, DTy);
1806     addFlag(&Buffer, dwarf::DW_AT_enum_class);
1807   }
1810 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1811 /// vtables.
1812 void DwarfUnit::constructContainingTypeDIEs() {
1813   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1814                                                  CE = ContainingTypeMap.end();
1815        CI != CE; ++CI) {
1816     DIE *SPDie = CI->first;
1817     DIDescriptor D(CI->second);
1818     if (!D)
1819       continue;
1820     DIE *NDie = getDIE(D);
1821     if (!NDie)
1822       continue;
1823     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, NDie);
1824   }
1827 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1828 DIE *DwarfUnit::constructVariableDIE(DbgVariable &DV, bool isScopeAbstract) {
1829   StringRef Name = DV.getName();
1831   // Define variable debug information entry.
1832   DIE *VariableDie = new DIE(DV.getTag());
1833   DbgVariable *AbsVar = DV.getAbstractVariable();
1834   DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1835   if (AbsDIE)
1836     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin, AbsDIE);
1837   else {
1838     if (!Name.empty())
1839       addString(VariableDie, dwarf::DW_AT_name, Name);
1840     addSourceLine(VariableDie, DV.getVariable());
1841     addType(VariableDie, DV.getType());
1842   }
1844   if (DV.isArtificial())
1845     addFlag(VariableDie, dwarf::DW_AT_artificial);
1847   if (isScopeAbstract) {
1848     DV.setDIE(VariableDie);
1849     return VariableDie;
1850   }
1852   // Add variable address.
1854   unsigned Offset = DV.getDotDebugLocOffset();
1855   if (Offset != ~0U) {
1856     addLocationList(VariableDie, dwarf::DW_AT_location, Offset);
1857     DV.setDIE(VariableDie);
1858     return VariableDie;
1859   }
1861   // Check if variable is described by a DBG_VALUE instruction.
1862   if (const MachineInstr *DVInsn = DV.getMInsn()) {
1863     assert(DVInsn->getNumOperands() == 3);
1864     if (DVInsn->getOperand(0).isReg()) {
1865       const MachineOperand RegOp = DVInsn->getOperand(0);
1866       // If the second operand is an immediate, this is an indirect value.
1867       if (DVInsn->getOperand(1).isImm()) {
1868         MachineLocation Location(RegOp.getReg(),
1869                                  DVInsn->getOperand(1).getImm());
1870         addVariableAddress(DV, VariableDie, Location);
1871       } else if (RegOp.getReg())
1872         addVariableAddress(DV, VariableDie, MachineLocation(RegOp.getReg()));
1873     } else if (DVInsn->getOperand(0).isImm())
1874       addConstantValue(VariableDie, DVInsn->getOperand(0), DV.getType());
1875     else if (DVInsn->getOperand(0).isFPImm())
1876       addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1877     else if (DVInsn->getOperand(0).isCImm())
1878       addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
1879                        isUnsignedDIType(DD, DV.getType()));
1881     DV.setDIE(VariableDie);
1882     return VariableDie;
1883   } else {
1884     // .. else use frame index.
1885     int FI = DV.getFrameIndex();
1886     if (FI != ~0) {
1887       unsigned FrameReg = 0;
1888       const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1889       int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1890       MachineLocation Location(FrameReg, Offset);
1891       addVariableAddress(DV, VariableDie, Location);
1892     }
1893   }
1895   DV.setDIE(VariableDie);
1896   return VariableDie;
1899 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1900 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1901   DIE *MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1902   StringRef Name = DT.getName();
1903   if (!Name.empty())
1904     addString(MemberDie, dwarf::DW_AT_name, Name);
1906   addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1908   addSourceLine(MemberDie, DT);
1910   if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1912     // For C++, virtual base classes are not at fixed offset. Use following
1913     // expression to extract appropriate offset from vtable.
1914     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1916     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1917     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1918     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1919     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1920     addUInt(VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1921     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1922     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1923     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1925     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1926   } else {
1927     uint64_t Size = DT.getSizeInBits();
1928     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1929     uint64_t OffsetInBytes;
1931     if (Size != FieldSize) {
1932       // Handle bitfield, assume bytes are 8 bits.
1933       addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1934       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1936       uint64_t Offset = DT.getOffsetInBits();
1937       uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1938       uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1939       uint64_t FieldOffset = (HiMark - FieldSize);
1940       Offset -= FieldOffset;
1942       // Maybe we need to work from the other end.
1943       if (Asm->getDataLayout().isLittleEndian())
1944         Offset = FieldSize - (Offset + Size);
1945       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1947       // Here DW_AT_data_member_location points to the anonymous
1948       // field that includes this bit field.
1949       OffsetInBytes = FieldOffset >> 3;
1950     } else
1951       // This is not a bitfield.
1952       OffsetInBytes = DT.getOffsetInBits() >> 3;
1954     if (DD->getDwarfVersion() <= 2) {
1955       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1956       addUInt(MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1957       addUInt(MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1958       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1959     } else
1960       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1961               OffsetInBytes);
1962   }
1964   if (DT.isProtected())
1965     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1966             dwarf::DW_ACCESS_protected);
1967   else if (DT.isPrivate())
1968     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1969             dwarf::DW_ACCESS_private);
1970   // Otherwise C++ member and base classes are considered public.
1971   else
1972     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1973             dwarf::DW_ACCESS_public);
1974   if (DT.isVirtual())
1975     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1976             dwarf::DW_VIRTUALITY_virtual);
1978   // Objective-C properties.
1979   if (MDNode *PNode = DT.getObjCProperty())
1980     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1981       MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1982                           PropertyDie);
1984   if (DT.isArtificial())
1985     addFlag(MemberDie, dwarf::DW_AT_artificial);
1988 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1989 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1990   if (!DT.Verify())
1991     return NULL;
1993   // Construct the context before querying for the existence of the DIE in case
1994   // such construction creates the DIE.
1995   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1996   assert(dwarf::isType(ContextDIE->getTag()) &&
1997          "Static member should belong to a type.");
1999   DIE *StaticMemberDIE = getDIE(DT);
2000   if (StaticMemberDIE)
2001     return StaticMemberDIE;
2003   StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
2005   DIType Ty = resolve(DT.getTypeDerivedFrom());
2007   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
2008   addType(StaticMemberDIE, Ty);
2009   addSourceLine(StaticMemberDIE, DT);
2010   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
2011   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
2013   // FIXME: We could omit private if the parent is a class_type, and
2014   // public if the parent is something else.
2015   if (DT.isProtected())
2016     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
2017             dwarf::DW_ACCESS_protected);
2018   else if (DT.isPrivate())
2019     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
2020             dwarf::DW_ACCESS_private);
2021   else
2022     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
2023             dwarf::DW_ACCESS_public);
2025   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
2026     addConstantValue(StaticMemberDIE, CI, isUnsignedDIType(DD, Ty));
2027   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
2028     addConstantFPValue(StaticMemberDIE, CFP);
2030   return StaticMemberDIE;
2033 void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const {
2034   Asm->OutStreamer.AddComment("DWARF version number");
2035   Asm->EmitInt16(DD->getDwarfVersion());
2036   Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2037   // We share one abbreviations table across all units so it's always at the
2038   // start of the section. Use a relocatable offset where needed to ensure
2039   // linking doesn't invalidate that offset.
2040   if (ASectionSym)
2041     Asm->EmitSectionOffset(ASectionSym, ASectionSym);
2042   else
2043     // Use a constant value in the dwo file, to avoid relocations
2044     Asm->EmitInt32(0);
2045   Asm->OutStreamer.AddComment("Address Size (in bytes)");
2046   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2049 void DwarfUnit::addRange(RangeSpan Range) {
2050   // Only add a range for this unit if we're emitting full debug.
2051   if (getCUNode().getEmissionKind() == DIBuilder::FullDebug) {
2052     // If we have no current ranges just add the range and return, otherwise,
2053     // check the current section and CU against the previous section and CU we
2054     // emitted into and the subprogram was contained within. If these are the
2055     // same then extend our current range, otherwise add this as a new range.
2056     if (CURanges.size() == 0 ||
2057         this != DD->getPrevCU() ||
2058         Asm->getCurrentSection() != DD->getPrevSection()) {
2059       CURanges.push_back(Range);
2060       return;
2061     }
2063     assert(&(CURanges.back().getEnd()->getSection()) ==
2064                &(Range.getEnd()->getSection()) &&
2065            "We can only append to a range in the same section!");
2066     CURanges.back().setEnd(Range.getEnd());
2067   }
2070 void DwarfCompileUnit::initStmtList(MCSymbol *DwarfLineSectionSym) {
2071   // Define start line table label for each Compile Unit.
2072   MCSymbol *LineTableStartSym =
2073       Asm->GetTempSymbol("line_table_start", getUniqueID());
2074   Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
2075                                                      getUniqueID());
2077   // Use a single line table if we are generating assembly.
2078   bool UseTheFirstCU =
2079       Asm->OutStreamer.hasRawTextSupport() || (getUniqueID() == 0);
2081   stmtListIndex = UnitDie->getValues().size();
2083   // DW_AT_stmt_list is a offset of line number information for this
2084   // compile unit in debug_line section. For split dwarf this is
2085   // left in the skeleton CU and so not included.
2086   // The line table entries are not always emitted in assembly, so it
2087   // is not okay to use line_table_start here.
2088   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2089     addSectionLabel(UnitDie.get(), dwarf::DW_AT_stmt_list,
2090                     UseTheFirstCU ? DwarfLineSectionSym : LineTableStartSym);
2091   else if (UseTheFirstCU)
2092     addSectionOffset(UnitDie.get(), dwarf::DW_AT_stmt_list, 0);
2093   else
2094     addSectionDelta(UnitDie.get(), dwarf::DW_AT_stmt_list, LineTableStartSym,
2095                     DwarfLineSectionSym);
2098 void DwarfCompileUnit::applyStmtList(DIE &D) {
2099   D.addValue(dwarf::DW_AT_stmt_list,
2100              UnitDie->getAbbrev().getData()[stmtListIndex].getForm(),
2101              UnitDie->getValues()[stmtListIndex]);
2104 void DwarfTypeUnit::emitHeader(const MCSymbol *ASectionSym) const {
2105   DwarfUnit::emitHeader(ASectionSym);
2106   Asm->OutStreamer.AddComment("Type Signature");
2107   Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
2108   Asm->OutStreamer.AddComment("Type DIE Offset");
2109   // In a skeleton type unit there is no type DIE so emit a zero offset.
2110   Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
2111                                 sizeof(Ty->getOffset()));
2114 void DwarfTypeUnit::initSection(const MCSection *Section) {
2115   assert(!this->Section);
2116   this->Section = Section;
2117   // Since each type unit is contained in its own COMDAT section, the begin
2118   // label and the section label are the same. Using the begin label emission in
2119   // DwarfDebug to emit the section label as well is slightly subtle/sneaky, but
2120   // the only other alternative of lazily constructing start-of-section labels
2121   // and storing a mapping in DwarfDebug (or AsmPrinter).
2122   this->SectionSym = this->LabelBegin =
2123       Asm->GetTempSymbol(Section->getLabelBeginName(), getUniqueID());
2124   this->LabelEnd =
2125       Asm->GetTempSymbol(Section->getLabelEndName(), getUniqueID());
2126   this->LabelRange = Asm->GetTempSymbol("gnu_ranges", getUniqueID());