be21d633e54ba287cedaee0577d298a3bd24bfa7
[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                                        MCSymbol *Label) {
286   if (Label)
287     DD->addArangeLabel(SymbolCU(this, Label));
289   if (!DD->useSplitDwarf()) {
290     if (Label) {
291       DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
292       Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
293     } else {
294       DIEValue *Value = new (DIEValueAllocator) DIEInteger(0);
295       Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
296     }
297   } else {
298     unsigned idx = DU->getAddrPoolIndex(Label);
299     DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
300     Die->addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value);
301   }
304 unsigned DwarfCompileUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
305   // If we print assembly, we can't separate .file entries according to
306   // compile units. Thus all files will belong to the default compile unit.
308   // FIXME: add a better feature test than hasRawTextSupport. Even better,
309   // extend .file to support this.
310   return Asm->OutStreamer.EmitDwarfFileDirective(
311       0, DirName, FileName,
312       Asm->OutStreamer.hasRawTextSupport() ? 0 : getUniqueID());
315 unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
316   return SplitLineTable ? SplitLineTable->getFile(DirName, FileName)
317                         : getCU().getOrCreateSourceID(FileName, DirName);
320 /// addOpAddress - Add a dwarf op address data and value using the
321 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
322 ///
323 void DwarfUnit::addOpAddress(DIELoc *Die, const MCSymbol *Sym) {
324   if (!DD->useSplitDwarf()) {
325     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
326     addLabel(Die, dwarf::DW_FORM_udata, Sym);
327   } else {
328     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
329     addUInt(Die, dwarf::DW_FORM_GNU_addr_index, DU->getAddrPoolIndex(Sym));
330   }
333 /// addSectionDelta - Add a section label delta attribute data and value.
334 ///
335 void DwarfUnit::addSectionDelta(DIE *Die, dwarf::Attribute Attribute,
336                                 const MCSymbol *Hi, const MCSymbol *Lo) {
337   DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
338   if (DD->getDwarfVersion() >= 4)
339     Die->addValue(Attribute, dwarf::DW_FORM_sec_offset, Value);
340   else
341     Die->addValue(Attribute, dwarf::DW_FORM_data4, Value);
344 void DwarfUnit::addLabelDelta(DIE *Die, dwarf::Attribute Attribute,
345                               const MCSymbol *Hi, const MCSymbol *Lo) {
346   DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
347   Die->addValue(Attribute, dwarf::DW_FORM_data4, Value);
350 /// addDIEEntry - Add a DIE attribute data and value.
351 ///
352 void DwarfUnit::addDIEEntry(DIE *Die, dwarf::Attribute Attribute, DIE *Entry) {
353   addDIEEntry(Die, Attribute, createDIEEntry(Entry));
356 void DwarfUnit::addDIETypeSignature(DIE *Die, const DwarfTypeUnit &Type) {
357   Die->addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
358                 new (DIEValueAllocator) DIETypeSignature(Type));
361 void DwarfUnit::addDIEEntry(DIE *Die, dwarf::Attribute Attribute,
362                             DIEEntry *Entry) {
363   const DIE *DieCU = Die->getUnitOrNull();
364   const DIE *EntryCU = Entry->getEntry()->getUnitOrNull();
365   if (!DieCU)
366     // We assume that Die belongs to this CU, if it is not linked to any CU yet.
367     DieCU = getUnitDie();
368   if (!EntryCU)
369     EntryCU = getUnitDie();
370   Die->addValue(Attribute, EntryCU == DieCU ? dwarf::DW_FORM_ref4
371                                             : dwarf::DW_FORM_ref_addr,
372                 Entry);
375 /// Create a DIE with the given Tag, add the DIE to its parent, and
376 /// call insertDIE if MD is not null.
377 DIE *DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) {
378   DIE *Die = new DIE(Tag);
379   Parent.addChild(Die);
380   if (N)
381     insertDIE(N, Die);
382   return Die;
385 /// addBlock - Add block data.
386 ///
387 void DwarfUnit::addBlock(DIE *Die, dwarf::Attribute Attribute, DIELoc *Loc) {
388   Loc->ComputeSize(Asm);
389   DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
390   Die->addValue(Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
393 void DwarfUnit::addBlock(DIE *Die, dwarf::Attribute Attribute,
394                          DIEBlock *Block) {
395   Block->ComputeSize(Asm);
396   DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
397   Die->addValue(Attribute, Block->BestForm(), Block);
400 /// addSourceLine - Add location information to specified debug information
401 /// entry.
402 void DwarfUnit::addSourceLine(DIE *Die, unsigned Line, StringRef File,
403                               StringRef Directory) {
404   if (Line == 0)
405     return;
407   unsigned FileID = getOrCreateSourceID(File, Directory);
408   assert(FileID && "Invalid file id");
409   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
410   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
413 /// addSourceLine - Add location information to specified debug information
414 /// entry.
415 void DwarfUnit::addSourceLine(DIE *Die, DIVariable V) {
416   assert(V.isVariable());
418   addSourceLine(Die, V.getLineNumber(), V.getContext().getFilename(),
419                 V.getContext().getDirectory());
422 /// addSourceLine - Add location information to specified debug information
423 /// entry.
424 void DwarfUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
425   assert(G.isGlobalVariable());
427   addSourceLine(Die, G.getLineNumber(), G.getFilename(), G.getDirectory());
430 /// addSourceLine - Add location information to specified debug information
431 /// entry.
432 void DwarfUnit::addSourceLine(DIE *Die, DISubprogram SP) {
433   assert(SP.isSubprogram());
435   addSourceLine(Die, SP.getLineNumber(), SP.getFilename(), SP.getDirectory());
438 /// addSourceLine - Add location information to specified debug information
439 /// entry.
440 void DwarfUnit::addSourceLine(DIE *Die, DIType Ty) {
441   assert(Ty.isType());
443   addSourceLine(Die, Ty.getLineNumber(), Ty.getFilename(), Ty.getDirectory());
446 /// addSourceLine - Add location information to specified debug information
447 /// entry.
448 void DwarfUnit::addSourceLine(DIE *Die, DIObjCProperty Ty) {
449   assert(Ty.isObjCProperty());
451   DIFile File = Ty.getFile();
452   addSourceLine(Die, Ty.getLineNumber(), File.getFilename(),
453                 File.getDirectory());
456 /// addSourceLine - Add location information to specified debug information
457 /// entry.
458 void DwarfUnit::addSourceLine(DIE *Die, DINameSpace NS) {
459   assert(NS.Verify());
461   addSourceLine(Die, NS.getLineNumber(), NS.getFilename(), NS.getDirectory());
464 /// addVariableAddress - Add DW_AT_location attribute for a
465 /// DbgVariable based on provided MachineLocation.
466 void DwarfUnit::addVariableAddress(const DbgVariable &DV, DIE *Die,
467                                    MachineLocation Location) {
468   if (DV.variableHasComplexAddress())
469     addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
470   else if (DV.isBlockByrefVariable())
471     addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
472   else
473     addAddress(Die, dwarf::DW_AT_location, Location,
474                DV.getVariable().isIndirect());
477 /// addRegisterOp - Add register operand.
478 void DwarfUnit::addRegisterOp(DIELoc *TheDie, unsigned Reg) {
479   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
480   int DWReg = RI->getDwarfRegNum(Reg, false);
481   bool isSubRegister = DWReg < 0;
483   unsigned Idx = 0;
485   // Go up the super-register chain until we hit a valid dwarf register number.
486   for (MCSuperRegIterator SR(Reg, RI); SR.isValid() && DWReg < 0; ++SR) {
487     DWReg = RI->getDwarfRegNum(*SR, false);
488     if (DWReg >= 0)
489       Idx = RI->getSubRegIndex(*SR, Reg);
490   }
492   if (DWReg < 0) {
493     DEBUG(dbgs() << "Invalid Dwarf register number.\n");
494     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_nop);
495     return;
496   }
498   // Emit register
499   if (DWReg < 32)
500     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
501   else {
502     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
503     addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
504   }
506   // Emit Mask
507   if (isSubRegister) {
508     unsigned Size = RI->getSubRegIdxSize(Idx);
509     unsigned Offset = RI->getSubRegIdxOffset(Idx);
510     if (Offset > 0) {
511       addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bit_piece);
512       addUInt(TheDie, dwarf::DW_FORM_data1, Size);
513       addUInt(TheDie, dwarf::DW_FORM_data1, Offset);
514     } else {
515       unsigned ByteSize = Size / 8; // Assuming 8 bits per byte.
516       addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_piece);
517       addUInt(TheDie, dwarf::DW_FORM_data1, ByteSize);
518     }
519   }
522 /// addRegisterOffset - Add register offset.
523 void DwarfUnit::addRegisterOffset(DIELoc *TheDie, unsigned Reg,
524                                   int64_t Offset) {
525   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
526   unsigned DWReg = RI->getDwarfRegNum(Reg, false);
527   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
528   if (Reg == TRI->getFrameRegister(*Asm->MF))
529     // If variable offset is based in frame register then use fbreg.
530     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
531   else if (DWReg < 32)
532     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
533   else {
534     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
535     addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
536   }
537   addSInt(TheDie, dwarf::DW_FORM_sdata, Offset);
540 /// addAddress - Add an address attribute to a die based on the location
541 /// provided.
542 void DwarfUnit::addAddress(DIE *Die, dwarf::Attribute Attribute,
543                            const MachineLocation &Location, bool Indirect) {
544   DIELoc *Loc = new (DIEValueAllocator) DIELoc();
546   if (Location.isReg() && !Indirect)
547     addRegisterOp(Loc, Location.getReg());
548   else {
549     addRegisterOffset(Loc, Location.getReg(), Location.getOffset());
550     if (Indirect && !Location.isReg()) {
551       addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
552     }
553   }
555   // Now attach the location information to the DIE.
556   addBlock(Die, Attribute, Loc);
559 /// addComplexAddress - Start with the address based on the location provided,
560 /// and generate the DWARF information necessary to find the actual variable
561 /// given the extra address information encoded in the DbgVariable, starting
562 /// from the starting location.  Add the DWARF information to the die.
563 ///
564 void DwarfUnit::addComplexAddress(const DbgVariable &DV, DIE *Die,
565                                   dwarf::Attribute Attribute,
566                                   const MachineLocation &Location) {
567   DIELoc *Loc = new (DIEValueAllocator) DIELoc();
568   unsigned N = DV.getNumAddrElements();
569   unsigned i = 0;
570   if (Location.isReg()) {
571     if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
572       // If first address element is OpPlus then emit
573       // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
574       addRegisterOffset(Loc, Location.getReg(), DV.getAddrElement(1));
575       i = 2;
576     } else
577       addRegisterOp(Loc, Location.getReg());
578   } else
579     addRegisterOffset(Loc, Location.getReg(), Location.getOffset());
581   for (; i < N; ++i) {
582     uint64_t Element = DV.getAddrElement(i);
583     if (Element == DIBuilder::OpPlus) {
584       addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
585       addUInt(Loc, dwarf::DW_FORM_udata, DV.getAddrElement(++i));
586     } else if (Element == DIBuilder::OpDeref) {
587       if (!Location.isReg())
588         addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
589     } else
590       llvm_unreachable("unknown DIBuilder Opcode");
591   }
593   // Now attach the location information to the DIE.
594   addBlock(Die, Attribute, Loc);
597 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
598    VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
599    gives the variable VarName either the struct, or a pointer to the struct, as
600    its type.  This is necessary for various behind-the-scenes things the
601    compiler needs to do with by-reference variables in Blocks.
603    However, as far as the original *programmer* is concerned, the variable
604    should still have type 'SomeType', as originally declared.
606    The function getBlockByrefType dives into the __Block_byref_x_VarName
607    struct to find the original type of the variable, which is then assigned to
608    the variable's Debug Information Entry as its real type.  So far, so good.
609    However now the debugger will expect the variable VarName to have the type
610    SomeType.  So we need the location attribute for the variable to be an
611    expression that explains to the debugger how to navigate through the
612    pointers and struct to find the actual variable of type SomeType.
614    The following function does just that.  We start by getting
615    the "normal" location for the variable. This will be the location
616    of either the struct __Block_byref_x_VarName or the pointer to the
617    struct __Block_byref_x_VarName.
619    The struct will look something like:
621    struct __Block_byref_x_VarName {
622      ... <various fields>
623      struct __Block_byref_x_VarName *forwarding;
624      ... <various other fields>
625      SomeType VarName;
626      ... <maybe more fields>
627    };
629    If we are given the struct directly (as our starting point) we
630    need to tell the debugger to:
632    1).  Add the offset of the forwarding field.
634    2).  Follow that pointer to get the real __Block_byref_x_VarName
635    struct to use (the real one may have been copied onto the heap).
637    3).  Add the offset for the field VarName, to find the actual variable.
639    If we started with a pointer to the struct, then we need to
640    dereference that pointer first, before the other steps.
641    Translating this into DWARF ops, we will need to append the following
642    to the current location description for the variable:
644    DW_OP_deref                    -- optional, if we start with a pointer
645    DW_OP_plus_uconst <forward_fld_offset>
646    DW_OP_deref
647    DW_OP_plus_uconst <varName_fld_offset>
649    That is what this function does.  */
651 /// addBlockByrefAddress - Start with the address based on the location
652 /// provided, and generate the DWARF information necessary to find the
653 /// actual Block variable (navigating the Block struct) based on the
654 /// starting location.  Add the DWARF information to the die.  For
655 /// more information, read large comment just above here.
656 ///
657 void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE *Die,
658                                      dwarf::Attribute Attribute,
659                                      const MachineLocation &Location) {
660   DIType Ty = DV.getType();
661   DIType TmpTy = Ty;
662   uint16_t Tag = Ty.getTag();
663   bool isPointer = false;
665   StringRef varName = DV.getName();
667   if (Tag == dwarf::DW_TAG_pointer_type) {
668     DIDerivedType DTy(Ty);
669     TmpTy = resolve(DTy.getTypeDerivedFrom());
670     isPointer = true;
671   }
673   DICompositeType blockStruct(TmpTy);
675   // Find the __forwarding field and the variable field in the __Block_byref
676   // struct.
677   DIArray Fields = blockStruct.getTypeArray();
678   DIDerivedType varField;
679   DIDerivedType forwardingField;
681   for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
682     DIDerivedType DT(Fields.getElement(i));
683     StringRef fieldName = DT.getName();
684     if (fieldName == "__forwarding")
685       forwardingField = DT;
686     else if (fieldName == varName)
687       varField = DT;
688   }
690   // Get the offsets for the forwarding field and the variable field.
691   unsigned forwardingFieldOffset = forwardingField.getOffsetInBits() >> 3;
692   unsigned varFieldOffset = varField.getOffsetInBits() >> 2;
694   // Decode the original location, and use that as the start of the byref
695   // variable's location.
696   DIELoc *Loc = new (DIEValueAllocator) DIELoc();
698   if (Location.isReg())
699     addRegisterOp(Loc, Location.getReg());
700   else
701     addRegisterOffset(Loc, Location.getReg(), Location.getOffset());
703   // If we started with a pointer to the __Block_byref... struct, then
704   // the first thing we need to do is dereference the pointer (DW_OP_deref).
705   if (isPointer)
706     addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
708   // Next add the offset for the '__forwarding' field:
709   // DW_OP_plus_uconst ForwardingFieldOffset.  Note there's no point in
710   // adding the offset if it's 0.
711   if (forwardingFieldOffset > 0) {
712     addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
713     addUInt(Loc, dwarf::DW_FORM_udata, forwardingFieldOffset);
714   }
716   // Now dereference the __forwarding field to get to the real __Block_byref
717   // struct:  DW_OP_deref.
718   addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
720   // Now that we've got the real __Block_byref... struct, add the offset
721   // for the variable's field to get to the location of the actual variable:
722   // DW_OP_plus_uconst varFieldOffset.  Again, don't add if it's 0.
723   if (varFieldOffset > 0) {
724     addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
725     addUInt(Loc, dwarf::DW_FORM_udata, varFieldOffset);
726   }
728   // Now attach the location information to the DIE.
729   addBlock(Die, Attribute, Loc);
732 /// isTypeSigned - Return true if the type is signed.
733 static bool isTypeSigned(DwarfDebug *DD, DIType Ty, int *SizeInBits) {
734   if (Ty.isDerivedType())
735     return isTypeSigned(DD, DD->resolve(DIDerivedType(Ty).getTypeDerivedFrom()),
736                         SizeInBits);
737   if (Ty.isBasicType())
738     if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed ||
739         DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
740       *SizeInBits = Ty.getSizeInBits();
741       return true;
742     }
743   return false;
746 /// Return true if type encoding is unsigned.
747 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
748   DIDerivedType DTy(Ty);
749   if (DTy.isDerivedType())
750     return isUnsignedDIType(DD, DD->resolve(DTy.getTypeDerivedFrom()));
752   DIBasicType BTy(Ty);
753   if (BTy.isBasicType()) {
754     unsigned Encoding = BTy.getEncoding();
755     if (Encoding == dwarf::DW_ATE_unsigned ||
756         Encoding == dwarf::DW_ATE_unsigned_char ||
757         Encoding == dwarf::DW_ATE_boolean)
758       return true;
759   }
760   return false;
763 /// If this type is derived from a base type then return base type size.
764 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
765   unsigned Tag = Ty.getTag();
767   if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
768       Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
769       Tag != dwarf::DW_TAG_restrict_type)
770     return Ty.getSizeInBits();
772   DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
774   // If this type is not derived from any type or the type is a declaration then
775   // take conservative approach.
776   if (!BaseType.isValid() || BaseType.isForwardDecl())
777     return Ty.getSizeInBits();
779   // If this is a derived type, go ahead and get the base type, unless it's a
780   // reference then it's just the size of the field. Pointer types have no need
781   // of this since they're a different type of qualification on the type.
782   if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
783       BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
784     return Ty.getSizeInBits();
786   if (BaseType.isDerivedType())
787     return getBaseTypeSize(DD, DIDerivedType(BaseType));
789   return BaseType.getSizeInBits();
792 /// addConstantValue - Add constant value entry in variable DIE.
793 void DwarfUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
794                                  DIType Ty) {
795   // FIXME: This is a bit conservative/simple - it emits negative values at
796   // their maximum bit width which is a bit unfortunate (& doesn't prefer
797   // udata/sdata over dataN as suggested by the DWARF spec)
798   assert(MO.isImm() && "Invalid machine operand!");
799   int SizeInBits = -1;
800   bool SignedConstant = isTypeSigned(DD, Ty, &SizeInBits);
801   dwarf::Form Form;
803   // If we're a signed constant definitely use sdata.
804   if (SignedConstant) {
805     addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, MO.getImm());
806     return;
807   }
809   // Else use data for now unless it's larger than we can deal with.
810   switch (SizeInBits) {
811   case 8:
812     Form = dwarf::DW_FORM_data1;
813     break;
814   case 16:
815     Form = dwarf::DW_FORM_data2;
816     break;
817   case 32:
818     Form = dwarf::DW_FORM_data4;
819     break;
820   case 64:
821     Form = dwarf::DW_FORM_data8;
822     break;
823   default:
824     Form = dwarf::DW_FORM_udata;
825     addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
826     return;
827   }
828   addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
831 /// addConstantFPValue - Add constant value entry in variable DIE.
832 void DwarfUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
833   assert(MO.isFPImm() && "Invalid machine operand!");
834   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
835   APFloat FPImm = MO.getFPImm()->getValueAPF();
837   // Get the raw data form of the floating point.
838   const APInt FltVal = FPImm.bitcastToAPInt();
839   const char *FltPtr = (const char *)FltVal.getRawData();
841   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
842   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
843   int Incr = (LittleEndian ? 1 : -1);
844   int Start = (LittleEndian ? 0 : NumBytes - 1);
845   int Stop = (LittleEndian ? NumBytes : -1);
847   // Output the constant to DWARF one byte at a time.
848   for (; Start != Stop; Start += Incr)
849     addUInt(Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
851   addBlock(Die, dwarf::DW_AT_const_value, Block);
854 /// addConstantFPValue - Add constant value entry in variable DIE.
855 void DwarfUnit::addConstantFPValue(DIE *Die, const ConstantFP *CFP) {
856   // Pass this down to addConstantValue as an unsigned bag of bits.
857   addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
860 /// addConstantValue - Add constant value entry in variable DIE.
861 void DwarfUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
862                                  bool Unsigned) {
863   addConstantValue(Die, CI->getValue(), Unsigned);
866 // addConstantValue - Add constant value entry in variable DIE.
867 void DwarfUnit::addConstantValue(DIE *Die, const APInt &Val, bool Unsigned) {
868   unsigned CIBitWidth = Val.getBitWidth();
869   if (CIBitWidth <= 64) {
870     // If we're a signed constant definitely use sdata.
871     if (!Unsigned) {
872       addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
873               Val.getSExtValue());
874       return;
875     }
877     // Else use data for now unless it's larger than we can deal with.
878     dwarf::Form Form;
879     switch (CIBitWidth) {
880     case 8:
881       Form = dwarf::DW_FORM_data1;
882       break;
883     case 16:
884       Form = dwarf::DW_FORM_data2;
885       break;
886     case 32:
887       Form = dwarf::DW_FORM_data4;
888       break;
889     case 64:
890       Form = dwarf::DW_FORM_data8;
891       break;
892     default:
893       addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
894               Val.getZExtValue());
895       return;
896     }
897     addUInt(Die, dwarf::DW_AT_const_value, Form, Val.getZExtValue());
898     return;
899   }
901   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
903   // Get the raw data form of the large APInt.
904   const uint64_t *Ptr64 = Val.getRawData();
906   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
907   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
909   // Output the constant to DWARF one byte at a time.
910   for (int i = 0; i < NumBytes; i++) {
911     uint8_t c;
912     if (LittleEndian)
913       c = Ptr64[i / 8] >> (8 * (i & 7));
914     else
915       c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
916     addUInt(Block, dwarf::DW_FORM_data1, c);
917   }
919   addBlock(Die, dwarf::DW_AT_const_value, Block);
922 /// addTemplateParams - Add template parameters into buffer.
923 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
924   // Add template parameters.
925   for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
926     DIDescriptor Element = TParams.getElement(i);
927     if (Element.isTemplateTypeParameter())
928       constructTemplateTypeParameterDIE(Buffer,
929                                         DITemplateTypeParameter(Element));
930     else if (Element.isTemplateValueParameter())
931       constructTemplateValueParameterDIE(Buffer,
932                                          DITemplateValueParameter(Element));
933   }
936 /// getOrCreateContextDIE - Get context owner's DIE.
937 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
938   if (!Context || Context.isFile())
939     return getUnitDie();
940   if (Context.isType())
941     return getOrCreateTypeDIE(DIType(Context));
942   if (Context.isNameSpace())
943     return getOrCreateNameSpace(DINameSpace(Context));
944   if (Context.isSubprogram())
945     return getOrCreateSubprogramDIE(DISubprogram(Context));
946   return getDIE(Context);
949 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
950   DIScope Context = resolve(Ty.getContext());
951   DIE *ContextDIE = getOrCreateContextDIE(Context);
953   DIE *TyDIE = getDIE(Ty);
954   if (TyDIE)
955     return TyDIE;
957   // Create new type.
958   TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
960   constructTypeDIE(*TyDIE, Ty);
962   updateAcceleratorTables(Context, Ty, TyDIE);
963   return TyDIE;
966 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
967 /// given DIType.
968 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
969   if (!TyNode)
970     return NULL;
972   DIType Ty(TyNode);
973   assert(Ty.isType());
974   assert(*&Ty == resolve(Ty.getRef()) &&
975          "type was not uniqued, possible ODR violation.");
977   // Construct the context before querying for the existence of the DIE in case
978   // such construction creates the DIE.
979   DIScope Context = resolve(Ty.getContext());
980   DIE *ContextDIE = getOrCreateContextDIE(Context);
981   assert(ContextDIE);
983   DIE *TyDIE = getDIE(Ty);
984   if (TyDIE)
985     return TyDIE;
987   // Create new type.
988   TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
990   updateAcceleratorTables(Context, Ty, TyDIE);
992   if (Ty.isBasicType())
993     constructTypeDIE(*TyDIE, DIBasicType(Ty));
994   else if (Ty.isCompositeType()) {
995     DICompositeType CTy(Ty);
996     if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
997       if (MDString *TypeId = CTy.getIdentifier()) {
998         DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
999         // Skip updating the accelerator tables since this is not the full type.
1000         return TyDIE;
1001       }
1002     constructTypeDIE(*TyDIE, CTy);
1003   } else {
1004     assert(Ty.isDerivedType() && "Unknown kind of DIType");
1005     constructTypeDIE(*TyDIE, DIDerivedType(Ty));
1006   }
1008   return TyDIE;
1011 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
1012                                         const DIE *TyDIE) {
1013   if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
1014     bool IsImplementation = 0;
1015     if (Ty.isCompositeType()) {
1016       DICompositeType CT(Ty);
1017       // A runtime language of 0 actually means C/C++ and that any
1018       // non-negative value is some version of Objective-C/C++.
1019       IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
1020     }
1021     unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
1022     addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
1024     if ((!Context || Context.isCompileUnit() || Context.isFile() ||
1025          Context.isNameSpace()) &&
1026         getCUNode().getEmissionKind() != DIBuilder::LineTablesOnly)
1027       GlobalTypes[getParentContextString(Context) + Ty.getName().str()] = TyDIE;
1028   }
1031 /// addType - Add a new type attribute to the specified entity.
1032 void DwarfUnit::addType(DIE *Entity, DIType Ty, dwarf::Attribute Attribute) {
1033   assert(Ty && "Trying to add a type that doesn't exist?");
1035   // Check for pre-existence.
1036   DIEEntry *Entry = getDIEEntry(Ty);
1037   // If it exists then use the existing value.
1038   if (Entry) {
1039     addDIEEntry(Entity, Attribute, Entry);
1040     return;
1041   }
1043   // Construct type.
1044   DIE *Buffer = getOrCreateTypeDIE(Ty);
1046   // Set up proxy.
1047   Entry = createDIEEntry(Buffer);
1048   insertDIEEntry(Ty, Entry);
1049   addDIEEntry(Entity, Attribute, Entry);
1052 // Accelerator table mutators - add each name along with its companion
1053 // DIE to the proper table while ensuring that the name that we're going
1054 // to reference is in the string table. We do this since the names we
1055 // add may not only be identical to the names in the DIE.
1056 void DwarfUnit::addAccelName(StringRef Name, const DIE *Die) {
1057   if (!DD->useDwarfAccelTables())
1058     return;
1059   DU->getStringPoolEntry(Name);
1060   std::vector<const DIE *> &DIEs = AccelNames[Name];
1061   DIEs.push_back(Die);
1064 void DwarfUnit::addAccelObjC(StringRef Name, const DIE *Die) {
1065   if (!DD->useDwarfAccelTables())
1066     return;
1067   DU->getStringPoolEntry(Name);
1068   std::vector<const DIE *> &DIEs = AccelObjC[Name];
1069   DIEs.push_back(Die);
1072 void DwarfUnit::addAccelNamespace(StringRef Name, const DIE *Die) {
1073   if (!DD->useDwarfAccelTables())
1074     return;
1075   DU->getStringPoolEntry(Name);
1076   std::vector<const DIE *> &DIEs = AccelNamespace[Name];
1077   DIEs.push_back(Die);
1080 void DwarfUnit::addAccelType(StringRef Name,
1081                              std::pair<const DIE *, unsigned> Die) {
1082   if (!DD->useDwarfAccelTables())
1083     return;
1084   DU->getStringPoolEntry(Name);
1085   std::vector<std::pair<const DIE *, unsigned> > &DIEs = AccelTypes[Name];
1086   DIEs.push_back(Die);
1089 /// addGlobalName - Add a new global name to the compile unit.
1090 void DwarfUnit::addGlobalName(StringRef Name, DIE *Die, DIScope Context) {
1091   if (getCUNode().getEmissionKind() == DIBuilder::LineTablesOnly)
1092     return;
1093   std::string FullName = getParentContextString(Context) + Name.str();
1094   GlobalNames[FullName] = Die;
1097 /// getParentContextString - Walks the metadata parent chain in a language
1098 /// specific manner (using the compile unit language) and returns
1099 /// it as a string. This is done at the metadata level because DIEs may
1100 /// not currently have been added to the parent context and walking the
1101 /// DIEs looking for names is more expensive than walking the metadata.
1102 std::string DwarfUnit::getParentContextString(DIScope Context) const {
1103   if (!Context)
1104     return "";
1106   // FIXME: Decide whether to implement this for non-C++ languages.
1107   if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
1108     return "";
1110   std::string CS;
1111   SmallVector<DIScope, 1> Parents;
1112   while (!Context.isCompileUnit()) {
1113     Parents.push_back(Context);
1114     if (Context.getContext())
1115       Context = resolve(Context.getContext());
1116     else
1117       // Structure, etc types will have a NULL context if they're at the top
1118       // level.
1119       break;
1120   }
1122   // Reverse iterate over our list to go from the outermost construct to the
1123   // innermost.
1124   for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
1125                                                   E = Parents.rend();
1126        I != E; ++I) {
1127     DIScope Ctx = *I;
1128     StringRef Name = Ctx.getName();
1129     if (!Name.empty()) {
1130       CS += Name;
1131       CS += "::";
1132     }
1133   }
1134   return CS;
1137 /// constructTypeDIE - Construct basic type die from DIBasicType.
1138 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
1139   // Get core information.
1140   StringRef Name = BTy.getName();
1141   // Add name if not anonymous or intermediate type.
1142   if (!Name.empty())
1143     addString(&Buffer, dwarf::DW_AT_name, Name);
1145   // An unspecified type only has a name attribute.
1146   if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
1147     return;
1149   addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1150           BTy.getEncoding());
1152   uint64_t Size = BTy.getSizeInBits() >> 3;
1153   addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1156 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1157 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1158   // Get core information.
1159   StringRef Name = DTy.getName();
1160   uint64_t Size = DTy.getSizeInBits() >> 3;
1161   uint16_t Tag = Buffer.getTag();
1163   // Map to main type, void will not have a type.
1164   DIType FromTy = resolve(DTy.getTypeDerivedFrom());
1165   if (FromTy)
1166     addType(&Buffer, FromTy);
1168   // Add name if not anonymous or intermediate type.
1169   if (!Name.empty())
1170     addString(&Buffer, dwarf::DW_AT_name, Name);
1172   // Add size if non-zero (derived types might be zero-sized.)
1173   if (Size && Tag != dwarf::DW_TAG_pointer_type)
1174     addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1176   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
1177     addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1178                 getOrCreateTypeDIE(resolve(DTy.getClassType())));
1179   // Add source line info if available and TyDesc is not a forward declaration.
1180   if (!DTy.isForwardDecl())
1181     addSourceLine(&Buffer, DTy);
1184 /// constructSubprogramArguments - Construct function argument DIEs.
1185 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DIArray Args) {
1186   for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1187     DIDescriptor Ty = Args.getElement(i);
1188     if (Ty.isUnspecifiedParameter()) {
1189       assert(i == N-1 && "Unspecified parameter must be the last argument");
1190       createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1191     } else {
1192       DIE *Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1193       addType(Arg, DIType(Ty));
1194       if (DIType(Ty).isArtificial())
1195         addFlag(Arg, dwarf::DW_AT_artificial);
1196     }
1197   }
1200 /// constructTypeDIE - Construct type DIE from DICompositeType.
1201 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1202   // Add name if not anonymous or intermediate type.
1203   StringRef Name = CTy.getName();
1205   uint64_t Size = CTy.getSizeInBits() >> 3;
1206   uint16_t Tag = Buffer.getTag();
1208   switch (Tag) {
1209   case dwarf::DW_TAG_array_type:
1210     constructArrayTypeDIE(Buffer, CTy);
1211     break;
1212   case dwarf::DW_TAG_enumeration_type:
1213     constructEnumTypeDIE(Buffer, CTy);
1214     break;
1215   case dwarf::DW_TAG_subroutine_type: {
1216     // Add return type. A void return won't have a type.
1217     DIArray Elements = CTy.getTypeArray();
1218     DIType RTy(Elements.getElement(0));
1219     if (RTy)
1220       addType(&Buffer, RTy);
1222     bool isPrototyped = true;
1223     if (Elements.getNumElements() == 2 &&
1224         Elements.getElement(1).isUnspecifiedParameter())
1225       isPrototyped = false;
1227     constructSubprogramArguments(Buffer, Elements);
1229     // Add prototype flag if we're dealing with a C language and the
1230     // function has been prototyped.
1231     uint16_t Language = getLanguage();
1232     if (isPrototyped &&
1233         (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1234          Language == dwarf::DW_LANG_ObjC))
1235       addFlag(&Buffer, dwarf::DW_AT_prototyped);
1237     if (CTy.isLValueReference())
1238       addFlag(&Buffer, dwarf::DW_AT_reference);
1240     if (CTy.isRValueReference())
1241       addFlag(&Buffer, dwarf::DW_AT_rvalue_reference);
1242   } break;
1243   case dwarf::DW_TAG_structure_type:
1244   case dwarf::DW_TAG_union_type:
1245   case dwarf::DW_TAG_class_type: {
1246     // Add elements to structure type.
1247     DIArray Elements = CTy.getTypeArray();
1248     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1249       DIDescriptor Element = Elements.getElement(i);
1250       DIE *ElemDie = NULL;
1251       if (Element.isSubprogram())
1252         ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
1253       else if (Element.isDerivedType()) {
1254         DIDerivedType DDTy(Element);
1255         if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1256           ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1257           addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1258                   dwarf::DW_AT_friend);
1259         } else if (DDTy.isStaticMember()) {
1260           getOrCreateStaticMemberDIE(DDTy);
1261         } else {
1262           constructMemberDIE(Buffer, DDTy);
1263         }
1264       } else if (Element.isObjCProperty()) {
1265         DIObjCProperty Property(Element);
1266         ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1267         StringRef PropertyName = Property.getObjCPropertyName();
1268         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1269         if (Property.getType())
1270           addType(ElemDie, Property.getType());
1271         addSourceLine(ElemDie, Property);
1272         StringRef GetterName = Property.getObjCPropertyGetterName();
1273         if (!GetterName.empty())
1274           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1275         StringRef SetterName = Property.getObjCPropertySetterName();
1276         if (!SetterName.empty())
1277           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1278         unsigned PropertyAttributes = 0;
1279         if (Property.isReadOnlyObjCProperty())
1280           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1281         if (Property.isReadWriteObjCProperty())
1282           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1283         if (Property.isAssignObjCProperty())
1284           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1285         if (Property.isRetainObjCProperty())
1286           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1287         if (Property.isCopyObjCProperty())
1288           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1289         if (Property.isNonAtomicObjCProperty())
1290           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1291         if (PropertyAttributes)
1292           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1293                   PropertyAttributes);
1295         DIEEntry *Entry = getDIEEntry(Element);
1296         if (!Entry) {
1297           Entry = createDIEEntry(ElemDie);
1298           insertDIEEntry(Element, Entry);
1299         }
1300       } else
1301         continue;
1302     }
1304     if (CTy.isAppleBlockExtension())
1305       addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
1307     DICompositeType ContainingType(resolve(CTy.getContainingType()));
1308     if (ContainingType)
1309       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1310                   getOrCreateTypeDIE(ContainingType));
1312     if (CTy.isObjcClassComplete())
1313       addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1315     // Add template parameters to a class, structure or union types.
1316     // FIXME: The support isn't in the metadata for this yet.
1317     if (Tag == dwarf::DW_TAG_class_type ||
1318         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1319       addTemplateParams(Buffer, CTy.getTemplateParams());
1321     break;
1322   }
1323   default:
1324     break;
1325   }
1327   // Add name if not anonymous or intermediate type.
1328   if (!Name.empty())
1329     addString(&Buffer, dwarf::DW_AT_name, Name);
1331   if (Tag == dwarf::DW_TAG_enumeration_type ||
1332       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1333       Tag == dwarf::DW_TAG_union_type) {
1334     // Add size if non-zero (derived types might be zero-sized.)
1335     // TODO: Do we care about size for enum forward declarations?
1336     if (Size)
1337       addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1338     else if (!CTy.isForwardDecl())
1339       // Add zero size if it is not a forward declaration.
1340       addUInt(&Buffer, dwarf::DW_AT_byte_size, None, 0);
1342     // If we're a forward decl, say so.
1343     if (CTy.isForwardDecl())
1344       addFlag(&Buffer, dwarf::DW_AT_declaration);
1346     // Add source line info if available.
1347     if (!CTy.isForwardDecl())
1348       addSourceLine(&Buffer, CTy);
1350     // No harm in adding the runtime language to the declaration.
1351     unsigned RLang = CTy.getRunTimeLang();
1352     if (RLang)
1353       addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1354               RLang);
1355   }
1358 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1359 /// DITemplateTypeParameter.
1360 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1361                                                   DITemplateTypeParameter TP) {
1362   DIE *ParamDIE =
1363       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1364   // Add the type if it exists, it could be void and therefore no type.
1365   if (TP.getType())
1366     addType(ParamDIE, resolve(TP.getType()));
1367   if (!TP.getName().empty())
1368     addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1371 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1372 /// DITemplateValueParameter.
1373 void
1374 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1375                                               DITemplateValueParameter VP) {
1376   DIE *ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1378   // Add the type if there is one, template template and template parameter
1379   // packs will not have a type.
1380   if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1381     addType(ParamDIE, resolve(VP.getType()));
1382   if (!VP.getName().empty())
1383     addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1384   if (Value *Val = VP.getValue()) {
1385     if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1386       addConstantValue(ParamDIE, CI,
1387                        isUnsignedDIType(DD, resolve(VP.getType())));
1388     else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1389       // For declaration non-type template parameters (such as global values and
1390       // functions)
1391       DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1392       addOpAddress(Loc, Asm->getSymbol(GV));
1393       // Emit DW_OP_stack_value to use the address as the immediate value of the
1394       // parameter, rather than a pointer to it.
1395       addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1396       addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1397     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1398       assert(isa<MDString>(Val));
1399       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1400                 cast<MDString>(Val)->getString());
1401     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1402       assert(isa<MDNode>(Val));
1403       DIArray A(cast<MDNode>(Val));
1404       addTemplateParams(*ParamDIE, A);
1405     }
1406   }
1409 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1410 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1411   // Construct the context before querying for the existence of the DIE in case
1412   // such construction creates the DIE.
1413   DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1415   DIE *NDie = getDIE(NS);
1416   if (NDie)
1417     return NDie;
1418   NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1420   if (!NS.getName().empty()) {
1421     addString(NDie, dwarf::DW_AT_name, NS.getName());
1422     addAccelNamespace(NS.getName(), NDie);
1423     addGlobalName(NS.getName(), NDie, NS.getContext());
1424   } else
1425     addAccelNamespace("(anonymous namespace)", NDie);
1426   addSourceLine(NDie, NS);
1427   return NDie;
1430 /// Unique C++ member function declarations based on their
1431 /// context and mangled name.
1432 DISubprogram
1433 DwarfUnit::getOdrUniqueSubprogram(DIScope Context, DISubprogram SP) const {
1434   if (!hasODR() ||
1435       !Context.isCompositeType() ||
1436       SP.getLinkageName().empty() ||
1437       SP.isDefinition())
1438     return SP;
1439   // Create a key with the UID of the parent class and this SP's name.
1440   Twine Key = SP.getContext().getName() + SP.getLinkageName();
1441   const MDNode *&Entry = DD->getOrCreateOdrMember(Key.str());
1442   if (!Entry)
1443     Entry = &*SP;
1445   return DISubprogram(Entry);
1448 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1449 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1450   // Construct the context before querying for the existence of the DIE in case
1451   // such construction creates the DIE (as is the case for member function
1452   // declarations).
1453   DIScope Context = resolve(SP.getContext());
1454   DIE *ContextDIE = getOrCreateContextDIE(Context);
1455   // Unique declarations based on the ODR, where applicable.
1456   SP = getOdrUniqueSubprogram(Context, SP);
1458   DIE *SPDie = getDIE(SP);
1459   if (SPDie)
1460     return SPDie;
1462   DISubprogram SPDecl = SP.getFunctionDeclaration();
1463   if (SPDecl.isSubprogram())
1464     // Add subprogram definitions to the CU die directly.
1465     ContextDIE = UnitDie.get();
1467   // DW_TAG_inlined_subroutine may refer to this DIE.
1468   SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1470   DIE *DeclDie = NULL;
1471   if (SPDecl.isSubprogram())
1472     DeclDie = getOrCreateSubprogramDIE(SPDecl);
1474   // Add function template parameters.
1475   addTemplateParams(*SPDie, SP.getTemplateParams());
1477   // If this DIE is going to refer declaration info using AT_specification
1478   // then there is no need to add other attributes.
1479   if (DeclDie) {
1480     // Refer function declaration directly.
1481     addDIEEntry(SPDie, dwarf::DW_AT_specification, DeclDie);
1483     return SPDie;
1484   }
1486   // Add the linkage name if we have one.
1487   StringRef LinkageName = SP.getLinkageName();
1488   if (!LinkageName.empty())
1489     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1490               GlobalValue::getRealLinkageName(LinkageName));
1492   // Constructors and operators for anonymous aggregates do not have names.
1493   if (!SP.getName().empty())
1494     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1496   addSourceLine(SPDie, SP);
1498   // Add the prototype if we have a prototype and we have a C like
1499   // language.
1500   uint16_t Language = getLanguage();
1501   if (SP.isPrototyped() &&
1502       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1503        Language == dwarf::DW_LANG_ObjC))
1504     addFlag(SPDie, dwarf::DW_AT_prototyped);
1506   DICompositeType SPTy = SP.getType();
1507   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1508          "the type of a subprogram should be a subroutine");
1510   DIArray Args = SPTy.getTypeArray();
1511   // Add a return type. If this is a type like a C/C++ void type we don't add a
1512   // return type.
1513   if (Args.getElement(0))
1514     addType(SPDie, DIType(Args.getElement(0)));
1516   unsigned VK = SP.getVirtuality();
1517   if (VK) {
1518     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1519     DIELoc *Block = getDIELoc();
1520     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1521     addUInt(Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1522     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1523     ContainingTypeMap.insert(
1524         std::make_pair(SPDie, resolve(SP.getContainingType())));
1525   }
1527   if (!SP.isDefinition()) {
1528     addFlag(SPDie, dwarf::DW_AT_declaration);
1530     // Add arguments. Do not add arguments for subprogram definition. They will
1531     // be handled while processing variables.
1532     constructSubprogramArguments(*SPDie, Args);
1533   }
1535   if (SP.isArtificial())
1536     addFlag(SPDie, dwarf::DW_AT_artificial);
1538   if (!SP.isLocalToUnit())
1539     addFlag(SPDie, dwarf::DW_AT_external);
1541   if (SP.isOptimized())
1542     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1544   if (unsigned isa = Asm->getISAEncoding()) {
1545     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1546   }
1548   if (SP.isLValueReference())
1549     addFlag(SPDie, dwarf::DW_AT_reference);
1551   if (SP.isRValueReference())
1552     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1554   if (SP.isProtected())
1555     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1556             dwarf::DW_ACCESS_protected);
1557   else if (SP.isPrivate())
1558     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1559             dwarf::DW_ACCESS_private);
1560   else
1561     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1562             dwarf::DW_ACCESS_public);
1564   if (SP.isExplicit())
1565     addFlag(SPDie, dwarf::DW_AT_explicit);
1567   return SPDie;
1570 // Return const expression if value is a GEP to access merged global
1571 // constant. e.g.
1572 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1573 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1574   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1575   if (!CE || CE->getNumOperands() != 3 ||
1576       CE->getOpcode() != Instruction::GetElementPtr)
1577     return NULL;
1579   // First operand points to a global struct.
1580   Value *Ptr = CE->getOperand(0);
1581   if (!isa<GlobalValue>(Ptr) ||
1582       !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1583     return NULL;
1585   // Second operand is zero.
1586   const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1587   if (!CI || !CI->isZero())
1588     return NULL;
1590   // Third operand is offset.
1591   if (!isa<ConstantInt>(CE->getOperand(2)))
1592     return NULL;
1594   return CE;
1597 /// createGlobalVariableDIE - create global variable DIE.
1598 void DwarfCompileUnit::createGlobalVariableDIE(DIGlobalVariable GV) {
1599   // Check for pre-existence.
1600   if (getDIE(GV))
1601     return;
1603   assert(GV.isGlobalVariable());
1605   DIScope GVContext = GV.getContext();
1606   DIType GTy = DD->resolve(GV.getType());
1608   // If this is a static data member definition, some attributes belong
1609   // to the declaration DIE.
1610   DIE *VariableDIE = NULL;
1611   bool IsStaticMember = false;
1612   DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1613   if (SDMDecl.Verify()) {
1614     assert(SDMDecl.isStaticMember() && "Expected static member decl");
1615     // We need the declaration DIE that is in the static member's class.
1616     VariableDIE = getOrCreateStaticMemberDIE(SDMDecl);
1617     IsStaticMember = true;
1618   }
1620   // If this is not a static data member definition, create the variable
1621   // DIE and add the initial set of attributes to it.
1622   if (!VariableDIE) {
1623     // Construct the context before querying for the existence of the DIE in
1624     // case such construction creates the DIE.
1625     DIE *ContextDIE = getOrCreateContextDIE(GVContext);
1627     // Add to map.
1628     VariableDIE = createAndAddDIE(GV.getTag(), *ContextDIE, GV);
1630     // Add name and type.
1631     addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1632     addType(VariableDIE, GTy);
1634     // Add scoping info.
1635     if (!GV.isLocalToUnit())
1636       addFlag(VariableDIE, dwarf::DW_AT_external);
1638     // Add line number info.
1639     addSourceLine(VariableDIE, GV);
1640   }
1642   // Add location.
1643   bool addToAccelTable = false;
1644   DIE *VariableSpecDIE = NULL;
1645   bool isGlobalVariable = GV.getGlobal() != NULL;
1646   if (isGlobalVariable) {
1647     addToAccelTable = true;
1648     DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1649     const MCSymbol *Sym = Asm->getSymbol(GV.getGlobal());
1650     if (GV.getGlobal()->isThreadLocal()) {
1651       // FIXME: Make this work with -gsplit-dwarf.
1652       unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1653       assert((PointerSize == 4 || PointerSize == 8) &&
1654              "Add support for other sizes if necessary");
1655       // Based on GCC's support for TLS:
1656       if (!DD->useSplitDwarf()) {
1657         // 1) Start with a constNu of the appropriate pointer size
1658         addUInt(Loc, dwarf::DW_FORM_data1,
1659                 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1660         // 2) containing the (relocated) offset of the TLS variable
1661         //    within the module's TLS block.
1662         addExpr(Loc, dwarf::DW_FORM_udata,
1663                 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym));
1664       } else {
1665         addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1666         addUInt(Loc, dwarf::DW_FORM_udata,
1667                 DU->getAddrPoolIndex(Sym, /* TLS */ true));
1668       }
1669       // 3) followed by a custom OP to make the debugger do a TLS lookup.
1670       addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_push_tls_address);
1671     } else {
1672       DD->addArangeLabel(SymbolCU(this, Sym));
1673       addOpAddress(Loc, Sym);
1674     }
1675     // Do not create specification DIE if context is either compile unit
1676     // or a subprogram.
1677     if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1678         !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1679       // Create specification DIE.
1680       VariableSpecDIE = createAndAddDIE(dwarf::DW_TAG_variable, *UnitDie);
1681       addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, VariableDIE);
1682       addBlock(VariableSpecDIE, dwarf::DW_AT_location, Loc);
1683       // A static member's declaration is already flagged as such.
1684       if (!SDMDecl.Verify())
1685         addFlag(VariableDIE, dwarf::DW_AT_declaration);
1686     } else {
1687       addBlock(VariableDIE, dwarf::DW_AT_location, Loc);
1688     }
1689     // Add the linkage name.
1690     StringRef LinkageName = GV.getLinkageName();
1691     if (!LinkageName.empty())
1692       // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1693       // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1694       // TAG_variable.
1695       addString(IsStaticMember && VariableSpecDIE ? VariableSpecDIE
1696                                                   : VariableDIE,
1697                 DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
1698                                            : dwarf::DW_AT_MIPS_linkage_name,
1699                 GlobalValue::getRealLinkageName(LinkageName));
1700   } else if (const ConstantInt *CI =
1701                  dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1702     // AT_const_value was added when the static member was created. To avoid
1703     // emitting AT_const_value multiple times, we only add AT_const_value when
1704     // it is not a static member.
1705     if (!IsStaticMember)
1706       addConstantValue(VariableDIE, CI, isUnsignedDIType(DD, GTy));
1707   } else if (const ConstantExpr *CE = getMergedGlobalExpr(GV->getOperand(11))) {
1708     addToAccelTable = true;
1709     // GV is a merged global.
1710     DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1711     Value *Ptr = CE->getOperand(0);
1712     MCSymbol *Sym = Asm->getSymbol(cast<GlobalValue>(Ptr));
1713     DD->addArangeLabel(SymbolCU(this, Sym));
1714     addOpAddress(Loc, Sym);
1715     addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1716     SmallVector<Value *, 3> Idx(CE->op_begin() + 1, CE->op_end());
1717     addUInt(Loc, dwarf::DW_FORM_udata,
1718             Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1719     addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1720     addBlock(VariableDIE, dwarf::DW_AT_location, Loc);
1721   }
1723   if (addToAccelTable) {
1724     DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1725     addAccelName(GV.getName(), AddrDIE);
1727     // If the linkage name is different than the name, go ahead and output
1728     // that as well into the name table.
1729     if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1730       addAccelName(GV.getLinkageName(), AddrDIE);
1731   }
1733   if (!GV.isLocalToUnit())
1734     addGlobalName(GV.getName(), VariableSpecDIE ? VariableSpecDIE : VariableDIE,
1735                   GV.getContext());
1738 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1739 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1740   DIE *DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1741   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, IndexTy);
1743   // The LowerBound value defines the lower bounds which is typically zero for
1744   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1745   // Count == -1 then the array is unbounded and we do not emit
1746   // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1747   // Count == 0, then the array has zero elements in which case we do not emit
1748   // an upper bound.
1749   int64_t LowerBound = SR.getLo();
1750   int64_t DefaultLowerBound = getDefaultLowerBound();
1751   int64_t Count = SR.getCount();
1753   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1754     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1756   if (Count != -1 && Count != 0)
1757     // FIXME: An unbounded array should reference the expression that defines
1758     // the array.
1759     addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, None,
1760             LowerBound + Count - 1);
1763 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1764 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1765   if (CTy.isVector())
1766     addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1768   // Emit the element type.
1769   addType(&Buffer, resolve(CTy.getTypeDerivedFrom()));
1771   // Get an anonymous type for index type.
1772   // FIXME: This type should be passed down from the front end
1773   // as different languages may have different sizes for indexes.
1774   DIE *IdxTy = getIndexTyDie();
1775   if (!IdxTy) {
1776     // Construct an anonymous type for index type.
1777     IdxTy = createAndAddDIE(dwarf::DW_TAG_base_type, *UnitDie);
1778     addString(IdxTy, dwarf::DW_AT_name, "int");
1779     addUInt(IdxTy, dwarf::DW_AT_byte_size, None, sizeof(int32_t));
1780     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1781             dwarf::DW_ATE_signed);
1782     setIndexTyDie(IdxTy);
1783   }
1785   // Add subranges to array type.
1786   DIArray Elements = CTy.getTypeArray();
1787   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1788     DIDescriptor Element = Elements.getElement(i);
1789     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1790       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1791   }
1794 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1795 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1796   DIArray Elements = CTy.getTypeArray();
1798   // Add enumerators to enumeration type.
1799   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1800     DIEnumerator Enum(Elements.getElement(i));
1801     if (Enum.isEnumerator()) {
1802       DIE *Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1803       StringRef Name = Enum.getName();
1804       addString(Enumerator, dwarf::DW_AT_name, Name);
1805       int64_t Value = Enum.getEnumValue();
1806       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1807               Value);
1808     }
1809   }
1810   DIType DTy = resolve(CTy.getTypeDerivedFrom());
1811   if (DTy) {
1812     addType(&Buffer, DTy);
1813     addFlag(&Buffer, dwarf::DW_AT_enum_class);
1814   }
1817 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1818 /// vtables.
1819 void DwarfUnit::constructContainingTypeDIEs() {
1820   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1821                                                  CE = ContainingTypeMap.end();
1822        CI != CE; ++CI) {
1823     DIE *SPDie = CI->first;
1824     DIDescriptor D(CI->second);
1825     if (!D)
1826       continue;
1827     DIE *NDie = getDIE(D);
1828     if (!NDie)
1829       continue;
1830     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, NDie);
1831   }
1834 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1835 DIE *DwarfUnit::constructVariableDIE(DbgVariable &DV, bool isScopeAbstract) {
1836   StringRef Name = DV.getName();
1838   // Define variable debug information entry.
1839   DIE *VariableDie = new DIE(DV.getTag());
1840   DbgVariable *AbsVar = DV.getAbstractVariable();
1841   DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1842   if (AbsDIE)
1843     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin, AbsDIE);
1844   else {
1845     if (!Name.empty())
1846       addString(VariableDie, dwarf::DW_AT_name, Name);
1847     addSourceLine(VariableDie, DV.getVariable());
1848     addType(VariableDie, DV.getType());
1849   }
1851   if (DV.isArtificial())
1852     addFlag(VariableDie, dwarf::DW_AT_artificial);
1854   if (isScopeAbstract) {
1855     DV.setDIE(VariableDie);
1856     return VariableDie;
1857   }
1859   // Add variable address.
1861   unsigned Offset = DV.getDotDebugLocOffset();
1862   if (Offset != ~0U) {
1863     addLocationList(VariableDie, dwarf::DW_AT_location, Offset);
1864     DV.setDIE(VariableDie);
1865     return VariableDie;
1866   }
1868   // Check if variable is described by a DBG_VALUE instruction.
1869   if (const MachineInstr *DVInsn = DV.getMInsn()) {
1870     assert(DVInsn->getNumOperands() == 3);
1871     if (DVInsn->getOperand(0).isReg()) {
1872       const MachineOperand RegOp = DVInsn->getOperand(0);
1873       // If the second operand is an immediate, this is an indirect value.
1874       if (DVInsn->getOperand(1).isImm()) {
1875         MachineLocation Location(RegOp.getReg(),
1876                                  DVInsn->getOperand(1).getImm());
1877         addVariableAddress(DV, VariableDie, Location);
1878       } else if (RegOp.getReg())
1879         addVariableAddress(DV, VariableDie, MachineLocation(RegOp.getReg()));
1880     } else if (DVInsn->getOperand(0).isImm())
1881       addConstantValue(VariableDie, DVInsn->getOperand(0), DV.getType());
1882     else if (DVInsn->getOperand(0).isFPImm())
1883       addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1884     else if (DVInsn->getOperand(0).isCImm())
1885       addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
1886                        isUnsignedDIType(DD, DV.getType()));
1888     DV.setDIE(VariableDie);
1889     return VariableDie;
1890   } else {
1891     // .. else use frame index.
1892     int FI = DV.getFrameIndex();
1893     if (FI != ~0) {
1894       unsigned FrameReg = 0;
1895       const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1896       int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1897       MachineLocation Location(FrameReg, Offset);
1898       addVariableAddress(DV, VariableDie, Location);
1899     }
1900   }
1902   DV.setDIE(VariableDie);
1903   return VariableDie;
1906 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1907 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1908   DIE *MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1909   StringRef Name = DT.getName();
1910   if (!Name.empty())
1911     addString(MemberDie, dwarf::DW_AT_name, Name);
1913   addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1915   addSourceLine(MemberDie, DT);
1917   if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1919     // For C++, virtual base classes are not at fixed offset. Use following
1920     // expression to extract appropriate offset from vtable.
1921     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1923     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1924     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1925     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1926     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1927     addUInt(VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1928     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1929     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1930     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1932     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1933   } else {
1934     uint64_t Size = DT.getSizeInBits();
1935     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1936     uint64_t OffsetInBytes;
1938     if (Size != FieldSize) {
1939       // Handle bitfield, assume bytes are 8 bits.
1940       addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1941       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1943       uint64_t Offset = DT.getOffsetInBits();
1944       uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1945       uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1946       uint64_t FieldOffset = (HiMark - FieldSize);
1947       Offset -= FieldOffset;
1949       // Maybe we need to work from the other end.
1950       if (Asm->getDataLayout().isLittleEndian())
1951         Offset = FieldSize - (Offset + Size);
1952       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1954       // Here DW_AT_data_member_location points to the anonymous
1955       // field that includes this bit field.
1956       OffsetInBytes = FieldOffset >> 3;
1957     } else
1958       // This is not a bitfield.
1959       OffsetInBytes = DT.getOffsetInBits() >> 3;
1961     if (DD->getDwarfVersion() <= 2) {
1962       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1963       addUInt(MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1964       addUInt(MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1965       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1966     } else
1967       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1968               OffsetInBytes);
1969   }
1971   if (DT.isProtected())
1972     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1973             dwarf::DW_ACCESS_protected);
1974   else if (DT.isPrivate())
1975     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1976             dwarf::DW_ACCESS_private);
1977   // Otherwise C++ member and base classes are considered public.
1978   else
1979     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1980             dwarf::DW_ACCESS_public);
1981   if (DT.isVirtual())
1982     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1983             dwarf::DW_VIRTUALITY_virtual);
1985   // Objective-C properties.
1986   if (MDNode *PNode = DT.getObjCProperty())
1987     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1988       MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1989                           PropertyDie);
1991   if (DT.isArtificial())
1992     addFlag(MemberDie, dwarf::DW_AT_artificial);
1995 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1996 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1997   if (!DT.Verify())
1998     return NULL;
2000   // Construct the context before querying for the existence of the DIE in case
2001   // such construction creates the DIE.
2002   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
2003   assert(dwarf::isType(ContextDIE->getTag()) &&
2004          "Static member should belong to a type.");
2006   DIE *StaticMemberDIE = getDIE(DT);
2007   if (StaticMemberDIE)
2008     return StaticMemberDIE;
2010   StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
2012   DIType Ty = resolve(DT.getTypeDerivedFrom());
2014   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
2015   addType(StaticMemberDIE, Ty);
2016   addSourceLine(StaticMemberDIE, DT);
2017   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
2018   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
2020   // FIXME: We could omit private if the parent is a class_type, and
2021   // public if the parent is something else.
2022   if (DT.isProtected())
2023     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
2024             dwarf::DW_ACCESS_protected);
2025   else if (DT.isPrivate())
2026     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
2027             dwarf::DW_ACCESS_private);
2028   else
2029     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
2030             dwarf::DW_ACCESS_public);
2032   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
2033     addConstantValue(StaticMemberDIE, CI, isUnsignedDIType(DD, Ty));
2034   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
2035     addConstantFPValue(StaticMemberDIE, CFP);
2037   return StaticMemberDIE;
2040 void DwarfUnit::emitHeader(const MCSection *ASection,
2041                            const MCSymbol *ASectionSym) const {
2042   Asm->OutStreamer.AddComment("DWARF version number");
2043   Asm->EmitInt16(DD->getDwarfVersion());
2044   Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2045   // We share one abbreviations table across all units so it's always at the
2046   // start of the section. Use a relocatable offset where needed to ensure
2047   // linking doesn't invalidate that offset.
2048   Asm->EmitSectionOffset(ASectionSym, ASectionSym);
2049   Asm->OutStreamer.AddComment("Address Size (in bytes)");
2050   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2053 void DwarfCompileUnit::initStmtList(MCSymbol *DwarfLineSectionSym) {
2054   // Define start line table label for each Compile Unit.
2055   MCSymbol *LineTableStartSym =
2056       Asm->GetTempSymbol("line_table_start", getUniqueID());
2057   Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
2058                                                      getUniqueID());
2060   // Use a single line table if we are generating assembly.
2061   bool UseTheFirstCU =
2062       Asm->OutStreamer.hasRawTextSupport() || (getUniqueID() == 0);
2064   stmtListIndex = UnitDie->getValues().size();
2066   // DW_AT_stmt_list is a offset of line number information for this
2067   // compile unit in debug_line section. For split dwarf this is
2068   // left in the skeleton CU and so not included.
2069   // The line table entries are not always emitted in assembly, so it
2070   // is not okay to use line_table_start here.
2071   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2072     addSectionLabel(UnitDie.get(), dwarf::DW_AT_stmt_list,
2073                     UseTheFirstCU ? DwarfLineSectionSym : LineTableStartSym);
2074   else if (UseTheFirstCU)
2075     addSectionOffset(UnitDie.get(), dwarf::DW_AT_stmt_list, 0);
2076   else
2077     addSectionDelta(UnitDie.get(), dwarf::DW_AT_stmt_list, LineTableStartSym,
2078                     DwarfLineSectionSym);
2081 void DwarfCompileUnit::applyStmtList(DIE &D) {
2082   D.addValue(dwarf::DW_AT_stmt_list,
2083              UnitDie->getAbbrev().getData()[stmtListIndex].getForm(),
2084              UnitDie->getValues()[stmtListIndex]);
2087 void DwarfTypeUnit::emitHeader(const MCSection *ASection,
2088                                const MCSymbol *ASectionSym) const {
2089   DwarfUnit::emitHeader(ASection, ASectionSym);
2090   Asm->OutStreamer.AddComment("Type Signature");
2091   Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
2092   Asm->OutStreamer.AddComment("Type DIE Offset");
2093   // In a skeleton type unit there is no type DIE so emit a zero offset.
2094   Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
2095                                 sizeof(Ty->getOffset()));
2098 void DwarfTypeUnit::initSection(const MCSection *Section) {
2099   assert(!this->Section);
2100   this->Section = Section;
2101   // Since each type unit is contained in its own COMDAT section, the begin
2102   // label and the section label are the same. Using the begin label emission in
2103   // DwarfDebug to emit the section label as well is slightly subtle/sneaky, but
2104   // the only other alternative of lazily constructing start-of-section labels
2105   // and storing a mapping in DwarfDebug (or AsmPrinter).
2106   this->SectionSym = this->LabelBegin =
2107       Asm->GetTempSymbol(Section->getLabelBeginName(), getUniqueID());
2108   this->LabelEnd =
2109       Asm->GetTempSymbol(Section->getLabelEndName(), getUniqueID());
2110   this->LabelRange = Asm->GetTempSymbol("gnu_ranges", getUniqueID());