508a6927c20968e158ebc425df8d4f5ff668cd8f
[opencl/llvm.git] / lib / CodeGen / AsmPrinter / DwarfCompileUnit.cpp
1 //===-- llvm/CodeGen/DwarfCompileUnit.cpp - Dwarf Compile Unit ------------===//
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 "DwarfCompileUnit.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/MC/MCSection.h"
26 #include "llvm/MC/MCStreamer.h"
27 #include "llvm/Target/Mangler.h"
28 #include "llvm/Target/TargetFrameLowering.h"
29 #include "llvm/Target/TargetMachine.h"
30 #include "llvm/Target/TargetLoweringObjectFile.h"
31 #include "llvm/Target/TargetRegisterInfo.h"
33 using namespace llvm;
35 /// CompileUnit - Compile unit constructor.
36 CompileUnit::CompileUnit(unsigned UID, DIE *D, const MDNode *N, AsmPrinter *A,
37                          DwarfDebug *DW, DwarfUnits *DWU)
38     : UniqueID(UID), Node(N), CUDie(D), Asm(A), DD(DW), DU(DWU), IndexTyDie(0),
39       DebugInfoOffset(0) {
40   DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
41   insertDIE(DIDescriptor(N), D);
42 }
44 /// ~CompileUnit - Destructor for compile unit.
45 CompileUnit::~CompileUnit() {
46   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
47     DIEBlocks[j]->~DIEBlock();
48 }
50 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
51 /// information entry.
52 DIEEntry *CompileUnit::createDIEEntry(DIE *Entry) {
53   DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
54   return Value;
55 }
57 /// getDefaultLowerBound - Return the default lower bound for an array. If the
58 /// DWARF version doesn't handle the language, return -1.
59 int64_t CompileUnit::getDefaultLowerBound() const {
60   switch (DICompileUnit(Node).getLanguage()) {
61   default:
62     break;
64   case dwarf::DW_LANG_C89:
65   case dwarf::DW_LANG_C99:
66   case dwarf::DW_LANG_C:
67   case dwarf::DW_LANG_C_plus_plus:
68   case dwarf::DW_LANG_ObjC:
69   case dwarf::DW_LANG_ObjC_plus_plus:
70     return 0;
72   case dwarf::DW_LANG_Fortran77:
73   case dwarf::DW_LANG_Fortran90:
74   case dwarf::DW_LANG_Fortran95:
75     return 1;
77   // The languages below have valid values only if the DWARF version >= 4.
78   case dwarf::DW_LANG_Java:
79   case dwarf::DW_LANG_Python:
80   case dwarf::DW_LANG_UPC:
81   case dwarf::DW_LANG_D:
82     if (dwarf::DWARF_VERSION >= 4)
83       return 0;
84     break;
86   case dwarf::DW_LANG_Ada83:
87   case dwarf::DW_LANG_Ada95:
88   case dwarf::DW_LANG_Cobol74:
89   case dwarf::DW_LANG_Cobol85:
90   case dwarf::DW_LANG_Modula2:
91   case dwarf::DW_LANG_Pascal83:
92   case dwarf::DW_LANG_PLI:
93     if (dwarf::DWARF_VERSION >= 4)
94       return 1;
95     break;
96   }
98   return -1;
99 }
101 /// Check whether the DIE for this MDNode can be shared across CUs.
102 static bool isShareableAcrossCUs(DIDescriptor D) {
103   // When the MDNode can be part of the type system, the DIE can be
104   // shared across CUs.
105   return D.isType() ||
106          (D.isSubprogram() && !DISubprogram(D).isDefinition());
109 /// getDIE - Returns the debug information entry map slot for the
110 /// specified debug variable. We delegate the request to DwarfDebug
111 /// when the DIE for this MDNode can be shared across CUs. The mappings
112 /// will be kept in DwarfDebug for shareable DIEs.
113 DIE *CompileUnit::getDIE(DIDescriptor D) const {
114   if (isShareableAcrossCUs(D))
115     return DD->getDIE(D);
116   return MDNodeToDieMap.lookup(D);
119 /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
120 /// when the DIE for this MDNode can be shared across CUs. The mappings
121 /// will be kept in DwarfDebug for shareable DIEs.
122 void CompileUnit::insertDIE(DIDescriptor Desc, DIE *D) {
123   if (isShareableAcrossCUs(Desc)) {
124     DD->insertDIE(Desc, D);
125     return;
126   }
127   MDNodeToDieMap.insert(std::make_pair(Desc, D));
130 /// addFlag - Add a flag that is true.
131 void CompileUnit::addFlag(DIE *Die, dwarf::Attribute Attribute) {
132   if (DD->getDwarfVersion() >= 4)
133     Die->addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
134   else
135     Die->addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
138 /// addUInt - Add an unsigned integer attribute data and value.
139 ///
140 void CompileUnit::addUInt(DIE *Die, dwarf::Attribute Attribute,
141                           Optional<dwarf::Form> Form, uint64_t Integer) {
142   if (!Form)
143     Form = DIEInteger::BestForm(false, Integer);
144   DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
145                         DIEInteger(Integer);
146   Die->addValue(Attribute, *Form, Value);
149 void CompileUnit::addUInt(DIEBlock *Block, dwarf::Form Form, uint64_t Integer) {
150   addUInt(Block, (dwarf::Attribute)0, Form, Integer);
153 /// addSInt - Add an signed integer attribute data and value.
154 ///
155 void CompileUnit::addSInt(DIE *Die, dwarf::Attribute Attribute,
156                           Optional<dwarf::Form> Form, int64_t Integer) {
157   if (!Form)
158     Form = DIEInteger::BestForm(true, Integer);
159   DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
160   Die->addValue(Attribute, *Form, Value);
163 void CompileUnit::addSInt(DIEBlock *Die, Optional<dwarf::Form> Form,
164                           int64_t Integer) {
165   addSInt(Die, (dwarf::Attribute)0, Form, Integer);
168 /// addString - Add a string attribute data and value. We always emit a
169 /// reference to the string pool instead of immediate strings so that DIEs have
170 /// more predictable sizes. In the case of split dwarf we emit an index
171 /// into another table which gets us the static offset into the string
172 /// table.
173 void CompileUnit::addString(DIE *Die, dwarf::Attribute Attribute,
174                             StringRef String) {
175   DIEValue *Value;
176   dwarf::Form Form;
177   if (!DD->useSplitDwarf()) {
178     MCSymbol *Symb = DU->getStringPoolEntry(String);
179     if (Asm->needsRelocationsForDwarfStringPool())
180       Value = new (DIEValueAllocator) DIELabel(Symb);
181     else {
182       MCSymbol *StringPool = DU->getStringPoolSym();
183       Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
184     }
185     Form = dwarf::DW_FORM_strp;
186   } else {
187     unsigned idx = DU->getStringPoolIndex(String);
188     Value = new (DIEValueAllocator) DIEInteger(idx);
189     Form = dwarf::DW_FORM_GNU_str_index;
190   }
191   DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
192   Die->addValue(Attribute, Form, Str);
195 /// addLocalString - Add a string attribute data and value. This is guaranteed
196 /// to be in the local string pool instead of indirected.
197 void CompileUnit::addLocalString(DIE *Die, dwarf::Attribute Attribute,
198                                  StringRef String) {
199   MCSymbol *Symb = DU->getStringPoolEntry(String);
200   DIEValue *Value;
201   if (Asm->needsRelocationsForDwarfStringPool())
202     Value = new (DIEValueAllocator) DIELabel(Symb);
203   else {
204     MCSymbol *StringPool = DU->getStringPoolSym();
205     Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
206   }
207   Die->addValue(Attribute, dwarf::DW_FORM_strp, Value);
210 /// addExpr - Add a Dwarf expression attribute data and value.
211 ///
212 void CompileUnit::addExpr(DIEBlock *Die, dwarf::Form Form, const MCExpr *Expr) {
213   DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr);
214   Die->addValue((dwarf::Attribute)0, Form, Value);
217 /// addLabel - Add a Dwarf label attribute data and value.
218 ///
219 void CompileUnit::addLabel(DIE *Die, dwarf::Attribute Attribute,
220                            dwarf::Form Form, const MCSymbol *Label) {
221   DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
222   Die->addValue(Attribute, Form, Value);
225 void CompileUnit::addLabel(DIEBlock *Die, dwarf::Form Form,
226                            const MCSymbol *Label) {
227   addLabel(Die, (dwarf::Attribute)0, Form, Label);
230 /// addLabelAddress - Add a dwarf label attribute data and value using
231 /// DW_FORM_addr or DW_FORM_GNU_addr_index.
232 ///
233 void CompileUnit::addLabelAddress(DIE *Die, dwarf::Attribute Attribute,
234                                   MCSymbol *Label) {
235   if (Label)
236     DD->addArangeLabel(SymbolCU(this, Label));
238   if (!DD->useSplitDwarf()) {
239     if (Label != NULL) {
240       DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
241       Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
242     } else {
243       DIEValue *Value = new (DIEValueAllocator) DIEInteger(0);
244       Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
245     }
246   } else {
247     unsigned idx = DU->getAddrPoolIndex(Label);
248     DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
249     Die->addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value);
250   }
253 /// addOpAddress - Add a dwarf op address data and value using the
254 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
255 ///
256 void CompileUnit::addOpAddress(DIEBlock *Die, const MCSymbol *Sym) {
257   DD->addArangeLabel(SymbolCU(this, Sym));
258   if (!DD->useSplitDwarf()) {
259     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
260     addLabel(Die, dwarf::DW_FORM_udata, Sym);
261   } else {
262     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
263     addUInt(Die, dwarf::DW_FORM_GNU_addr_index, DU->getAddrPoolIndex(Sym));
264   }
267 /// addDelta - Add a label delta attribute data and value.
268 ///
269 void CompileUnit::addDelta(DIE *Die, dwarf::Attribute Attribute,
270                            dwarf::Form Form, const MCSymbol *Hi,
271                            const MCSymbol *Lo) {
272   DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
273   Die->addValue(Attribute, Form, Value);
276 /// addDIEEntry - Add a DIE attribute data and value.
277 ///
278 void CompileUnit::addDIEEntry(DIE *Die, dwarf::Attribute Attribute,
279                               DIE *Entry) {
280   addDIEEntry(Die, Attribute, createDIEEntry(Entry));
283 void CompileUnit::addDIEEntry(DIE *Die, dwarf::Attribute Attribute,
284                               DIEEntry *Entry) {
285   const DIE *DieCU = Die->getCompileUnitOrNull();
286   const DIE *EntryCU = Entry->getEntry()->getCompileUnitOrNull();
287   if (!DieCU)
288     // We assume that Die belongs to this CU, if it is not linked to any CU yet.
289     DieCU = getCUDie();
290   if (!EntryCU)
291     EntryCU = getCUDie();
292   Die->addValue(Attribute, EntryCU == DieCU ? dwarf::DW_FORM_ref4
293                                             : dwarf::DW_FORM_ref_addr,
294                 Entry);
297 /// Create a DIE with the given Tag, add the DIE to its parent, and
298 /// call insertDIE if MD is not null.
299 DIE *CompileUnit::createAndAddDIE(unsigned Tag, DIE &Parent, const MDNode *MD) {
300   DIE *Die = new DIE(Tag);
301   Parent.addChild(Die);
302   if (MD)
303     insertDIE(DIDescriptor(MD), Die);
304   return Die;
307 /// addBlock - Add block data.
308 ///
309 void CompileUnit::addBlock(DIE *Die, dwarf::Attribute Attribute,
310                            DIEBlock *Block) {
311   Block->ComputeSize(Asm);
312   DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
313   Die->addValue(Attribute, Block->BestForm(), Block);
316 /// addSourceLine - Add location information to specified debug information
317 /// entry.
318 void CompileUnit::addSourceLine(DIE *Die, DIVariable V) {
319   // Verify variable.
320   if (!V.isVariable())
321     return;
323   unsigned Line = V.getLineNumber();
324   if (Line == 0)
325     return;
326   unsigned FileID =
327       DD->getOrCreateSourceID(V.getContext().getFilename(),
328                               V.getContext().getDirectory(), getUniqueID());
329   assert(FileID && "Invalid file id");
330   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
331   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
334 /// addSourceLine - Add location information to specified debug information
335 /// entry.
336 void CompileUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
337   // Verify global variable.
338   if (!G.isGlobalVariable())
339     return;
341   unsigned Line = G.getLineNumber();
342   if (Line == 0)
343     return;
344   unsigned FileID =
345       DD->getOrCreateSourceID(G.getFilename(), G.getDirectory(), getUniqueID());
346   assert(FileID && "Invalid file id");
347   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
348   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
351 /// addSourceLine - Add location information to specified debug information
352 /// entry.
353 void CompileUnit::addSourceLine(DIE *Die, DISubprogram SP) {
354   // Verify subprogram.
355   if (!SP.isSubprogram())
356     return;
358   // If the line number is 0, don't add it.
359   unsigned Line = SP.getLineNumber();
360   if (Line == 0)
361     return;
363   unsigned FileID = DD->getOrCreateSourceID(SP.getFilename(), SP.getDirectory(),
364                                             getUniqueID());
365   assert(FileID && "Invalid file id");
366   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
367   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
370 /// addSourceLine - Add location information to specified debug information
371 /// entry.
372 void CompileUnit::addSourceLine(DIE *Die, DIType Ty) {
373   // Verify type.
374   if (!Ty.isType())
375     return;
377   unsigned Line = Ty.getLineNumber();
378   if (Line == 0)
379     return;
380   unsigned FileID = DD->getOrCreateSourceID(Ty.getFilename(), Ty.getDirectory(),
381                                             getUniqueID());
382   assert(FileID && "Invalid file id");
383   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
384   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
387 /// addSourceLine - Add location information to specified debug information
388 /// entry.
389 void CompileUnit::addSourceLine(DIE *Die, DIObjCProperty Ty) {
390   // Verify type.
391   if (!Ty.isObjCProperty())
392     return;
394   unsigned Line = Ty.getLineNumber();
395   if (Line == 0)
396     return;
397   DIFile File = Ty.getFile();
398   unsigned FileID = DD->getOrCreateSourceID(File.getFilename(),
399                                             File.getDirectory(), getUniqueID());
400   assert(FileID && "Invalid file id");
401   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
402   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
405 /// addSourceLine - Add location information to specified debug information
406 /// entry.
407 void CompileUnit::addSourceLine(DIE *Die, DINameSpace NS) {
408   // Verify namespace.
409   if (!NS.Verify())
410     return;
412   unsigned Line = NS.getLineNumber();
413   if (Line == 0)
414     return;
415   StringRef FN = NS.getFilename();
417   unsigned FileID =
418       DD->getOrCreateSourceID(FN, NS.getDirectory(), getUniqueID());
419   assert(FileID && "Invalid file id");
420   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
421   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
424 /// addVariableAddress - Add DW_AT_location attribute for a
425 /// DbgVariable based on provided MachineLocation.
426 void CompileUnit::addVariableAddress(const DbgVariable &DV, DIE *Die,
427                                      MachineLocation Location) {
428   if (DV.variableHasComplexAddress())
429     addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
430   else if (DV.isBlockByrefVariable())
431     addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
432   else
433     addAddress(Die, dwarf::DW_AT_location, Location,
434                DV.getVariable().isIndirect());
437 /// addRegisterOp - Add register operand.
438 void CompileUnit::addRegisterOp(DIEBlock *TheDie, unsigned Reg) {
439   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
440   unsigned DWReg = RI->getDwarfRegNum(Reg, false);
441   if (DWReg < 32)
442     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
443   else {
444     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
445     addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
446   }
449 /// addRegisterOffset - Add register offset.
450 void CompileUnit::addRegisterOffset(DIEBlock *TheDie, unsigned Reg,
451                                     int64_t Offset) {
452   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
453   unsigned DWReg = RI->getDwarfRegNum(Reg, false);
454   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
455   if (Reg == TRI->getFrameRegister(*Asm->MF))
456     // If variable offset is based in frame register then use fbreg.
457     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
458   else if (DWReg < 32)
459     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
460   else {
461     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
462     addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
463   }
464   addSInt(TheDie, dwarf::DW_FORM_sdata, Offset);
467 /// addAddress - Add an address attribute to a die based on the location
468 /// provided.
469 void CompileUnit::addAddress(DIE *Die, dwarf::Attribute Attribute,
470                              const MachineLocation &Location, bool Indirect) {
471   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
473   if (Location.isReg() && !Indirect)
474     addRegisterOp(Block, Location.getReg());
475   else {
476     addRegisterOffset(Block, Location.getReg(), Location.getOffset());
477     if (Indirect && !Location.isReg()) {
478       addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
479     }
480   }
482   // Now attach the location information to the DIE.
483   addBlock(Die, Attribute, Block);
486 /// addComplexAddress - Start with the address based on the location provided,
487 /// and generate the DWARF information necessary to find the actual variable
488 /// given the extra address information encoded in the DIVariable, starting from
489 /// the starting location.  Add the DWARF information to the die.
490 ///
491 void CompileUnit::addComplexAddress(const DbgVariable &DV, DIE *Die,
492                                     dwarf::Attribute Attribute,
493                                     const MachineLocation &Location) {
494   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
495   unsigned N = DV.getNumAddrElements();
496   unsigned i = 0;
497   if (Location.isReg()) {
498     if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
499       // If first address element is OpPlus then emit
500       // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
501       addRegisterOffset(Block, Location.getReg(), DV.getAddrElement(1));
502       i = 2;
503     } else
504       addRegisterOp(Block, Location.getReg());
505   } else
506     addRegisterOffset(Block, Location.getReg(), Location.getOffset());
508   for (; i < N; ++i) {
509     uint64_t Element = DV.getAddrElement(i);
510     if (Element == DIBuilder::OpPlus) {
511       addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
512       addUInt(Block, dwarf::DW_FORM_udata, DV.getAddrElement(++i));
513     } else if (Element == DIBuilder::OpDeref) {
514       if (!Location.isReg())
515         addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
516     } else
517       llvm_unreachable("unknown DIBuilder Opcode");
518   }
520   // Now attach the location information to the DIE.
521   addBlock(Die, Attribute, Block);
524 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
525    VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
526    gives the variable VarName either the struct, or a pointer to the struct, as
527    its type.  This is necessary for various behind-the-scenes things the
528    compiler needs to do with by-reference variables in Blocks.
530    However, as far as the original *programmer* is concerned, the variable
531    should still have type 'SomeType', as originally declared.
533    The function getBlockByrefType dives into the __Block_byref_x_VarName
534    struct to find the original type of the variable, which is then assigned to
535    the variable's Debug Information Entry as its real type.  So far, so good.
536    However now the debugger will expect the variable VarName to have the type
537    SomeType.  So we need the location attribute for the variable to be an
538    expression that explains to the debugger how to navigate through the
539    pointers and struct to find the actual variable of type SomeType.
541    The following function does just that.  We start by getting
542    the "normal" location for the variable. This will be the location
543    of either the struct __Block_byref_x_VarName or the pointer to the
544    struct __Block_byref_x_VarName.
546    The struct will look something like:
548    struct __Block_byref_x_VarName {
549      ... <various fields>
550      struct __Block_byref_x_VarName *forwarding;
551      ... <various other fields>
552      SomeType VarName;
553      ... <maybe more fields>
554    };
556    If we are given the struct directly (as our starting point) we
557    need to tell the debugger to:
559    1).  Add the offset of the forwarding field.
561    2).  Follow that pointer to get the real __Block_byref_x_VarName
562    struct to use (the real one may have been copied onto the heap).
564    3).  Add the offset for the field VarName, to find the actual variable.
566    If we started with a pointer to the struct, then we need to
567    dereference that pointer first, before the other steps.
568    Translating this into DWARF ops, we will need to append the following
569    to the current location description for the variable:
571    DW_OP_deref                    -- optional, if we start with a pointer
572    DW_OP_plus_uconst <forward_fld_offset>
573    DW_OP_deref
574    DW_OP_plus_uconst <varName_fld_offset>
576    That is what this function does.  */
578 /// addBlockByrefAddress - Start with the address based on the location
579 /// provided, and generate the DWARF information necessary to find the
580 /// actual Block variable (navigating the Block struct) based on the
581 /// starting location.  Add the DWARF information to the die.  For
582 /// more information, read large comment just above here.
583 ///
584 void CompileUnit::addBlockByrefAddress(const DbgVariable &DV, DIE *Die,
585                                        dwarf::Attribute Attribute,
586                                        const MachineLocation &Location) {
587   DIType Ty = DV.getType();
588   DIType TmpTy = Ty;
589   uint16_t Tag = Ty.getTag();
590   bool isPointer = false;
592   StringRef varName = DV.getName();
594   if (Tag == dwarf::DW_TAG_pointer_type) {
595     DIDerivedType DTy = DIDerivedType(Ty);
596     TmpTy = resolve(DTy.getTypeDerivedFrom());
597     isPointer = true;
598   }
600   DICompositeType blockStruct = DICompositeType(TmpTy);
602   // Find the __forwarding field and the variable field in the __Block_byref
603   // struct.
604   DIArray Fields = blockStruct.getTypeArray();
605   DIDescriptor varField = DIDescriptor();
606   DIDescriptor forwardingField = DIDescriptor();
608   for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
609     DIDescriptor Element = Fields.getElement(i);
610     DIDerivedType DT = DIDerivedType(Element);
611     StringRef fieldName = DT.getName();
612     if (fieldName == "__forwarding")
613       forwardingField = Element;
614     else if (fieldName == varName)
615       varField = Element;
616   }
618   // Get the offsets for the forwarding field and the variable field.
619   unsigned forwardingFieldOffset =
620       DIDerivedType(forwardingField).getOffsetInBits() >> 3;
621   unsigned varFieldOffset = DIDerivedType(varField).getOffsetInBits() >> 3;
623   // Decode the original location, and use that as the start of the byref
624   // variable's location.
625   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
627   if (Location.isReg())
628     addRegisterOp(Block, Location.getReg());
629   else
630     addRegisterOffset(Block, Location.getReg(), Location.getOffset());
632   // If we started with a pointer to the __Block_byref... struct, then
633   // the first thing we need to do is dereference the pointer (DW_OP_deref).
634   if (isPointer)
635     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
637   // Next add the offset for the '__forwarding' field:
638   // DW_OP_plus_uconst ForwardingFieldOffset.  Note there's no point in
639   // adding the offset if it's 0.
640   if (forwardingFieldOffset > 0) {
641     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
642     addUInt(Block, dwarf::DW_FORM_udata, forwardingFieldOffset);
643   }
645   // Now dereference the __forwarding field to get to the real __Block_byref
646   // struct:  DW_OP_deref.
647   addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
649   // Now that we've got the real __Block_byref... struct, add the offset
650   // for the variable's field to get to the location of the actual variable:
651   // DW_OP_plus_uconst varFieldOffset.  Again, don't add if it's 0.
652   if (varFieldOffset > 0) {
653     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
654     addUInt(Block, dwarf::DW_FORM_udata, varFieldOffset);
655   }
657   // Now attach the location information to the DIE.
658   addBlock(Die, Attribute, Block);
661 /// isTypeSigned - Return true if the type is signed.
662 static bool isTypeSigned(DwarfDebug *DD, DIType Ty, int *SizeInBits) {
663   if (Ty.isDerivedType())
664     return isTypeSigned(DD, DD->resolve(DIDerivedType(Ty).getTypeDerivedFrom()),
665                         SizeInBits);
666   if (Ty.isBasicType())
667     if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed ||
668         DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
669       *SizeInBits = Ty.getSizeInBits();
670       return true;
671     }
672   return false;
675 /// Return true if type encoding is unsigned.
676 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
677   DIDerivedType DTy(Ty);
678   if (DTy.isDerivedType())
679     return isUnsignedDIType(DD, DD->resolve(DTy.getTypeDerivedFrom()));
681   DIBasicType BTy(Ty);
682   if (BTy.isBasicType()) {
683     unsigned Encoding = BTy.getEncoding();
684     if (Encoding == dwarf::DW_ATE_unsigned ||
685         Encoding == dwarf::DW_ATE_unsigned_char ||
686         Encoding == dwarf::DW_ATE_boolean)
687       return true;
688   }
689   return false;
692 /// If this type is derived from a base type then return base type size.
693 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
694   unsigned Tag = Ty.getTag();
696   if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
697       Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
698       Tag != dwarf::DW_TAG_restrict_type)
699     return Ty.getSizeInBits();
701   DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
703   // If this type is not derived from any type then take conservative approach.
704   if (!BaseType.isValid())
705     return Ty.getSizeInBits();
707   // If this is a derived type, go ahead and get the base type, unless it's a
708   // reference then it's just the size of the field. Pointer types have no need
709   // of this since they're a different type of qualification on the type.
710   if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
711       BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
712     return Ty.getSizeInBits();
714   if (BaseType.isDerivedType())
715     return getBaseTypeSize(DD, DIDerivedType(BaseType));
717   return BaseType.getSizeInBits();
720 /// addConstantValue - Add constant value entry in variable DIE.
721 void CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
722                                    DIType Ty) {
723   // FIXME: This is a bit conservative/simple - it emits negative values at
724   // their maximum bit width which is a bit unfortunate (& doesn't prefer
725   // udata/sdata over dataN as suggested by the DWARF spec)
726   assert(MO.isImm() && "Invalid machine operand!");
727   int SizeInBits = -1;
728   bool SignedConstant = isTypeSigned(DD, Ty, &SizeInBits);
729   dwarf::Form Form;
731   // If we're a signed constant definitely use sdata.
732   if (SignedConstant) {
733     addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, MO.getImm());
734     return;
735   }
737   // Else use data for now unless it's larger than we can deal with.
738   switch (SizeInBits) {
739   case 8:
740     Form = dwarf::DW_FORM_data1;
741     break;
742   case 16:
743     Form = dwarf::DW_FORM_data2;
744     break;
745   case 32:
746     Form = dwarf::DW_FORM_data4;
747     break;
748   case 64:
749     Form = dwarf::DW_FORM_data8;
750     break;
751   default:
752     Form = dwarf::DW_FORM_udata;
753     addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
754     return;
755   }
756   addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
759 /// addConstantFPValue - Add constant value entry in variable DIE.
760 void CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
761   assert(MO.isFPImm() && "Invalid machine operand!");
762   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
763   APFloat FPImm = MO.getFPImm()->getValueAPF();
765   // Get the raw data form of the floating point.
766   const APInt FltVal = FPImm.bitcastToAPInt();
767   const char *FltPtr = (const char *)FltVal.getRawData();
769   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
770   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
771   int Incr = (LittleEndian ? 1 : -1);
772   int Start = (LittleEndian ? 0 : NumBytes - 1);
773   int Stop = (LittleEndian ? NumBytes : -1);
775   // Output the constant to DWARF one byte at a time.
776   for (; Start != Stop; Start += Incr)
777     addUInt(Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
779   addBlock(Die, dwarf::DW_AT_const_value, Block);
782 /// addConstantFPValue - Add constant value entry in variable DIE.
783 void CompileUnit::addConstantFPValue(DIE *Die, const ConstantFP *CFP) {
784   // Pass this down to addConstantValue as an unsigned bag of bits.
785   addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
788 /// addConstantValue - Add constant value entry in variable DIE.
789 void CompileUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
790                                    bool Unsigned) {
791   addConstantValue(Die, CI->getValue(), Unsigned);
794 // addConstantValue - Add constant value entry in variable DIE.
795 void CompileUnit::addConstantValue(DIE *Die, const APInt &Val, bool Unsigned) {
796   unsigned CIBitWidth = Val.getBitWidth();
797   if (CIBitWidth <= 64) {
798     // If we're a signed constant definitely use sdata.
799     if (!Unsigned) {
800       addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
801               Val.getSExtValue());
802       return;
803     }
805     // Else use data for now unless it's larger than we can deal with.
806     dwarf::Form Form;
807     switch (CIBitWidth) {
808     case 8:
809       Form = dwarf::DW_FORM_data1;
810       break;
811     case 16:
812       Form = dwarf::DW_FORM_data2;
813       break;
814     case 32:
815       Form = dwarf::DW_FORM_data4;
816       break;
817     case 64:
818       Form = dwarf::DW_FORM_data8;
819       break;
820     default:
821       addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
822               Val.getZExtValue());
823       return;
824     }
825     addUInt(Die, dwarf::DW_AT_const_value, Form, Val.getZExtValue());
826     return;
827   }
829   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
831   // Get the raw data form of the large APInt.
832   const uint64_t *Ptr64 = Val.getRawData();
834   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
835   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
837   // Output the constant to DWARF one byte at a time.
838   for (int i = 0; i < NumBytes; i++) {
839     uint8_t c;
840     if (LittleEndian)
841       c = Ptr64[i / 8] >> (8 * (i & 7));
842     else
843       c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
844     addUInt(Block, dwarf::DW_FORM_data1, c);
845   }
847   addBlock(Die, dwarf::DW_AT_const_value, Block);
850 /// addTemplateParams - Add template parameters into buffer.
851 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
852   // Add template parameters.
853   for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
854     DIDescriptor Element = TParams.getElement(i);
855     if (Element.isTemplateTypeParameter())
856       constructTemplateTypeParameterDIE(Buffer,
857                                         DITemplateTypeParameter(Element));
858     else if (Element.isTemplateValueParameter())
859       constructTemplateValueParameterDIE(Buffer,
860                                          DITemplateValueParameter(Element));
861   }
864 /// getOrCreateContextDIE - Get context owner's DIE.
865 DIE *CompileUnit::getOrCreateContextDIE(DIScope Context) {
866   if (!Context || Context.isFile())
867     return getCUDie();
868   if (Context.isType())
869     return getOrCreateTypeDIE(DIType(Context));
870   if (Context.isNameSpace())
871     return getOrCreateNameSpace(DINameSpace(Context));
872   if (Context.isSubprogram())
873     return getOrCreateSubprogramDIE(DISubprogram(Context));
874   return getDIE(Context);
877 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
878 /// given DIType.
879 DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
880   if (!TyNode)
881     return NULL;
883   DIType Ty(TyNode);
884   assert(Ty.isType());
886   // Construct the context before querying for the existence of the DIE in case
887   // such construction creates the DIE.
888   DIE *ContextDIE = getOrCreateContextDIE(resolve(Ty.getContext()));
889   // TODO: Investigate if this beavior is intentional and possibly
890   // replace it with an assert.
891   if (!ContextDIE)
892     ContextDIE = getCUDie();
894   DIE *TyDIE = getDIE(Ty);
895   if (TyDIE)
896     return TyDIE;
898   // Create new type.
899   TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
901   if (Ty.isBasicType())
902     constructTypeDIE(*TyDIE, DIBasicType(Ty));
903   else if (Ty.isCompositeType())
904     constructTypeDIE(*TyDIE, DICompositeType(Ty));
905   else {
906     assert(Ty.isDerivedType() && "Unknown kind of DIType");
907     constructTypeDIE(*TyDIE, DIDerivedType(Ty));
908   }
909   // If this is a named finished type then include it in the list of types
910   // for the accelerator tables.
911   if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
912     bool IsImplementation = 0;
913     if (Ty.isCompositeType()) {
914       DICompositeType CT(Ty);
915       // A runtime language of 0 actually means C/C++ and that any
916       // non-negative value is some version of Objective-C/C++.
917       IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
918     }
919     unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
920     addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
921   }
923   return TyDIE;
926 /// addType - Add a new type attribute to the specified entity.
927 void CompileUnit::addType(DIE *Entity, DIType Ty, dwarf::Attribute Attribute) {
928   assert(Ty && "Trying to add a type that doesn't exist?");
930   // Check for pre-existence.
931   DIEEntry *Entry = getDIEEntry(Ty);
932   // If it exists then use the existing value.
933   if (Entry) {
934     addDIEEntry(Entity, Attribute, Entry);
935     return;
936   }
938   // Construct type.
939   DIE *Buffer = getOrCreateTypeDIE(Ty);
941   // Set up proxy.
942   Entry = createDIEEntry(Buffer);
943   insertDIEEntry(Ty, Entry);
944   addDIEEntry(Entity, Attribute, Entry);
946   // If this is a complete composite type then include it in the
947   // list of global types.
948   addGlobalType(Ty);
951 // Accelerator table mutators - add each name along with its companion
952 // DIE to the proper table while ensuring that the name that we're going
953 // to reference is in the string table. We do this since the names we
954 // add may not only be identical to the names in the DIE.
955 void CompileUnit::addAccelName(StringRef Name, DIE *Die) {
956   DU->getStringPoolEntry(Name);
957   std::vector<DIE *> &DIEs = AccelNames[Name];
958   DIEs.push_back(Die);
961 void CompileUnit::addAccelObjC(StringRef Name, DIE *Die) {
962   DU->getStringPoolEntry(Name);
963   std::vector<DIE *> &DIEs = AccelObjC[Name];
964   DIEs.push_back(Die);
967 void CompileUnit::addAccelNamespace(StringRef Name, DIE *Die) {
968   DU->getStringPoolEntry(Name);
969   std::vector<DIE *> &DIEs = AccelNamespace[Name];
970   DIEs.push_back(Die);
973 void CompileUnit::addAccelType(StringRef Name, std::pair<DIE *, unsigned> Die) {
974   DU->getStringPoolEntry(Name);
975   std::vector<std::pair<DIE *, unsigned> > &DIEs = AccelTypes[Name];
976   DIEs.push_back(Die);
979 /// addGlobalName - Add a new global name to the compile unit.
980 void CompileUnit::addGlobalName(StringRef Name, DIE *Die, DIScope Context) {
981   std::string FullName = getParentContextString(Context) + Name.str();
982   GlobalNames[FullName] = Die;
985 /// addGlobalType - Add a new global type to the compile unit.
986 ///
987 void CompileUnit::addGlobalType(DIType Ty) {
988   DIScope Context = resolve(Ty.getContext());
989   if (!Ty.getName().empty() && !Ty.isForwardDecl() &&
990       (!Context || Context.isCompileUnit() || Context.isFile() ||
991        Context.isNameSpace()))
992     if (DIEEntry *Entry = getDIEEntry(Ty)) {
993       std::string FullName =
994           getParentContextString(Context) + Ty.getName().str();
995       GlobalTypes[FullName] = Entry->getEntry();
996     }
999 /// getParentContextString - Walks the metadata parent chain in a language
1000 /// specific manner (using the compile unit language) and returns
1001 /// it as a string. This is done at the metadata level because DIEs may
1002 /// not currently have been added to the parent context and walking the
1003 /// DIEs looking for names is more expensive than walking the metadata.
1004 std::string CompileUnit::getParentContextString(DIScope Context) const {
1005   if (!Context)
1006     return "";
1008   // FIXME: Decide whether to implement this for non-C++ languages.
1009   if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
1010     return "";
1012   std::string CS;
1013   SmallVector<DIScope, 1> Parents;
1014   while (!Context.isCompileUnit()) {
1015     Parents.push_back(Context);
1016     if (Context.getContext())
1017       Context = resolve(Context.getContext());
1018     else
1019       // Structure, etc types will have a NULL context if they're at the top
1020       // level.
1021       break;
1022   }
1024   // Reverse iterate over our list to go from the outermost construct to the
1025   // innermost.
1026   for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
1027                                                   E = Parents.rend();
1028        I != E; ++I) {
1029     DIScope Ctx = *I;
1030     StringRef Name = Ctx.getName();
1031     if (!Name.empty()) {
1032       CS += Name;
1033       CS += "::";
1034     }
1035   }
1036   return CS;
1039 /// addPubTypes - Add subprogram argument types for pubtypes section.
1040 void CompileUnit::addPubTypes(DISubprogram SP) {
1041   DICompositeType SPTy = SP.getType();
1042   uint16_t SPTag = SPTy.getTag();
1043   if (SPTag != dwarf::DW_TAG_subroutine_type)
1044     return;
1046   DIArray Args = SPTy.getTypeArray();
1047   for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1048     DIType ATy(Args.getElement(i));
1049     if (!ATy.isType())
1050       continue;
1051     addGlobalType(ATy);
1052   }
1055 /// constructTypeDIE - Construct basic type die from DIBasicType.
1056 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
1057   // Get core information.
1058   StringRef Name = BTy.getName();
1059   // Add name if not anonymous or intermediate type.
1060   if (!Name.empty())
1061     addString(&Buffer, dwarf::DW_AT_name, Name);
1063   // An unspecified type only has a name attribute.
1064   if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
1065     return;
1067   addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1068           BTy.getEncoding());
1070   uint64_t Size = BTy.getSizeInBits() >> 3;
1071   addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1074 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1075 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1076   // Get core information.
1077   StringRef Name = DTy.getName();
1078   uint64_t Size = DTy.getSizeInBits() >> 3;
1079   uint16_t Tag = Buffer.getTag();
1081   // Map to main type, void will not have a type.
1082   DIType FromTy = resolve(DTy.getTypeDerivedFrom());
1083   if (FromTy)
1084     addType(&Buffer, FromTy);
1086   // Add name if not anonymous or intermediate type.
1087   if (!Name.empty())
1088     addString(&Buffer, dwarf::DW_AT_name, Name);
1090   // Add size if non-zero (derived types might be zero-sized.)
1091   if (Size && Tag != dwarf::DW_TAG_pointer_type)
1092     addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1094   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
1095     addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1096                 getOrCreateTypeDIE(resolve(DTy.getClassType())));
1097   // Add source line info if available and TyDesc is not a forward declaration.
1098   if (!DTy.isForwardDecl())
1099     addSourceLine(&Buffer, DTy);
1102 /// Return true if the type is appropriately scoped to be contained inside
1103 /// its own type unit.
1104 static bool isTypeUnitScoped(DIType Ty, const DwarfDebug *DD) {
1105   DIScope Parent = DD->resolve(Ty.getContext());
1106   while (Parent) {
1107     // Don't generate a hash for anything scoped inside a function.
1108     if (Parent.isSubprogram())
1109       return false;
1110     Parent = DD->resolve(Parent.getContext());
1111   }
1112   return true;
1115 /// Return true if the type should be split out into a type unit.
1116 static bool shouldCreateTypeUnit(DICompositeType CTy, const DwarfDebug *DD) {
1117   uint16_t Tag = CTy.getTag();
1119   switch (Tag) {
1120   case dwarf::DW_TAG_structure_type:
1121   case dwarf::DW_TAG_union_type:
1122   case dwarf::DW_TAG_enumeration_type:
1123   case dwarf::DW_TAG_class_type:
1124     // If this is a class, structure, union, or enumeration type
1125     // that is a definition (not a declaration), and not scoped
1126     // inside a function then separate this out as a type unit.
1127     return !CTy.isForwardDecl() && isTypeUnitScoped(CTy, DD);
1128   default:
1129     return false;
1130   }
1133 /// constructTypeDIE - Construct type DIE from DICompositeType.
1134 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1135   // Get core information.
1136   StringRef Name = CTy.getName();
1138   uint64_t Size = CTy.getSizeInBits() >> 3;
1139   uint16_t Tag = Buffer.getTag();
1141   switch (Tag) {
1142   case dwarf::DW_TAG_array_type:
1143     constructArrayTypeDIE(Buffer, CTy);
1144     break;
1145   case dwarf::DW_TAG_enumeration_type:
1146     constructEnumTypeDIE(Buffer, CTy);
1147     break;
1148   case dwarf::DW_TAG_subroutine_type: {
1149     // Add return type. A void return won't have a type.
1150     DIArray Elements = CTy.getTypeArray();
1151     DIDescriptor RTy = Elements.getElement(0);
1152     if (RTy)
1153       addType(&Buffer, DIType(RTy));
1155     bool isPrototyped = true;
1156     // Add arguments.
1157     for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1158       DIDescriptor Ty = Elements.getElement(i);
1159       if (Ty.isUnspecifiedParameter()) {
1160         createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1161         isPrototyped = false;
1162       } else {
1163         DIE *Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1164         addType(Arg, DIType(Ty));
1165         if (DIType(Ty).isArtificial())
1166           addFlag(Arg, dwarf::DW_AT_artificial);
1167       }
1168     }
1169     // Add prototype flag if we're dealing with a C language and the
1170     // function has been prototyped.
1171     uint16_t Language = DICompileUnit(Node).getLanguage();
1172     if (isPrototyped &&
1173         (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1174          Language == dwarf::DW_LANG_ObjC))
1175       addFlag(&Buffer, dwarf::DW_AT_prototyped);
1176   } break;
1177   case dwarf::DW_TAG_structure_type:
1178   case dwarf::DW_TAG_union_type:
1179   case dwarf::DW_TAG_class_type: {
1180     // Add elements to structure type.
1181     DIArray Elements = CTy.getTypeArray();
1182     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1183       DIDescriptor Element = Elements.getElement(i);
1184       DIE *ElemDie = NULL;
1185       if (Element.isSubprogram()) {
1186         DISubprogram SP(Element);
1187         ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
1188         if (SP.isProtected())
1189           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1190                   dwarf::DW_ACCESS_protected);
1191         else if (SP.isPrivate())
1192           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1193                   dwarf::DW_ACCESS_private);
1194         else
1195           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1196                   dwarf::DW_ACCESS_public);
1197         if (SP.isExplicit())
1198           addFlag(ElemDie, dwarf::DW_AT_explicit);
1199       } else if (Element.isDerivedType()) {
1200         DIDerivedType DDTy(Element);
1201         if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1202           ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1203           addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1204                   dwarf::DW_AT_friend);
1205         } else if (DDTy.isStaticMember()) {
1206           getOrCreateStaticMemberDIE(DDTy);
1207         } else {
1208           constructMemberDIE(Buffer, DDTy);
1209         }
1210       } else if (Element.isObjCProperty()) {
1211         DIObjCProperty Property(Element);
1212         ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1213         StringRef PropertyName = Property.getObjCPropertyName();
1214         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1215         addType(ElemDie, Property.getType());
1216         addSourceLine(ElemDie, Property);
1217         StringRef GetterName = Property.getObjCPropertyGetterName();
1218         if (!GetterName.empty())
1219           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1220         StringRef SetterName = Property.getObjCPropertySetterName();
1221         if (!SetterName.empty())
1222           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1223         unsigned PropertyAttributes = 0;
1224         if (Property.isReadOnlyObjCProperty())
1225           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1226         if (Property.isReadWriteObjCProperty())
1227           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1228         if (Property.isAssignObjCProperty())
1229           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1230         if (Property.isRetainObjCProperty())
1231           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1232         if (Property.isCopyObjCProperty())
1233           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1234         if (Property.isNonAtomicObjCProperty())
1235           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1236         if (PropertyAttributes)
1237           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1238                   PropertyAttributes);
1240         DIEEntry *Entry = getDIEEntry(Element);
1241         if (!Entry) {
1242           Entry = createDIEEntry(ElemDie);
1243           insertDIEEntry(Element, Entry);
1244         }
1245       } else
1246         continue;
1247     }
1249     if (CTy.isAppleBlockExtension())
1250       addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
1252     DICompositeType ContainingType(resolve(CTy.getContainingType()));
1253     if (DIDescriptor(ContainingType).isCompositeType())
1254       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1255                   getOrCreateTypeDIE(DIType(ContainingType)));
1257     if (CTy.isObjcClassComplete())
1258       addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1260     // Add template parameters to a class, structure or union types.
1261     // FIXME: The support isn't in the metadata for this yet.
1262     if (Tag == dwarf::DW_TAG_class_type ||
1263         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1264       addTemplateParams(Buffer, CTy.getTemplateParams());
1266     break;
1267   }
1268   default:
1269     break;
1270   }
1272   // Add name if not anonymous or intermediate type.
1273   if (!Name.empty())
1274     addString(&Buffer, dwarf::DW_AT_name, Name);
1276   if (Tag == dwarf::DW_TAG_enumeration_type ||
1277       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1278       Tag == dwarf::DW_TAG_union_type) {
1279     // Add size if non-zero (derived types might be zero-sized.)
1280     // TODO: Do we care about size for enum forward declarations?
1281     if (Size)
1282       addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1283     else if (!CTy.isForwardDecl())
1284       // Add zero size if it is not a forward declaration.
1285       addUInt(&Buffer, dwarf::DW_AT_byte_size, None, 0);
1287     // If we're a forward decl, say so.
1288     if (CTy.isForwardDecl())
1289       addFlag(&Buffer, dwarf::DW_AT_declaration);
1291     // Add source line info if available.
1292     if (!CTy.isForwardDecl())
1293       addSourceLine(&Buffer, CTy);
1295     // No harm in adding the runtime language to the declaration.
1296     unsigned RLang = CTy.getRunTimeLang();
1297     if (RLang)
1298       addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1299               RLang);
1300   }
1301   // If this is a type applicable to a type unit it then add it to the
1302   // list of types we'll compute a hash for later.
1303   if (shouldCreateTypeUnit(CTy, DD))
1304     DD->addTypeUnitType(&Buffer);
1307 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1308 /// DITemplateTypeParameter.
1309 void
1310 CompileUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1311                                                DITemplateTypeParameter TP) {
1312   DIE *ParamDIE =
1313       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1314   // Add the type if it exists, it could be void and therefore no type.
1315   if (TP.getType())
1316     addType(ParamDIE, resolve(TP.getType()));
1317   if (!TP.getName().empty())
1318     addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1321 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1322 /// DITemplateValueParameter.
1323 void
1324 CompileUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1325                                                 DITemplateValueParameter VP) {
1326   DIE *ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1328   // Add the type if there is one, template template and template parameter
1329   // packs will not have a type.
1330   if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1331     addType(ParamDIE, resolve(VP.getType()));
1332   if (!VP.getName().empty())
1333     addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1334   if (Value *Val = VP.getValue()) {
1335     if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1336       addConstantValue(ParamDIE, CI,
1337                        isUnsignedDIType(DD, resolve(VP.getType())));
1338     else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1339       // For declaration non-type template parameters (such as global values and
1340       // functions)
1341       DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1342       addOpAddress(Block, Asm->getSymbol(GV));
1343       // Emit DW_OP_stack_value to use the address as the immediate value of the
1344       // parameter, rather than a pointer to it.
1345       addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1346       addBlock(ParamDIE, dwarf::DW_AT_location, Block);
1347     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1348       assert(isa<MDString>(Val));
1349       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1350                 cast<MDString>(Val)->getString());
1351     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1352       assert(isa<MDNode>(Val));
1353       DIArray A(cast<MDNode>(Val));
1354       addTemplateParams(*ParamDIE, A);
1355     }
1356   }
1359 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1360 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
1361   // Construct the context before querying for the existence of the DIE in case
1362   // such construction creates the DIE.
1363   DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1365   DIE *NDie = getDIE(NS);
1366   if (NDie)
1367     return NDie;
1368   NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1370   if (!NS.getName().empty()) {
1371     addString(NDie, dwarf::DW_AT_name, NS.getName());
1372     addAccelNamespace(NS.getName(), NDie);
1373     addGlobalName(NS.getName(), NDie, NS.getContext());
1374   } else
1375     addAccelNamespace("(anonymous namespace)", NDie);
1376   addSourceLine(NDie, NS);
1377   return NDie;
1380 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1381 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1382   // Construct the context before querying for the existence of the DIE in case
1383   // such construction creates the DIE (as is the case for member function
1384   // declarations).
1385   DIE *ContextDIE = getOrCreateContextDIE(resolve(SP.getContext()));
1387   DIE *SPDie = getDIE(SP);
1388   if (SPDie)
1389     return SPDie;
1391   DISubprogram SPDecl = SP.getFunctionDeclaration();
1392   if (SPDecl.isSubprogram())
1393     // Add subprogram definitions to the CU die directly.
1394     ContextDIE = CUDie.get();
1396   // DW_TAG_inlined_subroutine may refer to this DIE.
1397   SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1399   DIE *DeclDie = NULL;
1400   if (SPDecl.isSubprogram())
1401     DeclDie = getOrCreateSubprogramDIE(SPDecl);
1403   // Add function template parameters.
1404   addTemplateParams(*SPDie, SP.getTemplateParams());
1406   // If this DIE is going to refer declaration info using AT_specification
1407   // then there is no need to add other attributes.
1408   if (DeclDie) {
1409     // Refer function declaration directly.
1410     addDIEEntry(SPDie, dwarf::DW_AT_specification, DeclDie);
1412     return SPDie;
1413   }
1415   // Add the linkage name if we have one.
1416   StringRef LinkageName = SP.getLinkageName();
1417   if (!LinkageName.empty())
1418     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1419               GlobalValue::getRealLinkageName(LinkageName));
1421   // Constructors and operators for anonymous aggregates do not have names.
1422   if (!SP.getName().empty())
1423     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1425   addSourceLine(SPDie, SP);
1427   // Add the prototype if we have a prototype and we have a C like
1428   // language.
1429   uint16_t Language = DICompileUnit(Node).getLanguage();
1430   if (SP.isPrototyped() &&
1431       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1432        Language == dwarf::DW_LANG_ObjC))
1433     addFlag(SPDie, dwarf::DW_AT_prototyped);
1435   DICompositeType SPTy = SP.getType();
1436   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1437          "the type of a subprogram should be a subroutine");
1439   DIArray Args = SPTy.getTypeArray();
1440   // Add a return type. If this is a type like a C/C++ void type we don't add a
1441   // return type.
1442   if (Args.getElement(0))
1443     addType(SPDie, DIType(Args.getElement(0)));
1445   unsigned VK = SP.getVirtuality();
1446   if (VK) {
1447     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1448     DIEBlock *Block = getDIEBlock();
1449     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1450     addUInt(Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1451     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1452     ContainingTypeMap.insert(
1453         std::make_pair(SPDie, resolve(SP.getContainingType())));
1454   }
1456   if (!SP.isDefinition()) {
1457     addFlag(SPDie, dwarf::DW_AT_declaration);
1459     // Add arguments. Do not add arguments for subprogram definition. They will
1460     // be handled while processing variables.
1461     for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1462       DIE *Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, *SPDie);
1463       DIType ATy = DIType(Args.getElement(i));
1464       addType(Arg, ATy);
1465       if (ATy.isArtificial())
1466         addFlag(Arg, dwarf::DW_AT_artificial);
1467     }
1468   }
1470   if (SP.isArtificial())
1471     addFlag(SPDie, dwarf::DW_AT_artificial);
1473   if (!SP.isLocalToUnit())
1474     addFlag(SPDie, dwarf::DW_AT_external);
1476   if (SP.isOptimized())
1477     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1479   if (unsigned isa = Asm->getISAEncoding()) {
1480     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1481   }
1483   return SPDie;
1486 // Return const expression if value is a GEP to access merged global
1487 // constant. e.g.
1488 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1489 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1490   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1491   if (!CE || CE->getNumOperands() != 3 ||
1492       CE->getOpcode() != Instruction::GetElementPtr)
1493     return NULL;
1495   // First operand points to a global struct.
1496   Value *Ptr = CE->getOperand(0);
1497   if (!isa<GlobalValue>(Ptr) ||
1498       !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1499     return NULL;
1501   // Second operand is zero.
1502   const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1503   if (!CI || !CI->isZero())
1504     return NULL;
1506   // Third operand is offset.
1507   if (!isa<ConstantInt>(CE->getOperand(2)))
1508     return NULL;
1510   return CE;
1513 /// createGlobalVariableDIE - create global variable DIE.
1514 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1515   DIGlobalVariable GV(N);
1517   // Check for pre-existence.
1518   if (getDIE(GV))
1519     return;
1521   if (!GV.isGlobalVariable())
1522     return;
1524   DIScope GVContext = GV.getContext();
1525   DIType GTy = GV.getType();
1527   // If this is a static data member definition, some attributes belong
1528   // to the declaration DIE.
1529   DIE *VariableDIE = NULL;
1530   bool IsStaticMember = false;
1531   DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1532   if (SDMDecl.Verify()) {
1533     assert(SDMDecl.isStaticMember() && "Expected static member decl");
1534     // We need the declaration DIE that is in the static member's class.
1535     VariableDIE = getOrCreateStaticMemberDIE(SDMDecl);
1536     IsStaticMember = true;
1537   }
1539   // If this is not a static data member definition, create the variable
1540   // DIE and add the initial set of attributes to it.
1541   if (!VariableDIE) {
1542     // Construct the context before querying for the existence of the DIE in
1543     // case such construction creates the DIE.
1544     DIE *ContextDIE = getOrCreateContextDIE(GVContext);
1546     // Add to map.
1547     VariableDIE = createAndAddDIE(GV.getTag(), *ContextDIE, N);
1549     // Add name and type.
1550     addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1551     addType(VariableDIE, GTy);
1553     // Add scoping info.
1554     if (!GV.isLocalToUnit())
1555       addFlag(VariableDIE, dwarf::DW_AT_external);
1557     // Add line number info.
1558     addSourceLine(VariableDIE, GV);
1559   }
1561   // Add location.
1562   bool addToAccelTable = false;
1563   DIE *VariableSpecDIE = NULL;
1564   bool isGlobalVariable = GV.getGlobal() != NULL;
1565   if (isGlobalVariable) {
1566     addToAccelTable = true;
1567     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1568     const MCSymbol *Sym = Asm->getSymbol(GV.getGlobal());
1569     if (GV.getGlobal()->isThreadLocal()) {
1570       // FIXME: Make this work with -gsplit-dwarf.
1571       unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1572       assert((PointerSize == 4 || PointerSize == 8) &&
1573              "Add support for other sizes if necessary");
1574       const MCExpr *Expr =
1575           Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym);
1576       // Based on GCC's support for TLS:
1577       if (!DD->useSplitDwarf()) {
1578         // 1) Start with a constNu of the appropriate pointer size
1579         addUInt(Block, dwarf::DW_FORM_data1,
1580                 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1581         // 2) containing the (relocated) offset of the TLS variable
1582         //    within the module's TLS block.
1583         addExpr(Block, dwarf::DW_FORM_udata, Expr);
1584       } else {
1585         addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1586         addUInt(Block, dwarf::DW_FORM_udata, DU->getAddrPoolIndex(Expr));
1587       }
1588       // 3) followed by a custom OP to make the debugger do a TLS lookup.
1589       addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_push_tls_address);
1590     } else
1591       addOpAddress(Block, Sym);
1592     // Do not create specification DIE if context is either compile unit
1593     // or a subprogram.
1594     if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1595         !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1596       // Create specification DIE.
1597       VariableSpecDIE = createAndAddDIE(dwarf::DW_TAG_variable, *CUDie.get());
1598       addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, VariableDIE);
1599       addBlock(VariableSpecDIE, dwarf::DW_AT_location, Block);
1600       // A static member's declaration is already flagged as such.
1601       if (!SDMDecl.Verify())
1602         addFlag(VariableDIE, dwarf::DW_AT_declaration);
1603     } else {
1604       addBlock(VariableDIE, dwarf::DW_AT_location, Block);
1605     }
1606     // Add the linkage name.
1607     StringRef LinkageName = GV.getLinkageName();
1608     if (!LinkageName.empty())
1609       // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1610       // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1611       // TAG_variable.
1612       addString(IsStaticMember && VariableSpecDIE ? VariableSpecDIE
1613                                                   : VariableDIE,
1614                 dwarf::DW_AT_MIPS_linkage_name,
1615                 GlobalValue::getRealLinkageName(LinkageName));
1616   } else if (const ConstantInt *CI =
1617                  dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1618     // AT_const_value was added when the static member was created. To avoid
1619     // emitting AT_const_value multiple times, we only add AT_const_value when
1620     // it is not a static member.
1621     if (!IsStaticMember)
1622       addConstantValue(VariableDIE, CI, isUnsignedDIType(DD, GTy));
1623   } else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1624     addToAccelTable = true;
1625     // GV is a merged global.
1626     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1627     Value *Ptr = CE->getOperand(0);
1628     addOpAddress(Block, Asm->getSymbol(cast<GlobalValue>(Ptr)));
1629     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1630     SmallVector<Value *, 3> Idx(CE->op_begin() + 1, CE->op_end());
1631     addUInt(Block, dwarf::DW_FORM_udata,
1632             Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1633     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1634     addBlock(VariableDIE, dwarf::DW_AT_location, Block);
1635   }
1637   if (addToAccelTable) {
1638     DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1639     addAccelName(GV.getName(), AddrDIE);
1641     // If the linkage name is different than the name, go ahead and output
1642     // that as well into the name table.
1643     if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1644       addAccelName(GV.getLinkageName(), AddrDIE);
1645   }
1647   if (!GV.isLocalToUnit())
1648     addGlobalName(GV.getName(), VariableSpecDIE ? VariableSpecDIE : VariableDIE,
1649                   GV.getContext());
1652 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1653 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
1654                                        DIE *IndexTy) {
1655   DIE *DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1656   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, IndexTy);
1658   // The LowerBound value defines the lower bounds which is typically zero for
1659   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1660   // Count == -1 then the array is unbounded and we do not emit
1661   // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1662   // Count == 0, then the array has zero elements in which case we do not emit
1663   // an upper bound.
1664   int64_t LowerBound = SR.getLo();
1665   int64_t DefaultLowerBound = getDefaultLowerBound();
1666   int64_t Count = SR.getCount();
1668   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1669     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1671   if (Count != -1 && Count != 0)
1672     // FIXME: An unbounded array should reference the expression that defines
1673     // the array.
1674     addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, None,
1675             LowerBound + Count - 1);
1678 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1679 void CompileUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1680   if (CTy.isVector())
1681     addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1683   // Emit the element type.
1684   addType(&Buffer, resolve(CTy.getTypeDerivedFrom()));
1686   // Get an anonymous type for index type.
1687   // FIXME: This type should be passed down from the front end
1688   // as different languages may have different sizes for indexes.
1689   DIE *IdxTy = getIndexTyDie();
1690   if (!IdxTy) {
1691     // Construct an anonymous type for index type.
1692     IdxTy = createAndAddDIE(dwarf::DW_TAG_base_type, *CUDie.get());
1693     addString(IdxTy, dwarf::DW_AT_name, "int");
1694     addUInt(IdxTy, dwarf::DW_AT_byte_size, None, sizeof(int32_t));
1695     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1696             dwarf::DW_ATE_signed);
1697     setIndexTyDie(IdxTy);
1698   }
1700   // Add subranges to array type.
1701   DIArray Elements = CTy.getTypeArray();
1702   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1703     DIDescriptor Element = Elements.getElement(i);
1704     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1705       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1706   }
1709 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1710 void CompileUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1711   DIArray Elements = CTy.getTypeArray();
1713   // Add enumerators to enumeration type.
1714   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1715     DIDescriptor Enum(Elements.getElement(i));
1716     DIEnumerator ETy = DIEnumerator(Enum);
1717     if (Enum.isEnumerator()) {
1718       DIE *Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1719       StringRef Name = ETy.getName();
1720       addString(Enumerator, dwarf::DW_AT_name, Name);
1721       int64_t Value = ETy.getEnumValue();
1722       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1723     }
1724   }
1725   DIType DTy = resolve(CTy.getTypeDerivedFrom());
1726   if (DTy) {
1727     addType(&Buffer, DTy);
1728     addFlag(&Buffer, dwarf::DW_AT_enum_class);
1729   }
1732 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1733 /// vtables.
1734 void CompileUnit::constructContainingTypeDIEs() {
1735   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1736                                                  CE = ContainingTypeMap.end();
1737        CI != CE; ++CI) {
1738     DIE *SPDie = CI->first;
1739     DIDescriptor D(CI->second);
1740     if (!D)
1741       continue;
1742     DIE *NDie = getDIE(D);
1743     if (!NDie)
1744       continue;
1745     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, NDie);
1746   }
1749 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1750 DIE *CompileUnit::constructVariableDIE(DbgVariable &DV, bool isScopeAbstract) {
1751   StringRef Name = DV.getName();
1753   // Define variable debug information entry.
1754   DIE *VariableDie = new DIE(DV.getTag());
1755   DbgVariable *AbsVar = DV.getAbstractVariable();
1756   DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1757   if (AbsDIE)
1758     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin, AbsDIE);
1759   else {
1760     if (!Name.empty())
1761       addString(VariableDie, dwarf::DW_AT_name, Name);
1762     addSourceLine(VariableDie, DV.getVariable());
1763     addType(VariableDie, DV.getType());
1764   }
1766   if (DV.isArtificial())
1767     addFlag(VariableDie, dwarf::DW_AT_artificial);
1769   if (isScopeAbstract) {
1770     DV.setDIE(VariableDie);
1771     return VariableDie;
1772   }
1774   // Add variable address.
1776   unsigned Offset = DV.getDotDebugLocOffset();
1777   if (Offset != ~0U) {
1778     addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1779              Asm->GetTempSymbol("debug_loc", Offset));
1780     DV.setDIE(VariableDie);
1781     return VariableDie;
1782   }
1784   // Check if variable is described by a DBG_VALUE instruction.
1785   if (const MachineInstr *DVInsn = DV.getMInsn()) {
1786     assert(DVInsn->getNumOperands() == 3);
1787     if (DVInsn->getOperand(0).isReg()) {
1788       const MachineOperand RegOp = DVInsn->getOperand(0);
1789       // If the second operand is an immediate, this is an indirect value.
1790       if (DVInsn->getOperand(1).isImm()) {
1791         MachineLocation Location(RegOp.getReg(),
1792                                  DVInsn->getOperand(1).getImm());
1793         addVariableAddress(DV, VariableDie, Location);
1794       } else if (RegOp.getReg())
1795         addVariableAddress(DV, VariableDie, MachineLocation(RegOp.getReg()));
1796     } else if (DVInsn->getOperand(0).isImm())
1797       addConstantValue(VariableDie, DVInsn->getOperand(0), DV.getType());
1798     else if (DVInsn->getOperand(0).isFPImm())
1799       addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1800     else if (DVInsn->getOperand(0).isCImm())
1801       addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
1802                        isUnsignedDIType(DD, DV.getType()));
1804     DV.setDIE(VariableDie);
1805     return VariableDie;
1806   } else {
1807     // .. else use frame index.
1808     int FI = DV.getFrameIndex();
1809     if (FI != ~0) {
1810       unsigned FrameReg = 0;
1811       const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1812       int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1813       MachineLocation Location(FrameReg, Offset);
1814       addVariableAddress(DV, VariableDie, Location);
1815     }
1816   }
1818   DV.setDIE(VariableDie);
1819   return VariableDie;
1822 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1823 void CompileUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1824   DIE *MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1825   StringRef Name = DT.getName();
1826   if (!Name.empty())
1827     addString(MemberDie, dwarf::DW_AT_name, Name);
1829   addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1831   addSourceLine(MemberDie, DT);
1833   DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1834   addUInt(MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1836   if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1838     // For C++, virtual base classes are not at fixed offset. Use following
1839     // expression to extract appropriate offset from vtable.
1840     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1842     DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1843     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1844     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1845     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1846     addUInt(VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1847     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1848     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1849     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1851     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1852   } else {
1853     uint64_t Size = DT.getSizeInBits();
1854     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1855     uint64_t OffsetInBytes;
1857     if (Size != FieldSize) {
1858       // Handle bitfield.
1859       addUInt(MemberDie, dwarf::DW_AT_byte_size, None,
1860               getBaseTypeSize(DD, DT) >> 3);
1861       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, DT.getSizeInBits());
1863       uint64_t Offset = DT.getOffsetInBits();
1864       uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1865       uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1866       uint64_t FieldOffset = (HiMark - FieldSize);
1867       Offset -= FieldOffset;
1869       // Maybe we need to work from the other end.
1870       if (Asm->getDataLayout().isLittleEndian())
1871         Offset = FieldSize - (Offset + Size);
1872       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1874       // Here WD_AT_data_member_location points to the anonymous
1875       // field that includes this bit field.
1876       OffsetInBytes = FieldOffset >> 3;
1877     } else
1878       // This is not a bitfield.
1879       OffsetInBytes = DT.getOffsetInBits() >> 3;
1880     addUInt(MemberDie, dwarf::DW_AT_data_member_location, None, OffsetInBytes);
1881   }
1883   if (DT.isProtected())
1884     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1885             dwarf::DW_ACCESS_protected);
1886   else if (DT.isPrivate())
1887     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1888             dwarf::DW_ACCESS_private);
1889   // Otherwise C++ member and base classes are considered public.
1890   else
1891     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1892             dwarf::DW_ACCESS_public);
1893   if (DT.isVirtual())
1894     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1895             dwarf::DW_VIRTUALITY_virtual);
1897   // Objective-C properties.
1898   if (MDNode *PNode = DT.getObjCProperty())
1899     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1900       MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1901                           PropertyDie);
1903   if (DT.isArtificial())
1904     addFlag(MemberDie, dwarf::DW_AT_artificial);
1907 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1908 DIE *CompileUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1909   if (!DT.Verify())
1910     return NULL;
1912   // Construct the context before querying for the existence of the DIE in case
1913   // such construction creates the DIE.
1914   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1915   assert(dwarf::isType(ContextDIE->getTag()) &&
1916          "Static member should belong to a type.");
1918   DIE *StaticMemberDIE = getDIE(DT);
1919   if (StaticMemberDIE)
1920     return StaticMemberDIE;
1922   StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1924   DIType Ty = resolve(DT.getTypeDerivedFrom());
1926   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1927   addType(StaticMemberDIE, Ty);
1928   addSourceLine(StaticMemberDIE, DT);
1929   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1930   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1932   // FIXME: We could omit private if the parent is a class_type, and
1933   // public if the parent is something else.
1934   if (DT.isProtected())
1935     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1936             dwarf::DW_ACCESS_protected);
1937   else if (DT.isPrivate())
1938     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1939             dwarf::DW_ACCESS_private);
1940   else
1941     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1942             dwarf::DW_ACCESS_public);
1944   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1945     addConstantValue(StaticMemberDIE, CI, isUnsignedDIType(DD, Ty));
1946   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1947     addConstantFPValue(StaticMemberDIE, CFP);
1949   return StaticMemberDIE;
1952 void CompileUnit::emitHeader(const MCSection *ASection,
1953                              const MCSymbol *ASectionSym) {
1954   Asm->OutStreamer.AddComment("DWARF version number");
1955   Asm->EmitInt16(DD->getDwarfVersion());
1956   Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1957   Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
1958                          ASectionSym);
1959   Asm->OutStreamer.AddComment("Address Size (in bytes)");
1960   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());