typo
[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/DIBuilder.h"
21 #include "llvm/IR/Constants.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/MCSection.h"
28 #include "llvm/MC/MCStreamer.h"
29 #include "llvm/Support/CommandLine.h"
30 #include "llvm/Target/TargetFrameLowering.h"
31 #include "llvm/Target/TargetLoweringObjectFile.h"
32 #include "llvm/Target/TargetMachine.h"
33 #include "llvm/Target/TargetRegisterInfo.h"
35 using namespace llvm;
37 static cl::opt<bool>
38 GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
39                        cl::desc("Generate DWARF4 type units."),
40                        cl::init(false));
42 /// Unit - Unit constructor.
43 DwarfUnit::DwarfUnit(unsigned UID, DIE *D, DICompileUnit Node, AsmPrinter *A,
44                      DwarfDebug *DW, DwarfFile *DWU)
45     : UniqueID(UID), CUNode(Node), UnitDie(D), DebugInfoOffset(0), Asm(A),
46       DD(DW), DU(DWU), IndexTyDie(0), Section(0), Skeleton(0) {
47   DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
48 }
50 DwarfCompileUnit::DwarfCompileUnit(unsigned UID, DIE *D, DICompileUnit Node,
51                                    AsmPrinter *A, DwarfDebug *DW,
52                                    DwarfFile *DWU)
53     : DwarfUnit(UID, D, Node, A, DW, DWU) {
54   insertDIE(Node, D);
55 }
57 DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DIE *D, DICompileUnit CUNode,
58                              AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
59     : DwarfUnit(UID, D, CUNode, A, DW, DWU) {}
61 /// ~Unit - Destructor for compile unit.
62 DwarfUnit::~DwarfUnit() {
63   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
64     DIEBlocks[j]->~DIEBlock();
65 }
67 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
68 /// information entry.
69 DIEEntry *DwarfUnit::createDIEEntry(DIE *Entry) {
70   DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
71   return Value;
72 }
74 /// getDefaultLowerBound - Return the default lower bound for an array. If the
75 /// DWARF version doesn't handle the language, return -1.
76 int64_t DwarfUnit::getDefaultLowerBound() const {
77   switch (getLanguage()) {
78   default:
79     break;
81   case dwarf::DW_LANG_C89:
82   case dwarf::DW_LANG_C99:
83   case dwarf::DW_LANG_C:
84   case dwarf::DW_LANG_C_plus_plus:
85   case dwarf::DW_LANG_ObjC:
86   case dwarf::DW_LANG_ObjC_plus_plus:
87     return 0;
89   case dwarf::DW_LANG_Fortran77:
90   case dwarf::DW_LANG_Fortran90:
91   case dwarf::DW_LANG_Fortran95:
92     return 1;
94   // The languages below have valid values only if the DWARF version >= 4.
95   case dwarf::DW_LANG_Java:
96   case dwarf::DW_LANG_Python:
97   case dwarf::DW_LANG_UPC:
98   case dwarf::DW_LANG_D:
99     if (dwarf::DWARF_VERSION >= 4)
100       return 0;
101     break;
103   case dwarf::DW_LANG_Ada83:
104   case dwarf::DW_LANG_Ada95:
105   case dwarf::DW_LANG_Cobol74:
106   case dwarf::DW_LANG_Cobol85:
107   case dwarf::DW_LANG_Modula2:
108   case dwarf::DW_LANG_Pascal83:
109   case dwarf::DW_LANG_PLI:
110     if (dwarf::DWARF_VERSION >= 4)
111       return 1;
112     break;
113   }
115   return -1;
118 /// Check whether the DIE for this MDNode can be shared across CUs.
119 static bool isShareableAcrossCUs(DIDescriptor D) {
120   // When the MDNode can be part of the type system, the DIE can be shared
121   // across CUs.
122   // Combining type units and cross-CU DIE sharing is lower value (since
123   // cross-CU DIE sharing is used in LTO and removes type redundancy at that
124   // level already) but may be implementable for some value in projects
125   // building multiple independent libraries with LTO and then linking those
126   // together.
127   return (D.isType() ||
128           (D.isSubprogram() && !DISubprogram(D).isDefinition())) &&
129          !GenerateDwarfTypeUnits;
132 /// getDIE - Returns the debug information entry map slot for the
133 /// specified debug variable. We delegate the request to DwarfDebug
134 /// when the DIE for this MDNode can be shared across CUs. The mappings
135 /// will be kept in DwarfDebug for shareable DIEs.
136 DIE *DwarfUnit::getDIE(DIDescriptor D) const {
137   if (isShareableAcrossCUs(D))
138     return DD->getDIE(D);
139   return MDNodeToDieMap.lookup(D);
142 /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
143 /// when the DIE for this MDNode can be shared across CUs. The mappings
144 /// will be kept in DwarfDebug for shareable DIEs.
145 void DwarfUnit::insertDIE(DIDescriptor Desc, DIE *D) {
146   if (isShareableAcrossCUs(Desc)) {
147     DD->insertDIE(Desc, D);
148     return;
149   }
150   MDNodeToDieMap.insert(std::make_pair(Desc, D));
153 /// addFlag - Add a flag that is true.
154 void DwarfUnit::addFlag(DIE *Die, dwarf::Attribute Attribute) {
155   if (DD->getDwarfVersion() >= 4)
156     Die->addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
157   else
158     Die->addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
161 /// addUInt - Add an unsigned integer attribute data and value.
162 ///
163 void DwarfUnit::addUInt(DIE *Die, dwarf::Attribute Attribute,
164                         Optional<dwarf::Form> Form, uint64_t Integer) {
165   if (!Form)
166     Form = DIEInteger::BestForm(false, Integer);
167   DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
168                         DIEInteger(Integer);
169   Die->addValue(Attribute, *Form, Value);
172 void DwarfUnit::addUInt(DIEBlock *Block, dwarf::Form Form, uint64_t Integer) {
173   addUInt(Block, (dwarf::Attribute)0, Form, Integer);
176 /// addSInt - Add an signed integer attribute data and value.
177 ///
178 void DwarfUnit::addSInt(DIE *Die, dwarf::Attribute Attribute,
179                         Optional<dwarf::Form> Form, int64_t Integer) {
180   if (!Form)
181     Form = DIEInteger::BestForm(true, Integer);
182   DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
183   Die->addValue(Attribute, *Form, Value);
186 void DwarfUnit::addSInt(DIEBlock *Die, Optional<dwarf::Form> Form,
187                         int64_t Integer) {
188   addSInt(Die, (dwarf::Attribute)0, Form, Integer);
191 /// addString - Add a string attribute data and value. We always emit a
192 /// reference to the string pool instead of immediate strings so that DIEs have
193 /// more predictable sizes. In the case of split dwarf we emit an index
194 /// into another table which gets us the static offset into the string
195 /// table.
196 void DwarfUnit::addString(DIE *Die, dwarf::Attribute Attribute,
197                           StringRef String) {
199   if (!DD->useSplitDwarf())
200     return addLocalString(Die, Attribute, String);
202   unsigned idx = DU->getStringPoolIndex(String);
203   DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
204   DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
205   Die->addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Str);
208 /// addLocalString - Add a string attribute data and value. This is guaranteed
209 /// to be in the local string pool instead of indirected.
210 void DwarfUnit::addLocalString(DIE *Die, dwarf::Attribute Attribute,
211                                StringRef String) {
212   MCSymbol *Symb = DU->getStringPoolEntry(String);
213   DIEValue *Value;
214   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
215     Value = new (DIEValueAllocator) DIELabel(Symb);
216   else {
217     MCSymbol *StringPool = DU->getStringPoolSym();
218     Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
219   }
220   DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
221   Die->addValue(Attribute, dwarf::DW_FORM_strp, Str);
224 /// addExpr - Add a Dwarf expression attribute data and value.
225 ///
226 void DwarfUnit::addExpr(DIEBlock *Die, dwarf::Form Form, const MCExpr *Expr) {
227   DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr);
228   Die->addValue((dwarf::Attribute)0, Form, Value);
231 /// addLabel - Add a Dwarf label attribute data and value.
232 ///
233 void DwarfUnit::addLabel(DIE *Die, dwarf::Attribute Attribute, dwarf::Form Form,
234                          const MCSymbol *Label) {
235   DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
236   Die->addValue(Attribute, Form, Value);
239 void DwarfUnit::addLabel(DIEBlock *Die, dwarf::Form Form,
240                          const MCSymbol *Label) {
241   addLabel(Die, (dwarf::Attribute)0, Form, Label);
244 /// addSectionLabel - Add a Dwarf section label attribute data and value.
245 ///
246 void DwarfUnit::addSectionLabel(DIE *Die, dwarf::Attribute Attribute,
247                                 const MCSymbol *Label) {
248   if (DD->getDwarfVersion() >= 4)
249     addLabel(Die, Attribute, dwarf::DW_FORM_sec_offset, Label);
250   else
251     addLabel(Die, Attribute, dwarf::DW_FORM_data4, Label);
254 /// addSectionOffset - Add an offset into a section attribute data and value.
255 ///
256 void DwarfUnit::addSectionOffset(DIE *Die, dwarf::Attribute Attribute,
257                                  uint64_t Integer) {
258   if (DD->getDwarfVersion() >= 4)
259     addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
260   else
261     addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
264 /// addLabelAddress - Add a dwarf label attribute data and value using
265 /// DW_FORM_addr or DW_FORM_GNU_addr_index.
266 ///
267 void DwarfCompileUnit::addLabelAddress(DIE *Die, dwarf::Attribute Attribute,
268                                        MCSymbol *Label) {
269   if (Label)
270     DD->addArangeLabel(SymbolCU(this, Label));
272   if (!DD->useSplitDwarf()) {
273     if (Label) {
274       DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
275       Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
276     } else {
277       DIEValue *Value = new (DIEValueAllocator) DIEInteger(0);
278       Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
279     }
280   } else {
281     unsigned idx = DU->getAddrPoolIndex(Label);
282     DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
283     Die->addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value);
284   }
287 /// addOpAddress - Add a dwarf op address data and value using the
288 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
289 ///
290 void DwarfUnit::addOpAddress(DIEBlock *Die, const MCSymbol *Sym) {
291   if (!DD->useSplitDwarf()) {
292     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
293     addLabel(Die, dwarf::DW_FORM_udata, Sym);
294   } else {
295     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
296     addUInt(Die, dwarf::DW_FORM_GNU_addr_index, DU->getAddrPoolIndex(Sym));
297   }
300 /// addSectionDelta - Add a section label delta attribute data and value.
301 ///
302 void DwarfUnit::addSectionDelta(DIE *Die, dwarf::Attribute Attribute,
303                                 const MCSymbol *Hi, const MCSymbol *Lo) {
304   DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
305   if (DD->getDwarfVersion() >= 4)
306     Die->addValue(Attribute, dwarf::DW_FORM_sec_offset, Value);
307   else
308     Die->addValue(Attribute, dwarf::DW_FORM_data4, Value);
311 /// addDIEEntry - Add a DIE attribute data and value.
312 ///
313 void DwarfUnit::addDIEEntry(DIE *Die, dwarf::Attribute Attribute, DIE *Entry) {
314   addDIEEntry(Die, Attribute, createDIEEntry(Entry));
317 void DwarfUnit::addDIETypeSignature(DIE *Die, const DwarfTypeUnit &Type) {
318   Die->addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
319                 new (DIEValueAllocator) DIETypeSignature(Type));
322 void DwarfUnit::addDIEEntry(DIE *Die, dwarf::Attribute Attribute,
323                             DIEEntry *Entry) {
324   const DIE *DieCU = Die->getUnitOrNull();
325   const DIE *EntryCU = Entry->getEntry()->getUnitOrNull();
326   if (!DieCU)
327     // We assume that Die belongs to this CU, if it is not linked to any CU yet.
328     DieCU = getUnitDie();
329   if (!EntryCU)
330     EntryCU = getUnitDie();
331   Die->addValue(Attribute, EntryCU == DieCU ? dwarf::DW_FORM_ref4
332                                             : dwarf::DW_FORM_ref_addr,
333                 Entry);
336 /// Create a DIE with the given Tag, add the DIE to its parent, and
337 /// call insertDIE if MD is not null.
338 DIE *DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) {
339   DIE *Die = new DIE(Tag);
340   Parent.addChild(Die);
341   if (N)
342     insertDIE(N, Die);
343   return Die;
346 /// addBlock - Add block data.
347 ///
348 void DwarfUnit::addBlock(DIE *Die, dwarf::Attribute Attribute,
349                          DIEBlock *Block) {
350   Block->ComputeSize(Asm);
351   DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
352   Die->addValue(Attribute, Block->BestForm(), Block);
355 /// addSourceLine - Add location information to specified debug information
356 /// entry.
357 void DwarfUnit::addSourceLine(DIE *Die, DIVariable V) {
358   // Verify variable.
359   if (!V.isVariable())
360     return;
362   unsigned Line = V.getLineNumber();
363   if (Line == 0)
364     return;
365   unsigned FileID =
366       DD->getOrCreateSourceID(V.getContext().getFilename(),
367                               V.getContext().getDirectory(), getUniqueID());
368   assert(FileID && "Invalid file id");
369   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
370   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
373 /// addSourceLine - Add location information to specified debug information
374 /// entry.
375 void DwarfUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
376   // Verify global variable.
377   if (!G.isGlobalVariable())
378     return;
380   unsigned Line = G.getLineNumber();
381   if (Line == 0)
382     return;
383   unsigned FileID =
384       DD->getOrCreateSourceID(G.getFilename(), G.getDirectory(), getUniqueID());
385   assert(FileID && "Invalid file id");
386   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
387   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
390 /// addSourceLine - Add location information to specified debug information
391 /// entry.
392 void DwarfUnit::addSourceLine(DIE *Die, DISubprogram SP) {
393   // Verify subprogram.
394   if (!SP.isSubprogram())
395     return;
397   // If the line number is 0, don't add it.
398   unsigned Line = SP.getLineNumber();
399   if (Line == 0)
400     return;
402   unsigned FileID = DD->getOrCreateSourceID(SP.getFilename(), SP.getDirectory(),
403                                             getUniqueID());
404   assert(FileID && "Invalid file id");
405   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
406   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
409 /// addSourceLine - Add location information to specified debug information
410 /// entry.
411 void DwarfUnit::addSourceLine(DIE *Die, DIType Ty) {
412   // Verify type.
413   if (!Ty.isType())
414     return;
416   unsigned Line = Ty.getLineNumber();
417   if (Line == 0)
418     return;
419   unsigned FileID = DD->getOrCreateSourceID(Ty.getFilename(), Ty.getDirectory(),
420                                             getUniqueID());
421   assert(FileID && "Invalid file id");
422   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
423   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
426 /// addSourceLine - Add location information to specified debug information
427 /// entry.
428 void DwarfUnit::addSourceLine(DIE *Die, DIObjCProperty Ty) {
429   // Verify type.
430   if (!Ty.isObjCProperty())
431     return;
433   unsigned Line = Ty.getLineNumber();
434   if (Line == 0)
435     return;
436   DIFile File = Ty.getFile();
437   unsigned FileID = DD->getOrCreateSourceID(File.getFilename(),
438                                             File.getDirectory(), getUniqueID());
439   assert(FileID && "Invalid file id");
440   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
441   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
444 /// addSourceLine - Add location information to specified debug information
445 /// entry.
446 void DwarfUnit::addSourceLine(DIE *Die, DINameSpace NS) {
447   // Verify namespace.
448   if (!NS.Verify())
449     return;
451   unsigned Line = NS.getLineNumber();
452   if (Line == 0)
453     return;
454   StringRef FN = NS.getFilename();
456   unsigned FileID =
457       DD->getOrCreateSourceID(FN, NS.getDirectory(), getUniqueID());
458   assert(FileID && "Invalid file id");
459   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
460   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
463 /// addVariableAddress - Add DW_AT_location attribute for a
464 /// DbgVariable based on provided MachineLocation.
465 void DwarfUnit::addVariableAddress(const DbgVariable &DV, DIE *Die,
466                                    MachineLocation Location) {
467   if (DV.variableHasComplexAddress())
468     addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
469   else if (DV.isBlockByrefVariable())
470     addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
471   else
472     addAddress(Die, dwarf::DW_AT_location, Location,
473                DV.getVariable().isIndirect());
476 /// addRegisterOp - Add register operand.
477 void DwarfUnit::addRegisterOp(DIEBlock *TheDie, unsigned Reg) {
478   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
479   unsigned DWReg = RI->getDwarfRegNum(Reg, false);
480   if (DWReg < 32)
481     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
482   else {
483     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
484     addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
485   }
488 /// addRegisterOffset - Add register offset.
489 void DwarfUnit::addRegisterOffset(DIEBlock *TheDie, unsigned Reg,
490                                   int64_t Offset) {
491   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
492   unsigned DWReg = RI->getDwarfRegNum(Reg, false);
493   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
494   if (Reg == TRI->getFrameRegister(*Asm->MF))
495     // If variable offset is based in frame register then use fbreg.
496     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
497   else if (DWReg < 32)
498     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
499   else {
500     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
501     addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
502   }
503   addSInt(TheDie, dwarf::DW_FORM_sdata, Offset);
506 /// addAddress - Add an address attribute to a die based on the location
507 /// provided.
508 void DwarfUnit::addAddress(DIE *Die, dwarf::Attribute Attribute,
509                            const MachineLocation &Location, bool Indirect) {
510   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
512   if (Location.isReg() && !Indirect)
513     addRegisterOp(Block, Location.getReg());
514   else {
515     addRegisterOffset(Block, Location.getReg(), Location.getOffset());
516     if (Indirect && !Location.isReg()) {
517       addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
518     }
519   }
521   // Now attach the location information to the DIE.
522   addBlock(Die, Attribute, Block);
525 /// addComplexAddress - Start with the address based on the location provided,
526 /// and generate the DWARF information necessary to find the actual variable
527 /// given the extra address information encoded in the DbgVariable, starting
528 /// from the starting location.  Add the DWARF information to the die.
529 ///
530 void DwarfUnit::addComplexAddress(const DbgVariable &DV, DIE *Die,
531                                   dwarf::Attribute Attribute,
532                                   const MachineLocation &Location) {
533   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
534   unsigned N = DV.getNumAddrElements();
535   unsigned i = 0;
536   if (Location.isReg()) {
537     if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
538       // If first address element is OpPlus then emit
539       // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
540       addRegisterOffset(Block, Location.getReg(), DV.getAddrElement(1));
541       i = 2;
542     } else
543       addRegisterOp(Block, Location.getReg());
544   } else
545     addRegisterOffset(Block, Location.getReg(), Location.getOffset());
547   for (; i < N; ++i) {
548     uint64_t Element = DV.getAddrElement(i);
549     if (Element == DIBuilder::OpPlus) {
550       addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
551       addUInt(Block, dwarf::DW_FORM_udata, DV.getAddrElement(++i));
552     } else if (Element == DIBuilder::OpDeref) {
553       if (!Location.isReg())
554         addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
555     } else
556       llvm_unreachable("unknown DIBuilder Opcode");
557   }
559   // Now attach the location information to the DIE.
560   addBlock(Die, Attribute, Block);
563 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
564    VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
565    gives the variable VarName either the struct, or a pointer to the struct, as
566    its type.  This is necessary for various behind-the-scenes things the
567    compiler needs to do with by-reference variables in Blocks.
569    However, as far as the original *programmer* is concerned, the variable
570    should still have type 'SomeType', as originally declared.
572    The function getBlockByrefType dives into the __Block_byref_x_VarName
573    struct to find the original type of the variable, which is then assigned to
574    the variable's Debug Information Entry as its real type.  So far, so good.
575    However now the debugger will expect the variable VarName to have the type
576    SomeType.  So we need the location attribute for the variable to be an
577    expression that explains to the debugger how to navigate through the
578    pointers and struct to find the actual variable of type SomeType.
580    The following function does just that.  We start by getting
581    the "normal" location for the variable. This will be the location
582    of either the struct __Block_byref_x_VarName or the pointer to the
583    struct __Block_byref_x_VarName.
585    The struct will look something like:
587    struct __Block_byref_x_VarName {
588      ... <various fields>
589      struct __Block_byref_x_VarName *forwarding;
590      ... <various other fields>
591      SomeType VarName;
592      ... <maybe more fields>
593    };
595    If we are given the struct directly (as our starting point) we
596    need to tell the debugger to:
598    1).  Add the offset of the forwarding field.
600    2).  Follow that pointer to get the real __Block_byref_x_VarName
601    struct to use (the real one may have been copied onto the heap).
603    3).  Add the offset for the field VarName, to find the actual variable.
605    If we started with a pointer to the struct, then we need to
606    dereference that pointer first, before the other steps.
607    Translating this into DWARF ops, we will need to append the following
608    to the current location description for the variable:
610    DW_OP_deref                    -- optional, if we start with a pointer
611    DW_OP_plus_uconst <forward_fld_offset>
612    DW_OP_deref
613    DW_OP_plus_uconst <varName_fld_offset>
615    That is what this function does.  */
617 /// addBlockByrefAddress - Start with the address based on the location
618 /// provided, and generate the DWARF information necessary to find the
619 /// actual Block variable (navigating the Block struct) based on the
620 /// starting location.  Add the DWARF information to the die.  For
621 /// more information, read large comment just above here.
622 ///
623 void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE *Die,
624                                      dwarf::Attribute Attribute,
625                                      const MachineLocation &Location) {
626   DIType Ty = DV.getType();
627   DIType TmpTy = Ty;
628   uint16_t Tag = Ty.getTag();
629   bool isPointer = false;
631   StringRef varName = DV.getName();
633   if (Tag == dwarf::DW_TAG_pointer_type) {
634     DIDerivedType DTy(Ty);
635     TmpTy = resolve(DTy.getTypeDerivedFrom());
636     isPointer = true;
637   }
639   DICompositeType blockStruct(TmpTy);
641   // Find the __forwarding field and the variable field in the __Block_byref
642   // struct.
643   DIArray Fields = blockStruct.getTypeArray();
644   DIDerivedType varField;
645   DIDerivedType forwardingField;
647   for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
648     DIDerivedType DT(Fields.getElement(i));
649     StringRef fieldName = DT.getName();
650     if (fieldName == "__forwarding")
651       forwardingField = DT;
652     else if (fieldName == varName)
653       varField = DT;
654   }
656   // Get the offsets for the forwarding field and the variable field.
657   unsigned forwardingFieldOffset = forwardingField.getOffsetInBits() >> 3;
658   unsigned varFieldOffset = varField.getOffsetInBits() >> 2;
660   // Decode the original location, and use that as the start of the byref
661   // variable's location.
662   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
664   if (Location.isReg())
665     addRegisterOp(Block, Location.getReg());
666   else
667     addRegisterOffset(Block, Location.getReg(), Location.getOffset());
669   // If we started with a pointer to the __Block_byref... struct, then
670   // the first thing we need to do is dereference the pointer (DW_OP_deref).
671   if (isPointer)
672     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
674   // Next add the offset for the '__forwarding' field:
675   // DW_OP_plus_uconst ForwardingFieldOffset.  Note there's no point in
676   // adding the offset if it's 0.
677   if (forwardingFieldOffset > 0) {
678     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
679     addUInt(Block, dwarf::DW_FORM_udata, forwardingFieldOffset);
680   }
682   // Now dereference the __forwarding field to get to the real __Block_byref
683   // struct:  DW_OP_deref.
684   addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
686   // Now that we've got the real __Block_byref... struct, add the offset
687   // for the variable's field to get to the location of the actual variable:
688   // DW_OP_plus_uconst varFieldOffset.  Again, don't add if it's 0.
689   if (varFieldOffset > 0) {
690     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
691     addUInt(Block, dwarf::DW_FORM_udata, varFieldOffset);
692   }
694   // Now attach the location information to the DIE.
695   addBlock(Die, Attribute, Block);
698 /// isTypeSigned - Return true if the type is signed.
699 static bool isTypeSigned(DwarfDebug *DD, DIType Ty, int *SizeInBits) {
700   if (Ty.isDerivedType())
701     return isTypeSigned(DD, DD->resolve(DIDerivedType(Ty).getTypeDerivedFrom()),
702                         SizeInBits);
703   if (Ty.isBasicType())
704     if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed ||
705         DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
706       *SizeInBits = Ty.getSizeInBits();
707       return true;
708     }
709   return false;
712 /// Return true if type encoding is unsigned.
713 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
714   DIDerivedType DTy(Ty);
715   if (DTy.isDerivedType())
716     return isUnsignedDIType(DD, DD->resolve(DTy.getTypeDerivedFrom()));
718   DIBasicType BTy(Ty);
719   if (BTy.isBasicType()) {
720     unsigned Encoding = BTy.getEncoding();
721     if (Encoding == dwarf::DW_ATE_unsigned ||
722         Encoding == dwarf::DW_ATE_unsigned_char ||
723         Encoding == dwarf::DW_ATE_boolean)
724       return true;
725   }
726   return false;
729 /// If this type is derived from a base type then return base type size.
730 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
731   unsigned Tag = Ty.getTag();
733   if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
734       Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
735       Tag != dwarf::DW_TAG_restrict_type)
736     return Ty.getSizeInBits();
738   DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
740   // If this type is not derived from any type then take conservative approach.
741   if (!BaseType.isValid())
742     return Ty.getSizeInBits();
744   // If this is a derived type, go ahead and get the base type, unless it's a
745   // reference then it's just the size of the field. Pointer types have no need
746   // of this since they're a different type of qualification on the type.
747   if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
748       BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
749     return Ty.getSizeInBits();
751   if (BaseType.isDerivedType())
752     return getBaseTypeSize(DD, DIDerivedType(BaseType));
754   return BaseType.getSizeInBits();
757 /// addConstantValue - Add constant value entry in variable DIE.
758 void DwarfUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
759                                  DIType Ty) {
760   // FIXME: This is a bit conservative/simple - it emits negative values at
761   // their maximum bit width which is a bit unfortunate (& doesn't prefer
762   // udata/sdata over dataN as suggested by the DWARF spec)
763   assert(MO.isImm() && "Invalid machine operand!");
764   int SizeInBits = -1;
765   bool SignedConstant = isTypeSigned(DD, Ty, &SizeInBits);
766   dwarf::Form Form;
768   // If we're a signed constant definitely use sdata.
769   if (SignedConstant) {
770     addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, MO.getImm());
771     return;
772   }
774   // Else use data for now unless it's larger than we can deal with.
775   switch (SizeInBits) {
776   case 8:
777     Form = dwarf::DW_FORM_data1;
778     break;
779   case 16:
780     Form = dwarf::DW_FORM_data2;
781     break;
782   case 32:
783     Form = dwarf::DW_FORM_data4;
784     break;
785   case 64:
786     Form = dwarf::DW_FORM_data8;
787     break;
788   default:
789     Form = dwarf::DW_FORM_udata;
790     addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
791     return;
792   }
793   addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
796 /// addConstantFPValue - Add constant value entry in variable DIE.
797 void DwarfUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
798   assert(MO.isFPImm() && "Invalid machine operand!");
799   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
800   APFloat FPImm = MO.getFPImm()->getValueAPF();
802   // Get the raw data form of the floating point.
803   const APInt FltVal = FPImm.bitcastToAPInt();
804   const char *FltPtr = (const char *)FltVal.getRawData();
806   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
807   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
808   int Incr = (LittleEndian ? 1 : -1);
809   int Start = (LittleEndian ? 0 : NumBytes - 1);
810   int Stop = (LittleEndian ? NumBytes : -1);
812   // Output the constant to DWARF one byte at a time.
813   for (; Start != Stop; Start += Incr)
814     addUInt(Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
816   addBlock(Die, dwarf::DW_AT_const_value, Block);
819 /// addConstantFPValue - Add constant value entry in variable DIE.
820 void DwarfUnit::addConstantFPValue(DIE *Die, const ConstantFP *CFP) {
821   // Pass this down to addConstantValue as an unsigned bag of bits.
822   addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
825 /// addConstantValue - Add constant value entry in variable DIE.
826 void DwarfUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
827                                  bool Unsigned) {
828   addConstantValue(Die, CI->getValue(), Unsigned);
831 // addConstantValue - Add constant value entry in variable DIE.
832 void DwarfUnit::addConstantValue(DIE *Die, const APInt &Val, bool Unsigned) {
833   unsigned CIBitWidth = Val.getBitWidth();
834   if (CIBitWidth <= 64) {
835     // If we're a signed constant definitely use sdata.
836     if (!Unsigned) {
837       addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
838               Val.getSExtValue());
839       return;
840     }
842     // Else use data for now unless it's larger than we can deal with.
843     dwarf::Form Form;
844     switch (CIBitWidth) {
845     case 8:
846       Form = dwarf::DW_FORM_data1;
847       break;
848     case 16:
849       Form = dwarf::DW_FORM_data2;
850       break;
851     case 32:
852       Form = dwarf::DW_FORM_data4;
853       break;
854     case 64:
855       Form = dwarf::DW_FORM_data8;
856       break;
857     default:
858       addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
859               Val.getZExtValue());
860       return;
861     }
862     addUInt(Die, dwarf::DW_AT_const_value, Form, Val.getZExtValue());
863     return;
864   }
866   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
868   // Get the raw data form of the large APInt.
869   const uint64_t *Ptr64 = Val.getRawData();
871   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
872   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
874   // Output the constant to DWARF one byte at a time.
875   for (int i = 0; i < NumBytes; i++) {
876     uint8_t c;
877     if (LittleEndian)
878       c = Ptr64[i / 8] >> (8 * (i & 7));
879     else
880       c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
881     addUInt(Block, dwarf::DW_FORM_data1, c);
882   }
884   addBlock(Die, dwarf::DW_AT_const_value, Block);
887 /// addTemplateParams - Add template parameters into buffer.
888 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
889   // Add template parameters.
890   for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
891     DIDescriptor Element = TParams.getElement(i);
892     if (Element.isTemplateTypeParameter())
893       constructTemplateTypeParameterDIE(Buffer,
894                                         DITemplateTypeParameter(Element));
895     else if (Element.isTemplateValueParameter())
896       constructTemplateValueParameterDIE(Buffer,
897                                          DITemplateValueParameter(Element));
898   }
901 /// getOrCreateContextDIE - Get context owner's DIE.
902 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
903   if (!Context || Context.isFile())
904     return getUnitDie();
905   if (Context.isType())
906     return getOrCreateTypeDIE(DIType(Context));
907   if (Context.isNameSpace())
908     return getOrCreateNameSpace(DINameSpace(Context));
909   if (Context.isSubprogram())
910     return getOrCreateSubprogramDIE(DISubprogram(Context));
911   return getDIE(Context);
914 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
915   DIScope Context = resolve(Ty.getContext());
916   DIE *ContextDIE = getOrCreateContextDIE(Context);
918   DIE *TyDIE = getDIE(Ty);
919   if (TyDIE)
920     return TyDIE;
922   // Create new type.
923   TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
925   constructTypeDIE(*TyDIE, Ty);
927   updateAcceleratorTables(Context, Ty, TyDIE);
928   return TyDIE;
931 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
932 /// given DIType.
933 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
934   if (!TyNode)
935     return NULL;
937   DIType Ty(TyNode);
938   assert(Ty.isType());
940   // Construct the context before querying for the existence of the DIE in case
941   // such construction creates the DIE.
942   DIScope Context = resolve(Ty.getContext());
943   DIE *ContextDIE = getOrCreateContextDIE(Context);
944   assert(ContextDIE);
946   DIE *TyDIE = getDIE(Ty);
947   if (TyDIE)
948     return TyDIE;
950   // Create new type.
951   TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
953   if (Ty.isBasicType())
954     constructTypeDIE(*TyDIE, DIBasicType(Ty));
955   else if (Ty.isCompositeType()) {
956     DICompositeType CTy(Ty);
957     if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
958       if (MDString *TypeId = CTy.getIdentifier()) {
959         DD->addDwarfTypeUnitType(getCUNode(), TypeId->getString(), TyDIE, CTy);
960         // Skip updating the accellerator tables since this is not the full type
961         return TyDIE;
962       }
963     constructTypeDIE(*TyDIE, CTy);
964   } else {
965     assert(Ty.isDerivedType() && "Unknown kind of DIType");
966     constructTypeDIE(*TyDIE, DIDerivedType(Ty));
967   }
969   updateAcceleratorTables(Context, Ty, TyDIE);
971   return TyDIE;
974 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
975                                         const DIE *TyDIE) {
976   if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
977     bool IsImplementation = 0;
978     if (Ty.isCompositeType()) {
979       DICompositeType CT(Ty);
980       // A runtime language of 0 actually means C/C++ and that any
981       // non-negative value is some version of Objective-C/C++.
982       IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
983     }
984     unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
985     addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
987     if (!Context || Context.isCompileUnit() || Context.isFile() ||
988         Context.isNameSpace())
989       GlobalTypes[getParentContextString(Context) + Ty.getName().str()] = TyDIE;
990   }
993 /// addType - Add a new type attribute to the specified entity.
994 void DwarfUnit::addType(DIE *Entity, DIType Ty, dwarf::Attribute Attribute) {
995   assert(Ty && "Trying to add a type that doesn't exist?");
997   // Check for pre-existence.
998   DIEEntry *Entry = getDIEEntry(Ty);
999   // If it exists then use the existing value.
1000   if (Entry) {
1001     addDIEEntry(Entity, Attribute, Entry);
1002     return;
1003   }
1005   // Construct type.
1006   DIE *Buffer = getOrCreateTypeDIE(Ty);
1008   // Set up proxy.
1009   Entry = createDIEEntry(Buffer);
1010   insertDIEEntry(Ty, Entry);
1011   addDIEEntry(Entity, Attribute, Entry);
1014 // Accelerator table mutators - add each name along with its companion
1015 // DIE to the proper table while ensuring that the name that we're going
1016 // to reference is in the string table. We do this since the names we
1017 // add may not only be identical to the names in the DIE.
1018 void DwarfUnit::addAccelName(StringRef Name, const DIE *Die) {
1019   DU->getStringPoolEntry(Name);
1020   std::vector<const DIE *> &DIEs = AccelNames[Name];
1021   DIEs.push_back(Die);
1024 void DwarfUnit::addAccelObjC(StringRef Name, const DIE *Die) {
1025   DU->getStringPoolEntry(Name);
1026   std::vector<const DIE *> &DIEs = AccelObjC[Name];
1027   DIEs.push_back(Die);
1030 void DwarfUnit::addAccelNamespace(StringRef Name, const DIE *Die) {
1031   DU->getStringPoolEntry(Name);
1032   std::vector<const DIE *> &DIEs = AccelNamespace[Name];
1033   DIEs.push_back(Die);
1036 void DwarfUnit::addAccelType(StringRef Name,
1037                              std::pair<const DIE *, unsigned> Die) {
1038   DU->getStringPoolEntry(Name);
1039   std::vector<std::pair<const DIE *, unsigned> > &DIEs = AccelTypes[Name];
1040   DIEs.push_back(Die);
1043 /// addGlobalName - Add a new global name to the compile unit.
1044 void DwarfUnit::addGlobalName(StringRef Name, DIE *Die, DIScope Context) {
1045   std::string FullName = getParentContextString(Context) + Name.str();
1046   GlobalNames[FullName] = Die;
1049 /// getParentContextString - Walks the metadata parent chain in a language
1050 /// specific manner (using the compile unit language) and returns
1051 /// it as a string. This is done at the metadata level because DIEs may
1052 /// not currently have been added to the parent context and walking the
1053 /// DIEs looking for names is more expensive than walking the metadata.
1054 std::string DwarfUnit::getParentContextString(DIScope Context) const {
1055   if (!Context)
1056     return "";
1058   // FIXME: Decide whether to implement this for non-C++ languages.
1059   if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
1060     return "";
1062   std::string CS;
1063   SmallVector<DIScope, 1> Parents;
1064   while (!Context.isCompileUnit()) {
1065     Parents.push_back(Context);
1066     if (Context.getContext())
1067       Context = resolve(Context.getContext());
1068     else
1069       // Structure, etc types will have a NULL context if they're at the top
1070       // level.
1071       break;
1072   }
1074   // Reverse iterate over our list to go from the outermost construct to the
1075   // innermost.
1076   for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
1077                                                   E = Parents.rend();
1078        I != E; ++I) {
1079     DIScope Ctx = *I;
1080     StringRef Name = Ctx.getName();
1081     if (!Name.empty()) {
1082       CS += Name;
1083       CS += "::";
1084     }
1085   }
1086   return CS;
1089 /// constructTypeDIE - Construct basic type die from DIBasicType.
1090 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
1091   // Get core information.
1092   StringRef Name = BTy.getName();
1093   // Add name if not anonymous or intermediate type.
1094   if (!Name.empty())
1095     addString(&Buffer, dwarf::DW_AT_name, Name);
1097   // An unspecified type only has a name attribute.
1098   if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
1099     return;
1101   addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1102           BTy.getEncoding());
1104   uint64_t Size = BTy.getSizeInBits() >> 3;
1105   addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1108 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1109 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1110   // Get core information.
1111   StringRef Name = DTy.getName();
1112   uint64_t Size = DTy.getSizeInBits() >> 3;
1113   uint16_t Tag = Buffer.getTag();
1115   // Map to main type, void will not have a type.
1116   DIType FromTy = resolve(DTy.getTypeDerivedFrom());
1117   if (FromTy)
1118     addType(&Buffer, FromTy);
1120   // Add name if not anonymous or intermediate type.
1121   if (!Name.empty())
1122     addString(&Buffer, dwarf::DW_AT_name, Name);
1124   // Add size if non-zero (derived types might be zero-sized.)
1125   if (Size && Tag != dwarf::DW_TAG_pointer_type)
1126     addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1128   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
1129     addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1130                 getOrCreateTypeDIE(resolve(DTy.getClassType())));
1131   // Add source line info if available and TyDesc is not a forward declaration.
1132   if (!DTy.isForwardDecl())
1133     addSourceLine(&Buffer, DTy);
1136 /// constructTypeDIE - Construct type DIE from DICompositeType.
1137 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1138   // Add name if not anonymous or intermediate type.
1139   StringRef Name = CTy.getName();
1141   uint64_t Size = CTy.getSizeInBits() >> 3;
1142   uint16_t Tag = Buffer.getTag();
1144   switch (Tag) {
1145   case dwarf::DW_TAG_array_type:
1146     constructArrayTypeDIE(Buffer, CTy);
1147     break;
1148   case dwarf::DW_TAG_enumeration_type:
1149     constructEnumTypeDIE(Buffer, CTy);
1150     break;
1151   case dwarf::DW_TAG_subroutine_type: {
1152     // Add return type. A void return won't have a type.
1153     DIArray Elements = CTy.getTypeArray();
1154     DIType RTy(Elements.getElement(0));
1155     if (RTy)
1156       addType(&Buffer, RTy);
1158     bool isPrototyped = true;
1159     // Add arguments.
1160     for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1161       DIDescriptor Ty = Elements.getElement(i);
1162       if (Ty.isUnspecifiedParameter()) {
1163         createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1164         isPrototyped = false;
1165       } else {
1166         DIE *Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1167         addType(Arg, DIType(Ty));
1168         if (DIType(Ty).isArtificial())
1169           addFlag(Arg, dwarf::DW_AT_artificial);
1170       }
1171     }
1172     // Add prototype flag if we're dealing with a C language and the
1173     // function has been prototyped.
1174     uint16_t Language = getLanguage();
1175     if (isPrototyped &&
1176         (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1177          Language == dwarf::DW_LANG_ObjC))
1178       addFlag(&Buffer, dwarf::DW_AT_prototyped);
1180     if (CTy.isLValueReference())
1181       addFlag(&Buffer, dwarf::DW_AT_reference);
1183     if (CTy.isRValueReference())
1184       addFlag(&Buffer, dwarf::DW_AT_rvalue_reference);
1185   } break;
1186   case dwarf::DW_TAG_structure_type:
1187   case dwarf::DW_TAG_union_type:
1188   case dwarf::DW_TAG_class_type: {
1189     // Add elements to structure type.
1190     DIArray Elements = CTy.getTypeArray();
1191     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1192       DIDescriptor Element = Elements.getElement(i);
1193       DIE *ElemDie = NULL;
1194       if (Element.isSubprogram())
1195         ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
1196       else if (Element.isDerivedType()) {
1197         DIDerivedType DDTy(Element);
1198         if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1199           ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1200           addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1201                   dwarf::DW_AT_friend);
1202         } else if (DDTy.isStaticMember()) {
1203           getOrCreateStaticMemberDIE(DDTy);
1204         } else {
1205           constructMemberDIE(Buffer, DDTy);
1206         }
1207       } else if (Element.isObjCProperty()) {
1208         DIObjCProperty Property(Element);
1209         ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1210         StringRef PropertyName = Property.getObjCPropertyName();
1211         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1212         if (Property.getType())
1213           addType(ElemDie, Property.getType());
1214         addSourceLine(ElemDie, Property);
1215         StringRef GetterName = Property.getObjCPropertyGetterName();
1216         if (!GetterName.empty())
1217           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1218         StringRef SetterName = Property.getObjCPropertySetterName();
1219         if (!SetterName.empty())
1220           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1221         unsigned PropertyAttributes = 0;
1222         if (Property.isReadOnlyObjCProperty())
1223           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1224         if (Property.isReadWriteObjCProperty())
1225           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1226         if (Property.isAssignObjCProperty())
1227           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1228         if (Property.isRetainObjCProperty())
1229           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1230         if (Property.isCopyObjCProperty())
1231           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1232         if (Property.isNonAtomicObjCProperty())
1233           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1234         if (PropertyAttributes)
1235           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1236                   PropertyAttributes);
1238         DIEEntry *Entry = getDIEEntry(Element);
1239         if (!Entry) {
1240           Entry = createDIEEntry(ElemDie);
1241           insertDIEEntry(Element, Entry);
1242         }
1243       } else
1244         continue;
1245     }
1247     if (CTy.isAppleBlockExtension())
1248       addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
1250     DICompositeType ContainingType(resolve(CTy.getContainingType()));
1251     if (ContainingType)
1252       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1253                   getOrCreateTypeDIE(ContainingType));
1255     if (CTy.isObjcClassComplete())
1256       addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1258     // Add template parameters to a class, structure or union types.
1259     // FIXME: The support isn't in the metadata for this yet.
1260     if (Tag == dwarf::DW_TAG_class_type ||
1261         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1262       addTemplateParams(Buffer, CTy.getTemplateParams());
1264     break;
1265   }
1266   default:
1267     break;
1268   }
1270   // Add name if not anonymous or intermediate type.
1271   if (!Name.empty())
1272     addString(&Buffer, dwarf::DW_AT_name, Name);
1274   if (Tag == dwarf::DW_TAG_enumeration_type ||
1275       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1276       Tag == dwarf::DW_TAG_union_type) {
1277     // Add size if non-zero (derived types might be zero-sized.)
1278     // TODO: Do we care about size for enum forward declarations?
1279     if (Size)
1280       addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1281     else if (!CTy.isForwardDecl())
1282       // Add zero size if it is not a forward declaration.
1283       addUInt(&Buffer, dwarf::DW_AT_byte_size, None, 0);
1285     // If we're a forward decl, say so.
1286     if (CTy.isForwardDecl())
1287       addFlag(&Buffer, dwarf::DW_AT_declaration);
1289     // Add source line info if available.
1290     if (!CTy.isForwardDecl())
1291       addSourceLine(&Buffer, CTy);
1293     // No harm in adding the runtime language to the declaration.
1294     unsigned RLang = CTy.getRunTimeLang();
1295     if (RLang)
1296       addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1297               RLang);
1298   }
1301 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1302 /// DITemplateTypeParameter.
1303 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1304                                                   DITemplateTypeParameter TP) {
1305   DIE *ParamDIE =
1306       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1307   // Add the type if it exists, it could be void and therefore no type.
1308   if (TP.getType())
1309     addType(ParamDIE, resolve(TP.getType()));
1310   if (!TP.getName().empty())
1311     addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1314 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1315 /// DITemplateValueParameter.
1316 void
1317 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1318                                               DITemplateValueParameter VP) {
1319   DIE *ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1321   // Add the type if there is one, template template and template parameter
1322   // packs will not have a type.
1323   if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1324     addType(ParamDIE, resolve(VP.getType()));
1325   if (!VP.getName().empty())
1326     addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1327   if (Value *Val = VP.getValue()) {
1328     if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1329       addConstantValue(ParamDIE, CI,
1330                        isUnsignedDIType(DD, resolve(VP.getType())));
1331     else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1332       // For declaration non-type template parameters (such as global values and
1333       // functions)
1334       DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1335       addOpAddress(Block, Asm->getSymbol(GV));
1336       // Emit DW_OP_stack_value to use the address as the immediate value of the
1337       // parameter, rather than a pointer to it.
1338       addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1339       addBlock(ParamDIE, dwarf::DW_AT_location, Block);
1340     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1341       assert(isa<MDString>(Val));
1342       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1343                 cast<MDString>(Val)->getString());
1344     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1345       assert(isa<MDNode>(Val));
1346       DIArray A(cast<MDNode>(Val));
1347       addTemplateParams(*ParamDIE, A);
1348     }
1349   }
1352 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1353 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1354   // Construct the context before querying for the existence of the DIE in case
1355   // such construction creates the DIE.
1356   DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1358   DIE *NDie = getDIE(NS);
1359   if (NDie)
1360     return NDie;
1361   NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1363   if (!NS.getName().empty()) {
1364     addString(NDie, dwarf::DW_AT_name, NS.getName());
1365     addAccelNamespace(NS.getName(), NDie);
1366     addGlobalName(NS.getName(), NDie, NS.getContext());
1367   } else
1368     addAccelNamespace("(anonymous namespace)", NDie);
1369   addSourceLine(NDie, NS);
1370   return NDie;
1373 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1374 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1375   // Construct the context before querying for the existence of the DIE in case
1376   // such construction creates the DIE (as is the case for member function
1377   // declarations).
1378   DIE *ContextDIE = getOrCreateContextDIE(resolve(SP.getContext()));
1380   DIE *SPDie = getDIE(SP);
1381   if (SPDie)
1382     return SPDie;
1384   DISubprogram SPDecl = SP.getFunctionDeclaration();
1385   if (SPDecl.isSubprogram())
1386     // Add subprogram definitions to the CU die directly.
1387     ContextDIE = UnitDie.get();
1389   // DW_TAG_inlined_subroutine may refer to this DIE.
1390   SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1392   DIE *DeclDie = NULL;
1393   if (SPDecl.isSubprogram())
1394     DeclDie = getOrCreateSubprogramDIE(SPDecl);
1396   // Add function template parameters.
1397   addTemplateParams(*SPDie, SP.getTemplateParams());
1399   // If this DIE is going to refer declaration info using AT_specification
1400   // then there is no need to add other attributes.
1401   if (DeclDie) {
1402     // Refer function declaration directly.
1403     addDIEEntry(SPDie, dwarf::DW_AT_specification, DeclDie);
1405     return SPDie;
1406   }
1408   // Add the linkage name if we have one.
1409   StringRef LinkageName = SP.getLinkageName();
1410   if (!LinkageName.empty())
1411     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1412               GlobalValue::getRealLinkageName(LinkageName));
1414   // Constructors and operators for anonymous aggregates do not have names.
1415   if (!SP.getName().empty())
1416     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1418   addSourceLine(SPDie, SP);
1420   // Add the prototype if we have a prototype and we have a C like
1421   // language.
1422   uint16_t Language = getLanguage();
1423   if (SP.isPrototyped() &&
1424       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1425        Language == dwarf::DW_LANG_ObjC))
1426     addFlag(SPDie, dwarf::DW_AT_prototyped);
1428   DICompositeType SPTy = SP.getType();
1429   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1430          "the type of a subprogram should be a subroutine");
1432   DIArray Args = SPTy.getTypeArray();
1433   // Add a return type. If this is a type like a C/C++ void type we don't add a
1434   // return type.
1435   if (Args.getElement(0))
1436     addType(SPDie, DIType(Args.getElement(0)));
1438   unsigned VK = SP.getVirtuality();
1439   if (VK) {
1440     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1441     DIEBlock *Block = getDIEBlock();
1442     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1443     addUInt(Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1444     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1445     ContainingTypeMap.insert(
1446         std::make_pair(SPDie, resolve(SP.getContainingType())));
1447   }
1449   if (!SP.isDefinition()) {
1450     addFlag(SPDie, dwarf::DW_AT_declaration);
1452     // Add arguments. Do not add arguments for subprogram definition. They will
1453     // be handled while processing variables.
1454     for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1455       DIE *Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, *SPDie);
1456       DIType ATy(Args.getElement(i));
1457       addType(Arg, ATy);
1458       if (ATy.isArtificial())
1459         addFlag(Arg, dwarf::DW_AT_artificial);
1460     }
1461   }
1463   if (SP.isArtificial())
1464     addFlag(SPDie, dwarf::DW_AT_artificial);
1466   if (!SP.isLocalToUnit())
1467     addFlag(SPDie, dwarf::DW_AT_external);
1469   if (SP.isOptimized())
1470     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1472   if (unsigned isa = Asm->getISAEncoding()) {
1473     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1474   }
1476   if (SP.isLValueReference())
1477     addFlag(SPDie, dwarf::DW_AT_reference);
1479   if (SP.isRValueReference())
1480     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1482   if (SP.isProtected())
1483     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1484             dwarf::DW_ACCESS_protected);
1485   else if (SP.isPrivate())
1486     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1487             dwarf::DW_ACCESS_private);
1488   else
1489     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1490             dwarf::DW_ACCESS_public);
1492   if (SP.isExplicit())
1493     addFlag(SPDie, dwarf::DW_AT_explicit);
1495   return SPDie;
1498 // Return const expression if value is a GEP to access merged global
1499 // constant. e.g.
1500 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1501 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1502   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1503   if (!CE || CE->getNumOperands() != 3 ||
1504       CE->getOpcode() != Instruction::GetElementPtr)
1505     return NULL;
1507   // First operand points to a global struct.
1508   Value *Ptr = CE->getOperand(0);
1509   if (!isa<GlobalValue>(Ptr) ||
1510       !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1511     return NULL;
1513   // Second operand is zero.
1514   const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1515   if (!CI || !CI->isZero())
1516     return NULL;
1518   // Third operand is offset.
1519   if (!isa<ConstantInt>(CE->getOperand(2)))
1520     return NULL;
1522   return CE;
1525 /// createGlobalVariableDIE - create global variable DIE.
1526 void DwarfCompileUnit::createGlobalVariableDIE(DIGlobalVariable GV) {
1527   // Check for pre-existence.
1528   if (getDIE(GV))
1529     return;
1531   if (!GV.isGlobalVariable())
1532     return;
1534   DIScope GVContext = GV.getContext();
1535   DIType GTy = GV.getType();
1537   // If this is a static data member definition, some attributes belong
1538   // to the declaration DIE.
1539   DIE *VariableDIE = NULL;
1540   bool IsStaticMember = false;
1541   DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1542   if (SDMDecl.Verify()) {
1543     assert(SDMDecl.isStaticMember() && "Expected static member decl");
1544     // We need the declaration DIE that is in the static member's class.
1545     VariableDIE = getOrCreateStaticMemberDIE(SDMDecl);
1546     IsStaticMember = true;
1547   }
1549   // If this is not a static data member definition, create the variable
1550   // DIE and add the initial set of attributes to it.
1551   if (!VariableDIE) {
1552     // Construct the context before querying for the existence of the DIE in
1553     // case such construction creates the DIE.
1554     DIE *ContextDIE = getOrCreateContextDIE(GVContext);
1556     // Add to map.
1557     VariableDIE = createAndAddDIE(GV.getTag(), *ContextDIE, GV);
1559     // Add name and type.
1560     addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1561     addType(VariableDIE, GTy);
1563     // Add scoping info.
1564     if (!GV.isLocalToUnit())
1565       addFlag(VariableDIE, dwarf::DW_AT_external);
1567     // Add line number info.
1568     addSourceLine(VariableDIE, GV);
1569   }
1571   // Add location.
1572   bool addToAccelTable = false;
1573   DIE *VariableSpecDIE = NULL;
1574   bool isGlobalVariable = GV.getGlobal() != NULL;
1575   if (isGlobalVariable) {
1576     addToAccelTable = true;
1577     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1578     const MCSymbol *Sym = Asm->getSymbol(GV.getGlobal());
1579     if (GV.getGlobal()->isThreadLocal()) {
1580       // FIXME: Make this work with -gsplit-dwarf.
1581       unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1582       assert((PointerSize == 4 || PointerSize == 8) &&
1583              "Add support for other sizes if necessary");
1584       const MCExpr *Expr =
1585           Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym);
1586       // Based on GCC's support for TLS:
1587       if (!DD->useSplitDwarf()) {
1588         // 1) Start with a constNu of the appropriate pointer size
1589         addUInt(Block, dwarf::DW_FORM_data1,
1590                 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1591         // 2) containing the (relocated) offset of the TLS variable
1592         //    within the module's TLS block.
1593         addExpr(Block, dwarf::DW_FORM_udata, Expr);
1594       } else {
1595         addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1596         addUInt(Block, dwarf::DW_FORM_udata, DU->getAddrPoolIndex(Expr));
1597       }
1598       // 3) followed by a custom OP to make the debugger do a TLS lookup.
1599       addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_push_tls_address);
1600     } else {
1601       DD->addArangeLabel(SymbolCU(this, Sym));
1602       addOpAddress(Block, Sym);
1603     }
1604     // Do not create specification DIE if context is either compile unit
1605     // or a subprogram.
1606     if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1607         !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1608       // Create specification DIE.
1609       VariableSpecDIE = createAndAddDIE(dwarf::DW_TAG_variable, *UnitDie);
1610       addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, VariableDIE);
1611       addBlock(VariableSpecDIE, dwarf::DW_AT_location, Block);
1612       // A static member's declaration is already flagged as such.
1613       if (!SDMDecl.Verify())
1614         addFlag(VariableDIE, dwarf::DW_AT_declaration);
1615     } else {
1616       addBlock(VariableDIE, dwarf::DW_AT_location, Block);
1617     }
1618     // Add the linkage name.
1619     StringRef LinkageName = GV.getLinkageName();
1620     if (!LinkageName.empty())
1621       // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1622       // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1623       // TAG_variable.
1624       addString(IsStaticMember && VariableSpecDIE ? VariableSpecDIE
1625                                                   : VariableDIE,
1626                 dwarf::DW_AT_MIPS_linkage_name,
1627                 GlobalValue::getRealLinkageName(LinkageName));
1628   } else if (const ConstantInt *CI =
1629                  dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1630     // AT_const_value was added when the static member was created. To avoid
1631     // emitting AT_const_value multiple times, we only add AT_const_value when
1632     // it is not a static member.
1633     if (!IsStaticMember)
1634       addConstantValue(VariableDIE, CI, isUnsignedDIType(DD, GTy));
1635   } else if (const ConstantExpr *CE = getMergedGlobalExpr(GV->getOperand(11))) {
1636     addToAccelTable = true;
1637     // GV is a merged global.
1638     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1639     Value *Ptr = CE->getOperand(0);
1640     MCSymbol *Sym = Asm->getSymbol(cast<GlobalValue>(Ptr));
1641     DD->addArangeLabel(SymbolCU(this, Sym));
1642     addOpAddress(Block, Sym);
1643     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1644     SmallVector<Value *, 3> Idx(CE->op_begin() + 1, CE->op_end());
1645     addUInt(Block, dwarf::DW_FORM_udata,
1646             Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1647     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1648     addBlock(VariableDIE, dwarf::DW_AT_location, Block);
1649   }
1651   if (addToAccelTable) {
1652     DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1653     addAccelName(GV.getName(), AddrDIE);
1655     // If the linkage name is different than the name, go ahead and output
1656     // that as well into the name table.
1657     if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1658       addAccelName(GV.getLinkageName(), AddrDIE);
1659   }
1661   if (!GV.isLocalToUnit())
1662     addGlobalName(GV.getName(), VariableSpecDIE ? VariableSpecDIE : VariableDIE,
1663                   GV.getContext());
1666 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1667 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1668   DIE *DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1669   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, IndexTy);
1671   // The LowerBound value defines the lower bounds which is typically zero for
1672   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1673   // Count == -1 then the array is unbounded and we do not emit
1674   // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1675   // Count == 0, then the array has zero elements in which case we do not emit
1676   // an upper bound.
1677   int64_t LowerBound = SR.getLo();
1678   int64_t DefaultLowerBound = getDefaultLowerBound();
1679   int64_t Count = SR.getCount();
1681   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1682     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1684   if (Count != -1 && Count != 0)
1685     // FIXME: An unbounded array should reference the expression that defines
1686     // the array.
1687     addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, None,
1688             LowerBound + Count - 1);
1691 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1692 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1693   if (CTy.isVector())
1694     addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1696   // Emit the element type.
1697   addType(&Buffer, resolve(CTy.getTypeDerivedFrom()));
1699   // Get an anonymous type for index type.
1700   // FIXME: This type should be passed down from the front end
1701   // as different languages may have different sizes for indexes.
1702   DIE *IdxTy = getIndexTyDie();
1703   if (!IdxTy) {
1704     // Construct an anonymous type for index type.
1705     IdxTy = createAndAddDIE(dwarf::DW_TAG_base_type, *UnitDie);
1706     addString(IdxTy, dwarf::DW_AT_name, "int");
1707     addUInt(IdxTy, dwarf::DW_AT_byte_size, None, sizeof(int32_t));
1708     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1709             dwarf::DW_ATE_signed);
1710     setIndexTyDie(IdxTy);
1711   }
1713   // Add subranges to array type.
1714   DIArray Elements = CTy.getTypeArray();
1715   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1716     DIDescriptor Element = Elements.getElement(i);
1717     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1718       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1719   }
1722 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1723 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1724   DIArray Elements = CTy.getTypeArray();
1726   // Add enumerators to enumeration type.
1727   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1728     DIEnumerator Enum(Elements.getElement(i));
1729     if (Enum.isEnumerator()) {
1730       DIE *Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1731       StringRef Name = Enum.getName();
1732       addString(Enumerator, dwarf::DW_AT_name, Name);
1733       int64_t Value = Enum.getEnumValue();
1734       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1735               Value);
1736     }
1737   }
1738   DIType DTy = resolve(CTy.getTypeDerivedFrom());
1739   if (DTy) {
1740     addType(&Buffer, DTy);
1741     addFlag(&Buffer, dwarf::DW_AT_enum_class);
1742   }
1745 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1746 /// vtables.
1747 void DwarfUnit::constructContainingTypeDIEs() {
1748   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1749                                                  CE = ContainingTypeMap.end();
1750        CI != CE; ++CI) {
1751     DIE *SPDie = CI->first;
1752     DIDescriptor D(CI->second);
1753     if (!D)
1754       continue;
1755     DIE *NDie = getDIE(D);
1756     if (!NDie)
1757       continue;
1758     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, NDie);
1759   }
1762 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1763 DIE *DwarfUnit::constructVariableDIE(DbgVariable &DV, bool isScopeAbstract) {
1764   StringRef Name = DV.getName();
1766   // Define variable debug information entry.
1767   DIE *VariableDie = new DIE(DV.getTag());
1768   DbgVariable *AbsVar = DV.getAbstractVariable();
1769   DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1770   if (AbsDIE)
1771     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin, AbsDIE);
1772   else {
1773     if (!Name.empty())
1774       addString(VariableDie, dwarf::DW_AT_name, Name);
1775     addSourceLine(VariableDie, DV.getVariable());
1776     addType(VariableDie, DV.getType());
1777   }
1779   if (DV.isArtificial())
1780     addFlag(VariableDie, dwarf::DW_AT_artificial);
1782   if (isScopeAbstract) {
1783     DV.setDIE(VariableDie);
1784     return VariableDie;
1785   }
1787   // Add variable address.
1789   unsigned Offset = DV.getDotDebugLocOffset();
1790   if (Offset != ~0U) {
1791     addSectionLabel(VariableDie, dwarf::DW_AT_location,
1792                     Asm->GetTempSymbol("debug_loc", Offset));
1793     DV.setDIE(VariableDie);
1794     return VariableDie;
1795   }
1797   // Check if variable is described by a DBG_VALUE instruction.
1798   if (const MachineInstr *DVInsn = DV.getMInsn()) {
1799     assert(DVInsn->getNumOperands() == 3);
1800     if (DVInsn->getOperand(0).isReg()) {
1801       const MachineOperand RegOp = DVInsn->getOperand(0);
1802       // If the second operand is an immediate, this is an indirect value.
1803       if (DVInsn->getOperand(1).isImm()) {
1804         MachineLocation Location(RegOp.getReg(),
1805                                  DVInsn->getOperand(1).getImm());
1806         addVariableAddress(DV, VariableDie, Location);
1807       } else if (RegOp.getReg())
1808         addVariableAddress(DV, VariableDie, MachineLocation(RegOp.getReg()));
1809     } else if (DVInsn->getOperand(0).isImm())
1810       addConstantValue(VariableDie, DVInsn->getOperand(0), DV.getType());
1811     else if (DVInsn->getOperand(0).isFPImm())
1812       addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1813     else if (DVInsn->getOperand(0).isCImm())
1814       addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
1815                        isUnsignedDIType(DD, DV.getType()));
1817     DV.setDIE(VariableDie);
1818     return VariableDie;
1819   } else {
1820     // .. else use frame index.
1821     int FI = DV.getFrameIndex();
1822     if (FI != ~0) {
1823       unsigned FrameReg = 0;
1824       const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1825       int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1826       MachineLocation Location(FrameReg, Offset);
1827       addVariableAddress(DV, VariableDie, Location);
1828     }
1829   }
1831   DV.setDIE(VariableDie);
1832   return VariableDie;
1835 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1836 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1837   DIE *MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1838   StringRef Name = DT.getName();
1839   if (!Name.empty())
1840     addString(MemberDie, dwarf::DW_AT_name, Name);
1842   addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1844   addSourceLine(MemberDie, DT);
1846   if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1848     // For C++, virtual base classes are not at fixed offset. Use following
1849     // expression to extract appropriate offset from vtable.
1850     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1852     DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1853     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1854     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1855     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1856     addUInt(VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1857     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1858     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1859     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1861     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1862   } else {
1863     uint64_t Size = DT.getSizeInBits();
1864     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1865     uint64_t OffsetInBytes;
1867     if (Size != FieldSize) {
1868       // Handle bitfield.
1869       addUInt(MemberDie, dwarf::DW_AT_byte_size, None,
1870               getBaseTypeSize(DD, DT) >> 3);
1871       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, DT.getSizeInBits());
1873       uint64_t Offset = DT.getOffsetInBits();
1874       uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1875       uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1876       uint64_t FieldOffset = (HiMark - FieldSize);
1877       Offset -= FieldOffset;
1879       // Maybe we need to work from the other end.
1880       if (Asm->getDataLayout().isLittleEndian())
1881         Offset = FieldSize - (Offset + Size);
1882       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1884       // Here DW_AT_data_member_location points to the anonymous
1885       // field that includes this bit field.
1886       OffsetInBytes = FieldOffset >> 3;
1887     } else
1888       // This is not a bitfield.
1889       OffsetInBytes = DT.getOffsetInBits() >> 3;
1891     if (DD->getDwarfVersion() <= 2) {
1892       DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1893       addUInt(MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1894       addUInt(MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1895       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1896     } else
1897       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1898               OffsetInBytes);
1899   }
1901   if (DT.isProtected())
1902     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1903             dwarf::DW_ACCESS_protected);
1904   else if (DT.isPrivate())
1905     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1906             dwarf::DW_ACCESS_private);
1907   // Otherwise C++ member and base classes are considered public.
1908   else
1909     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1910             dwarf::DW_ACCESS_public);
1911   if (DT.isVirtual())
1912     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1913             dwarf::DW_VIRTUALITY_virtual);
1915   // Objective-C properties.
1916   if (MDNode *PNode = DT.getObjCProperty())
1917     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1918       MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1919                           PropertyDie);
1921   if (DT.isArtificial())
1922     addFlag(MemberDie, dwarf::DW_AT_artificial);
1925 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1926 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1927   if (!DT.Verify())
1928     return NULL;
1930   // Construct the context before querying for the existence of the DIE in case
1931   // such construction creates the DIE.
1932   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1933   assert(dwarf::isType(ContextDIE->getTag()) &&
1934          "Static member should belong to a type.");
1936   DIE *StaticMemberDIE = getDIE(DT);
1937   if (StaticMemberDIE)
1938     return StaticMemberDIE;
1940   StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1942   DIType Ty = resolve(DT.getTypeDerivedFrom());
1944   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1945   addType(StaticMemberDIE, Ty);
1946   addSourceLine(StaticMemberDIE, DT);
1947   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1948   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1950   // FIXME: We could omit private if the parent is a class_type, and
1951   // public if the parent is something else.
1952   if (DT.isProtected())
1953     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1954             dwarf::DW_ACCESS_protected);
1955   else if (DT.isPrivate())
1956     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1957             dwarf::DW_ACCESS_private);
1958   else
1959     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1960             dwarf::DW_ACCESS_public);
1962   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1963     addConstantValue(StaticMemberDIE, CI, isUnsignedDIType(DD, Ty));
1964   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1965     addConstantFPValue(StaticMemberDIE, CFP);
1967   return StaticMemberDIE;
1970 void DwarfUnit::emitHeader(const MCSection *ASection,
1971                            const MCSymbol *ASectionSym) const {
1972   Asm->OutStreamer.AddComment("DWARF version number");
1973   Asm->EmitInt16(DD->getDwarfVersion());
1974   Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1975   // We share one abbreviations table across all units so it's always at the
1976   // start of the section. Use a relocatable offset where needed to ensure
1977   // linking doesn't invalidate that offset.
1978   Asm->EmitSectionOffset(ASectionSym, ASectionSym);
1979   Asm->OutStreamer.AddComment("Address Size (in bytes)");
1980   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1983 DwarfCompileUnit::~DwarfCompileUnit() {}
1984 DwarfTypeUnit::~DwarfTypeUnit() {}
1986 void DwarfTypeUnit::emitHeader(const MCSection *ASection,
1987                                const MCSymbol *ASectionSym) const {
1988   DwarfUnit::emitHeader(ASection, ASectionSym);
1989   Asm->OutStreamer.AddComment("Type Signature");
1990   Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
1991   Asm->OutStreamer.AddComment("Type DIE Offset");
1992   // In a skeleton type unit there is no type DIE so emit a zero offset.
1993   Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
1994                                 sizeof(Ty->getOffset()));
1997 void DwarfTypeUnit::initSection(const MCSection *Section) {
1998   assert(!this->Section);
1999   this->Section = Section;
2000   // Since each type unit is contained in its own COMDAT section, the begin
2001   // label and the section label are the same. Using the begin label emission in
2002   // DwarfDebug to emit the section label as well is slightly subtle/sneaky, but
2003   // the only other alternative of lazily constructing start-of-section labels
2004   // and storing a mapping in DwarfDebug (or AsmPrinter).
2005   this->SectionSym = this->LabelBegin =
2006       Asm->GetTempSymbol(Section->getLabelBeginName(), getUniqueID());
2007   this->LabelEnd =
2008       Asm->GetTempSymbol(Section->getLabelEndName(), getUniqueID());
2009   this->LabelRange = Asm->GetTempSymbol("gnu_ranges", getUniqueID());