blob: 836beb89b45ff07fd0a0890e922aa1c36ec87038 [file] [log] [blame]
David Blaikie319a05f2013-12-02 19:33:10 +00001//===-- llvm/CodeGen/DwarfUnit.cpp - Dwarf Type and Compile Units ---------===//
Devang Patel0e821f42011-04-12 23:21:44 +00002//
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//
Eric Christopher160522c2012-08-14 05:13:29 +000010// This file contains support for constructing a dwarf compile unit.
Devang Patel0e821f42011-04-12 23:21:44 +000011//
12//===----------------------------------------------------------------------===//
13
14#define DEBUG_TYPE "dwarfdebug"
15
David Blaikie2c86a722013-12-02 19:33:15 +000016#include "DwarfUnit.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000017#include "DwarfAccelTable.h"
Devang Patel0e821f42011-04-12 23:21:44 +000018#include "DwarfDebug.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000019#include "llvm/ADT/APFloat.h"
Chandler Carruth9fb823b2013-01-02 11:36:10 +000020#include "llvm/IR/Constants.h"
Chandler Carruth12664a02014-03-06 00:22:06 +000021#include "llvm/IR/DIBuilder.h"
Chandler Carruth9fb823b2013-01-02 11:36:10 +000022#include "llvm/IR/DataLayout.h"
23#include "llvm/IR/GlobalVariable.h"
24#include "llvm/IR/Instructions.h"
Rafael Espindola894843c2014-01-07 21:19:40 +000025#include "llvm/IR/Mangler.h"
Eric Christopher84588622013-12-28 01:39:17 +000026#include "llvm/MC/MCAsmInfo.h"
Adrian Prantlcbcd5782014-02-11 22:22:15 +000027#include "llvm/MC/MCContext.h"
David Blaikie6b288cf2013-10-30 20:42:41 +000028#include "llvm/MC/MCSection.h"
29#include "llvm/MC/MCStreamer.h"
Chandler Carruth8a8cd2b2014-01-07 11:48:04 +000030#include "llvm/Support/CommandLine.h"
Devang Patel0e821f42011-04-12 23:21:44 +000031#include "llvm/Target/TargetFrameLowering.h"
David Blaikief2694972013-06-28 20:05:11 +000032#include "llvm/Target/TargetLoweringObjectFile.h"
Chandler Carruth8a8cd2b2014-01-07 11:48:04 +000033#include "llvm/Target/TargetMachine.h"
Devang Patel0e821f42011-04-12 23:21:44 +000034#include "llvm/Target/TargetRegisterInfo.h"
Devang Patel0e821f42011-04-12 23:21:44 +000035
36using namespace llvm;
37
Eric Christopher4287a492013-12-09 23:57:44 +000038static cl::opt<bool>
39GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
40 cl::desc("Generate DWARF4 type units."),
41 cl::init(false));
David Blaikie409dd9c2013-11-19 23:08:21 +000042
David Blaikie2a80e442013-12-02 22:09:48 +000043/// Unit - Unit constructor.
David Blaikie7480ae62014-01-09 03:03:27 +000044DwarfUnit::DwarfUnit(unsigned UID, DIE *D, DICompileUnit Node, AsmPrinter *A,
45 DwarfDebug *DW, DwarfFile *DWU)
David Blaikief645f962014-01-09 03:23:41 +000046 : UniqueID(UID), CUNode(Node), UnitDie(D), DebugInfoOffset(0), Asm(A),
47 DD(DW), DU(DWU), IndexTyDie(0), Section(0), Skeleton(0) {
David Blaikie319a05f2013-12-02 19:33:10 +000048 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
49}
50
Eric Christopher4287a492013-12-09 23:57:44 +000051DwarfCompileUnit::DwarfCompileUnit(unsigned UID, DIE *D, DICompileUnit Node,
52 AsmPrinter *A, DwarfDebug *DW,
53 DwarfFile *DWU)
David Blaikie7480ae62014-01-09 03:03:27 +000054 : DwarfUnit(UID, D, Node, A, DW, DWU) {
David Blaikie5a152402013-11-15 23:52:02 +000055 insertDIE(Node, D);
Devang Patel0e821f42011-04-12 23:21:44 +000056}
57
David Blaikie15632ae2014-02-12 00:31:30 +000058DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DIE *D, DwarfCompileUnit &CU,
Eric Christopher4287a492013-12-09 23:57:44 +000059 AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
Eric Christopher4a741042014-02-16 08:46:55 +000060 : DwarfUnit(UID, D, CU.getCUNode(), A, DW, DWU), CU(CU) {}
David Blaikie409dd9c2013-11-19 23:08:21 +000061
David Blaikie319a05f2013-12-02 19:33:10 +000062/// ~Unit - Destructor for compile unit.
Eric Christophera5a79422013-12-09 23:32:48 +000063DwarfUnit::~DwarfUnit() {
Devang Patel0e821f42011-04-12 23:21:44 +000064 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
65 DIEBlocks[j]->~DIEBlock();
Eric Christopher4a741042014-02-16 08:46:55 +000066 for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
67 DIELocs[j]->~DIELoc();
Devang Patel0e821f42011-04-12 23:21:44 +000068}
69
70/// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
71/// information entry.
Eric Christophera5a79422013-12-09 23:32:48 +000072DIEEntry *DwarfUnit::createDIEEntry(DIE *Entry) {
Devang Patel0e821f42011-04-12 23:21:44 +000073 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
74 return Value;
75}
76
Bill Wendling3495f9b2012-12-06 07:55:19 +000077/// getDefaultLowerBound - Return the default lower bound for an array. If the
Bill Wendling28fe9e72012-12-06 07:38:10 +000078/// DWARF version doesn't handle the language, return -1.
Eric Christophera5a79422013-12-09 23:32:48 +000079int64_t DwarfUnit::getDefaultLowerBound() const {
David Blaikiecb8e4352013-11-15 23:50:53 +000080 switch (getLanguage()) {
Bill Wendling28fe9e72012-12-06 07:38:10 +000081 default:
82 break;
83
84 case dwarf::DW_LANG_C89:
85 case dwarf::DW_LANG_C99:
86 case dwarf::DW_LANG_C:
87 case dwarf::DW_LANG_C_plus_plus:
88 case dwarf::DW_LANG_ObjC:
89 case dwarf::DW_LANG_ObjC_plus_plus:
90 return 0;
91
92 case dwarf::DW_LANG_Fortran77:
93 case dwarf::DW_LANG_Fortran90:
94 case dwarf::DW_LANG_Fortran95:
95 return 1;
96
97 // The languages below have valid values only if the DWARF version >= 4.
98 case dwarf::DW_LANG_Java:
99 case dwarf::DW_LANG_Python:
100 case dwarf::DW_LANG_UPC:
101 case dwarf::DW_LANG_D:
102 if (dwarf::DWARF_VERSION >= 4)
103 return 0;
104 break;
105
106 case dwarf::DW_LANG_Ada83:
107 case dwarf::DW_LANG_Ada95:
108 case dwarf::DW_LANG_Cobol74:
109 case dwarf::DW_LANG_Cobol85:
110 case dwarf::DW_LANG_Modula2:
111 case dwarf::DW_LANG_Pascal83:
112 case dwarf::DW_LANG_PLI:
113 if (dwarf::DWARF_VERSION >= 4)
114 return 1;
115 break;
116 }
117
118 return -1;
119}
120
Manman Ren4dbdc902013-10-31 17:54:35 +0000121/// Check whether the DIE for this MDNode can be shared across CUs.
David Blaikie4201ddf2013-11-15 22:59:36 +0000122static bool isShareableAcrossCUs(DIDescriptor D) {
David Blaikiebcb418e2013-11-20 18:40:16 +0000123 // When the MDNode can be part of the type system, the DIE can be shared
124 // across CUs.
125 // Combining type units and cross-CU DIE sharing is lower value (since
126 // cross-CU DIE sharing is used in LTO and removes type redundancy at that
127 // level already) but may be implementable for some value in projects
128 // building multiple independent libraries with LTO and then linking those
129 // together.
David Blaikie409dd9c2013-11-19 23:08:21 +0000130 return (D.isType() ||
131 (D.isSubprogram() && !DISubprogram(D).isDefinition())) &&
Eric Christopher4287a492013-12-09 23:57:44 +0000132 !GenerateDwarfTypeUnits;
Manman Ren4dbdc902013-10-31 17:54:35 +0000133}
134
135/// getDIE - Returns the debug information entry map slot for the
136/// specified debug variable. We delegate the request to DwarfDebug
137/// when the DIE for this MDNode can be shared across CUs. The mappings
138/// will be kept in DwarfDebug for shareable DIEs.
Eric Christophera5a79422013-12-09 23:32:48 +0000139DIE *DwarfUnit::getDIE(DIDescriptor D) const {
David Blaikie2ad00162013-11-15 23:09:13 +0000140 if (isShareableAcrossCUs(D))
141 return DD->getDIE(D);
142 return MDNodeToDieMap.lookup(D);
Manman Ren4dbdc902013-10-31 17:54:35 +0000143}
144
145/// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
146/// when the DIE for this MDNode can be shared across CUs. The mappings
147/// will be kept in DwarfDebug for shareable DIEs.
Eric Christophera5a79422013-12-09 23:32:48 +0000148void DwarfUnit::insertDIE(DIDescriptor Desc, DIE *D) {
David Blaikie2ad00162013-11-15 23:09:13 +0000149 if (isShareableAcrossCUs(Desc)) {
150 DD->insertDIE(Desc, D);
Manman Ren4dbdc902013-10-31 17:54:35 +0000151 return;
152 }
David Blaikie2ad00162013-11-15 23:09:13 +0000153 MDNodeToDieMap.insert(std::make_pair(Desc, D));
Manman Ren4dbdc902013-10-31 17:54:35 +0000154}
155
Eric Christopherbb69a272012-08-24 01:14:27 +0000156/// addFlag - Add a flag that is true.
Eric Christophera5a79422013-12-09 23:32:48 +0000157void DwarfUnit::addFlag(DIE *Die, dwarf::Attribute Attribute) {
Michael Gottesmanc89466f2013-09-04 04:39:38 +0000158 if (DD->getDwarfVersion() >= 4)
Eric Christopherdccd3282013-10-04 22:40:05 +0000159 Die->addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
Eric Christopherbb69a272012-08-24 01:14:27 +0000160 else
Eric Christopherdccd3282013-10-04 22:40:05 +0000161 Die->addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
Eric Christopherbb69a272012-08-24 01:14:27 +0000162}
163
Devang Patel0e821f42011-04-12 23:21:44 +0000164/// addUInt - Add an unsigned integer attribute data and value.
165///
Eric Christophera5a79422013-12-09 23:32:48 +0000166void DwarfUnit::addUInt(DIE *Die, dwarf::Attribute Attribute,
167 Optional<dwarf::Form> Form, uint64_t Integer) {
Eric Christopherc2697f82013-10-19 01:04:47 +0000168 if (!Form)
169 Form = DIEInteger::BestForm(false, Integer);
170 DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
171 DIEInteger(Integer);
David Blaikief2443192013-10-21 17:28:37 +0000172 Die->addValue(Attribute, *Form, Value);
173}
174
Eric Christopher4a741042014-02-16 08:46:55 +0000175void DwarfUnit::addUInt(DIE *Block, dwarf::Form Form, uint64_t Integer) {
David Blaikief2443192013-10-21 17:28:37 +0000176 addUInt(Block, (dwarf::Attribute)0, Form, Integer);
Devang Patel0e821f42011-04-12 23:21:44 +0000177}
178
179/// addSInt - Add an signed integer attribute data and value.
180///
Eric Christophera5a79422013-12-09 23:32:48 +0000181void DwarfUnit::addSInt(DIE *Die, dwarf::Attribute Attribute,
182 Optional<dwarf::Form> Form, int64_t Integer) {
Eric Christopherc2697f82013-10-19 01:04:47 +0000183 if (!Form)
184 Form = DIEInteger::BestForm(true, Integer);
Devang Patel0e821f42011-04-12 23:21:44 +0000185 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
David Blaikief2443192013-10-21 17:28:37 +0000186 Die->addValue(Attribute, *Form, Value);
187}
188
Eric Christopher4a741042014-02-16 08:46:55 +0000189void DwarfUnit::addSInt(DIELoc *Die, Optional<dwarf::Form> Form,
Eric Christophera5a79422013-12-09 23:32:48 +0000190 int64_t Integer) {
David Blaikief2443192013-10-21 17:28:37 +0000191 addSInt(Die, (dwarf::Attribute)0, Form, Integer);
Devang Patel0e821f42011-04-12 23:21:44 +0000192}
193
Nick Lewyckycc64ae12011-10-28 05:29:47 +0000194/// addString - Add a string attribute data and value. We always emit a
195/// reference to the string pool instead of immediate strings so that DIEs have
Eric Christopherfba22602013-01-07 19:32:45 +0000196/// more predictable sizes. In the case of split dwarf we emit an index
197/// into another table which gets us the static offset into the string
198/// table.
Eric Christophera5a79422013-12-09 23:32:48 +0000199void DwarfUnit::addString(DIE *Die, dwarf::Attribute Attribute,
200 StringRef String) {
Eric Christopher05893f42013-12-30 18:32:31 +0000201
202 if (!DD->useSplitDwarf())
203 return addLocalString(Die, Attribute, String);
204
205 unsigned idx = DU->getStringPoolIndex(String);
206 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
Eric Christopher67646432013-07-26 17:02:41 +0000207 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
Eric Christopher05893f42013-12-30 18:32:31 +0000208 Die->addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Str);
Eric Christopher2cbd5762013-01-07 19:32:41 +0000209}
210
211/// addLocalString - Add a string attribute data and value. This is guaranteed
212/// to be in the local string pool instead of indirected.
Eric Christophera5a79422013-12-09 23:32:48 +0000213void DwarfUnit::addLocalString(DIE *Die, dwarf::Attribute Attribute,
214 StringRef String) {
Eric Christophere698f532012-12-20 21:58:36 +0000215 MCSymbol *Symb = DU->getStringPoolEntry(String);
Nick Lewyckycc64ae12011-10-28 05:29:47 +0000216 DIEValue *Value;
Eric Christopher84588622013-12-28 01:39:17 +0000217 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
Ulrich Weigand396ba8b2013-07-02 18:46:26 +0000218 Value = new (DIEValueAllocator) DIELabel(Symb);
Nick Lewyckycc64ae12011-10-28 05:29:47 +0000219 else {
Eric Christophere698f532012-12-20 21:58:36 +0000220 MCSymbol *StringPool = DU->getStringPoolSym();
Nick Lewyckycc64ae12011-10-28 05:29:47 +0000221 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
Nick Lewyckyd59c0ca2011-10-27 06:44:11 +0000222 }
Eric Christopher05893f42013-12-30 18:32:31 +0000223 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
224 Die->addValue(Attribute, dwarf::DW_FORM_strp, Str);
Devang Patel0e821f42011-04-12 23:21:44 +0000225}
226
Ulrich Weigand396ba8b2013-07-02 18:46:26 +0000227/// addExpr - Add a Dwarf expression attribute data and value.
Devang Patel0e821f42011-04-12 23:21:44 +0000228///
Eric Christopher4a741042014-02-16 08:46:55 +0000229void DwarfUnit::addExpr(DIELoc *Die, dwarf::Form Form, const MCExpr *Expr) {
Ulrich Weigand396ba8b2013-07-02 18:46:26 +0000230 DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr);
David Blaikief2443192013-10-21 17:28:37 +0000231 Die->addValue((dwarf::Attribute)0, Form, Value);
Devang Patel0e821f42011-04-12 23:21:44 +0000232}
233
Eric Christophera27220f2014-03-05 22:41:20 +0000234/// addLocationList - Add a Dwarf loclistptr attribute data and value.
235///
236void DwarfUnit::addLocationList(DIE *Die, dwarf::Attribute Attribute,
237 unsigned Index) {
238 DIEValue *Value = new (DIEValueAllocator) DIELocList(Index);
239 dwarf::Form Form = DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
240 : dwarf::DW_FORM_data4;
241 Die->addValue(Attribute, Form, Value);
242}
243
Ulrich Weigand396ba8b2013-07-02 18:46:26 +0000244/// addLabel - Add a Dwarf label attribute data and value.
245///
Eric Christophera5a79422013-12-09 23:32:48 +0000246void DwarfUnit::addLabel(DIE *Die, dwarf::Attribute Attribute, dwarf::Form Form,
247 const MCSymbol *Label) {
Ulrich Weigand396ba8b2013-07-02 18:46:26 +0000248 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
249 Die->addValue(Attribute, Form, Value);
David Blaikief3cd7c52013-06-28 20:05:04 +0000250}
251
Eric Christopher4a741042014-02-16 08:46:55 +0000252void DwarfUnit::addLabel(DIELoc *Die, dwarf::Form Form, const MCSymbol *Label) {
David Blaikief2443192013-10-21 17:28:37 +0000253 addLabel(Die, (dwarf::Attribute)0, Form, Label);
254}
255
Eric Christopher33ff6972013-11-21 23:46:41 +0000256/// addSectionLabel - Add a Dwarf section label attribute data and value.
257///
Eric Christophera5a79422013-12-09 23:32:48 +0000258void DwarfUnit::addSectionLabel(DIE *Die, dwarf::Attribute Attribute,
259 const MCSymbol *Label) {
Eric Christopher33ff6972013-11-21 23:46:41 +0000260 if (DD->getDwarfVersion() >= 4)
261 addLabel(Die, Attribute, dwarf::DW_FORM_sec_offset, Label);
262 else
263 addLabel(Die, Attribute, dwarf::DW_FORM_data4, Label);
264}
265
266/// addSectionOffset - Add an offset into a section attribute data and value.
267///
Eric Christophera5a79422013-12-09 23:32:48 +0000268void DwarfUnit::addSectionOffset(DIE *Die, dwarf::Attribute Attribute,
269 uint64_t Integer) {
Eric Christopher33ff6972013-11-21 23:46:41 +0000270 if (DD->getDwarfVersion() >= 4)
271 addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
272 else
273 addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
274}
275
Eric Christopher962c9082013-01-15 23:56:56 +0000276/// addLabelAddress - Add a dwarf label attribute data and value using
277/// DW_FORM_addr or DW_FORM_GNU_addr_index.
278///
Eric Christopher4287a492013-12-09 23:57:44 +0000279void DwarfCompileUnit::addLabelAddress(DIE *Die, dwarf::Attribute Attribute,
280 MCSymbol *Label) {
Alexey Samsonov4436bf02013-10-03 08:54:43 +0000281 if (Label)
282 DD->addArangeLabel(SymbolCU(this, Label));
Richard Mitton21101b32013-09-19 23:21:01 +0000283
Eric Christophercf48ade2014-01-24 11:52:53 +0000284 if (!DD->useSplitDwarf()) {
285 if (Label) {
286 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
287 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
288 } else {
289 DIEValue *Value = new (DIEValueAllocator) DIEInteger(0);
290 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
291 }
Eric Christopher962c9082013-01-15 23:56:56 +0000292 } else {
Eric Christophercf48ade2014-01-24 11:52:53 +0000293 unsigned idx = DU->getAddrPoolIndex(Label);
294 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
295 Die->addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value);
Eric Christopher962c9082013-01-15 23:56:56 +0000296 }
297}
298
Eric Christophere9ec2452013-01-18 22:11:33 +0000299/// addOpAddress - Add a dwarf op address data and value using the
300/// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
301///
Eric Christopher4a741042014-02-16 08:46:55 +0000302void DwarfUnit::addOpAddress(DIELoc *Die, const MCSymbol *Sym) {
Eric Christophere9ec2452013-01-18 22:11:33 +0000303 if (!DD->useSplitDwarf()) {
David Blaikief2443192013-10-21 17:28:37 +0000304 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
305 addLabel(Die, dwarf::DW_FORM_udata, Sym);
Eric Christophere9ec2452013-01-18 22:11:33 +0000306 } else {
David Blaikief2443192013-10-21 17:28:37 +0000307 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
308 addUInt(Die, dwarf::DW_FORM_GNU_addr_index, DU->getAddrPoolIndex(Sym));
Eric Christophere9ec2452013-01-18 22:11:33 +0000309 }
310}
311
Eric Christopher33ff6972013-11-21 23:46:41 +0000312/// addSectionDelta - Add a section label delta attribute data and value.
Devang Patel0e821f42011-04-12 23:21:44 +0000313///
Eric Christophera5a79422013-12-09 23:32:48 +0000314void DwarfUnit::addSectionDelta(DIE *Die, dwarf::Attribute Attribute,
315 const MCSymbol *Hi, const MCSymbol *Lo) {
Devang Patel0e821f42011-04-12 23:21:44 +0000316 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
Eric Christopher33ff6972013-11-21 23:46:41 +0000317 if (DD->getDwarfVersion() >= 4)
318 Die->addValue(Attribute, dwarf::DW_FORM_sec_offset, Value);
319 else
320 Die->addValue(Attribute, dwarf::DW_FORM_data4, Value);
Devang Patel0e821f42011-04-12 23:21:44 +0000321}
322
David Blaikie48b1bdc2014-03-07 01:30:55 +0000323void DwarfUnit::addLabelDelta(DIE *Die, dwarf::Attribute Attribute,
324 const MCSymbol *Hi, const MCSymbol *Lo) {
325 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
326 Die->addValue(Attribute, dwarf::DW_FORM_data4, Value);
327}
328
Devang Patel0e821f42011-04-12 23:21:44 +0000329/// addDIEEntry - Add a DIE attribute data and value.
330///
Eric Christophera5a79422013-12-09 23:32:48 +0000331void DwarfUnit::addDIEEntry(DIE *Die, dwarf::Attribute Attribute, DIE *Entry) {
Manman Ren4dbdc902013-10-31 17:54:35 +0000332 addDIEEntry(Die, Attribute, createDIEEntry(Entry));
333}
334
David Blaikie47f615e2013-12-17 23:32:35 +0000335void DwarfUnit::addDIETypeSignature(DIE *Die, const DwarfTypeUnit &Type) {
336 Die->addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
337 new (DIEValueAllocator) DIETypeSignature(Type));
338}
339
Eric Christophera5a79422013-12-09 23:32:48 +0000340void DwarfUnit::addDIEEntry(DIE *Die, dwarf::Attribute Attribute,
341 DIEEntry *Entry) {
David Blaikie409dd9c2013-11-19 23:08:21 +0000342 const DIE *DieCU = Die->getUnitOrNull();
343 const DIE *EntryCU = Entry->getEntry()->getUnitOrNull();
Manman Ren4dbdc902013-10-31 17:54:35 +0000344 if (!DieCU)
345 // We assume that Die belongs to this CU, if it is not linked to any CU yet.
David Blaikie2a80e442013-12-02 22:09:48 +0000346 DieCU = getUnitDie();
Manman Ren4dbdc902013-10-31 17:54:35 +0000347 if (!EntryCU)
David Blaikie2a80e442013-12-02 22:09:48 +0000348 EntryCU = getUnitDie();
Manman Ren4dbdc902013-10-31 17:54:35 +0000349 Die->addValue(Attribute, EntryCU == DieCU ? dwarf::DW_FORM_ref4
350 : dwarf::DW_FORM_ref_addr,
351 Entry);
Devang Patel0e821f42011-04-12 23:21:44 +0000352}
353
Manman Renb987e512013-10-29 00:53:03 +0000354/// Create a DIE with the given Tag, add the DIE to its parent, and
355/// call insertDIE if MD is not null.
Eric Christophera5a79422013-12-09 23:32:48 +0000356DIE *DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) {
Manman Renb987e512013-10-29 00:53:03 +0000357 DIE *Die = new DIE(Tag);
358 Parent.addChild(Die);
David Blaikie52c50202013-11-16 00:29:01 +0000359 if (N)
360 insertDIE(N, Die);
Manman Renb987e512013-10-29 00:53:03 +0000361 return Die;
362}
363
Devang Patel0e821f42011-04-12 23:21:44 +0000364/// addBlock - Add block data.
365///
Eric Christopher4a741042014-02-16 08:46:55 +0000366void DwarfUnit::addBlock(DIE *Die, dwarf::Attribute Attribute, DIELoc *Loc) {
Eric Christopher8bdab432014-02-27 18:36:10 +0000367 Loc->ComputeSize(Asm);
Eric Christopher4a741042014-02-16 08:46:55 +0000368 DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
369 Die->addValue(Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
370}
371
Eric Christophera5a79422013-12-09 23:32:48 +0000372void DwarfUnit::addBlock(DIE *Die, dwarf::Attribute Attribute,
373 DIEBlock *Block) {
Eric Christopher8bdab432014-02-27 18:36:10 +0000374 Block->ComputeSize(Asm);
Devang Patel0e821f42011-04-12 23:21:44 +0000375 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
376 Die->addValue(Attribute, Block->BestForm(), Block);
377}
378
379/// addSourceLine - Add location information to specified debug information
380/// entry.
David Blaikie101613e2014-02-12 00:11:25 +0000381void DwarfUnit::addSourceLine(DIE *Die, unsigned Line, StringRef File,
382 StringRef Directory) {
Devang Patel0e821f42011-04-12 23:21:44 +0000383 if (Line == 0)
384 return;
David Blaikie101613e2014-02-12 00:11:25 +0000385
David Blaikie5b858582014-02-12 00:40:47 +0000386 unsigned FileID =
387 DD->getOrCreateSourceID(File, Directory, getCU().getUniqueID());
Devang Patel0e821f42011-04-12 23:21:44 +0000388 assert(FileID && "Invalid file id");
David Blaikief2443192013-10-21 17:28:37 +0000389 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
390 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
Devang Patel0e821f42011-04-12 23:21:44 +0000391}
392
393/// addSourceLine - Add location information to specified debug information
394/// entry.
David Blaikie101613e2014-02-12 00:11:25 +0000395void DwarfUnit::addSourceLine(DIE *Die, DIVariable V) {
396 assert(V.isVariable());
397
Eric Christopher89a575c2014-02-12 22:38:04 +0000398 addSourceLine(Die, V.getLineNumber(), V.getContext().getFilename(),
399 V.getContext().getDirectory());
David Blaikie101613e2014-02-12 00:11:25 +0000400}
401
402/// addSourceLine - Add location information to specified debug information
403/// entry.
Eric Christophera5a79422013-12-09 23:32:48 +0000404void DwarfUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
David Blaikie52019302014-02-11 23:57:03 +0000405 assert(G.isGlobalVariable());
Devang Patel0e821f42011-04-12 23:21:44 +0000406
David Blaikie101613e2014-02-12 00:11:25 +0000407 addSourceLine(Die, G.getLineNumber(), G.getFilename(), G.getDirectory());
Devang Patel0e821f42011-04-12 23:21:44 +0000408}
409
410/// addSourceLine - Add location information to specified debug information
411/// entry.
Eric Christophera5a79422013-12-09 23:32:48 +0000412void DwarfUnit::addSourceLine(DIE *Die, DISubprogram SP) {
David Blaikie52019302014-02-11 23:57:03 +0000413 assert(SP.isSubprogram());
Eric Christopher7734ca22012-03-15 23:55:40 +0000414
David Blaikie101613e2014-02-12 00:11:25 +0000415 addSourceLine(Die, SP.getLineNumber(), SP.getFilename(), SP.getDirectory());
Devang Patel0e821f42011-04-12 23:21:44 +0000416}
417
418/// addSourceLine - Add location information to specified debug information
419/// entry.
Eric Christophera5a79422013-12-09 23:32:48 +0000420void DwarfUnit::addSourceLine(DIE *Die, DIType Ty) {
David Blaikie52019302014-02-11 23:57:03 +0000421 assert(Ty.isType());
Devang Patel0e821f42011-04-12 23:21:44 +0000422
David Blaikie101613e2014-02-12 00:11:25 +0000423 addSourceLine(Die, Ty.getLineNumber(), Ty.getFilename(), Ty.getDirectory());
Devang Patel0e821f42011-04-12 23:21:44 +0000424}
425
426/// addSourceLine - Add location information to specified debug information
427/// entry.
Eric Christophera5a79422013-12-09 23:32:48 +0000428void DwarfUnit::addSourceLine(DIE *Die, DIObjCProperty Ty) {
David Blaikie52019302014-02-11 23:57:03 +0000429 assert(Ty.isObjCProperty());
Eric Christopher70e1bd82012-03-29 08:42:56 +0000430
Eric Christopher70e1bd82012-03-29 08:42:56 +0000431 DIFile File = Ty.getFile();
David Blaikie101613e2014-02-12 00:11:25 +0000432 addSourceLine(Die, Ty.getLineNumber(), File.getFilename(),
433 File.getDirectory());
Eric Christopher70e1bd82012-03-29 08:42:56 +0000434}
435
436/// addSourceLine - Add location information to specified debug information
437/// entry.
Eric Christophera5a79422013-12-09 23:32:48 +0000438void DwarfUnit::addSourceLine(DIE *Die, DINameSpace NS) {
David Blaikie52019302014-02-11 23:57:03 +0000439 assert(NS.Verify());
Devang Patel0e821f42011-04-12 23:21:44 +0000440
David Blaikie101613e2014-02-12 00:11:25 +0000441 addSourceLine(Die, NS.getLineNumber(), NS.getFilename(), NS.getDirectory());
Devang Patel0e821f42011-04-12 23:21:44 +0000442}
443
Eric Christopher92331fd2012-11-21 00:34:38 +0000444/// addVariableAddress - Add DW_AT_location attribute for a
Devang Patel77dc5412011-04-27 22:45:24 +0000445/// DbgVariable based on provided MachineLocation.
Eric Christophera5a79422013-12-09 23:32:48 +0000446void DwarfUnit::addVariableAddress(const DbgVariable &DV, DIE *Die,
447 MachineLocation Location) {
Eric Christopherbf2d23c2013-06-24 21:07:27 +0000448 if (DV.variableHasComplexAddress())
Devang Patel0e821f42011-04-12 23:21:44 +0000449 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
Eric Christopherbf2d23c2013-06-24 21:07:27 +0000450 else if (DV.isBlockByrefVariable())
Devang Patel0e821f42011-04-12 23:21:44 +0000451 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
452 else
David Blaikieea2605d2013-06-20 00:25:24 +0000453 addAddress(Die, dwarf::DW_AT_location, Location,
Eric Christopherbf2d23c2013-06-24 21:07:27 +0000454 DV.getVariable().isIndirect());
Devang Patel0e821f42011-04-12 23:21:44 +0000455}
456
Devang Patelba5fbf12011-04-26 19:06:18 +0000457/// addRegisterOp - Add register operand.
Eric Christopher4a741042014-02-16 08:46:55 +0000458void DwarfUnit::addRegisterOp(DIELoc *TheDie, unsigned Reg) {
Devang Patelba5fbf12011-04-26 19:06:18 +0000459 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
Adrian Prantlcbcd5782014-02-11 22:22:15 +0000460 int DWReg = RI->getDwarfRegNum(Reg, false);
461 bool isSubRegister = DWReg < 0;
462
463 unsigned Idx = 0;
464
465 // Go up the super-register chain until we hit a valid dwarf register number.
466 for (MCSuperRegIterator SR(Reg, RI); SR.isValid() && DWReg < 0; ++SR) {
467 DWReg = RI->getDwarfRegNum(*SR, false);
468 if (DWReg >= 0)
469 Idx = RI->getSubRegIndex(*SR, Reg);
470 }
471
472 if (DWReg < 0) {
Eric Christophera13839f2014-02-26 23:27:16 +0000473 DEBUG(dbgs() << "Invalid Dwarf register number.\n");
Adrian Prantlcbcd5782014-02-11 22:22:15 +0000474 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_nop);
475 return;
476 }
477
478 // Emit register
Devang Patelba5fbf12011-04-26 19:06:18 +0000479 if (DWReg < 32)
David Blaikief2443192013-10-21 17:28:37 +0000480 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
Devang Patelba5fbf12011-04-26 19:06:18 +0000481 else {
David Blaikief2443192013-10-21 17:28:37 +0000482 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
483 addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
Devang Patelba5fbf12011-04-26 19:06:18 +0000484 }
Adrian Prantlcbcd5782014-02-11 22:22:15 +0000485
486 // Emit Mask
487 if (isSubRegister) {
488 unsigned Size = RI->getSubRegIdxSize(Idx);
489 unsigned Offset = RI->getSubRegIdxOffset(Idx);
490 if (Offset > 0) {
491 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bit_piece);
492 addUInt(TheDie, dwarf::DW_FORM_data1, Size);
493 addUInt(TheDie, dwarf::DW_FORM_data1, Offset);
494 } else {
Adrian Prantl7199fd52014-02-12 19:34:44 +0000495 unsigned ByteSize = Size / 8; // Assuming 8 bits per byte.
Adrian Prantlcbcd5782014-02-11 22:22:15 +0000496 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_piece);
Adrian Prantl7199fd52014-02-12 19:34:44 +0000497 addUInt(TheDie, dwarf::DW_FORM_data1, ByteSize);
Adrian Prantlcbcd5782014-02-11 22:22:15 +0000498 }
499 }
Devang Patelba5fbf12011-04-26 19:06:18 +0000500}
501
502/// addRegisterOffset - Add register offset.
Eric Christopher4a741042014-02-16 08:46:55 +0000503void DwarfUnit::addRegisterOffset(DIELoc *TheDie, unsigned Reg,
Eric Christophera5a79422013-12-09 23:32:48 +0000504 int64_t Offset) {
Devang Patelba5fbf12011-04-26 19:06:18 +0000505 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
506 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
507 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
508 if (Reg == TRI->getFrameRegister(*Asm->MF))
509 // If variable offset is based in frame register then use fbreg.
David Blaikief2443192013-10-21 17:28:37 +0000510 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
Devang Patelba5fbf12011-04-26 19:06:18 +0000511 else if (DWReg < 32)
David Blaikief2443192013-10-21 17:28:37 +0000512 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
Devang Patelba5fbf12011-04-26 19:06:18 +0000513 else {
David Blaikief2443192013-10-21 17:28:37 +0000514 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
515 addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
Devang Patelba5fbf12011-04-26 19:06:18 +0000516 }
David Blaikief2443192013-10-21 17:28:37 +0000517 addSInt(TheDie, dwarf::DW_FORM_sdata, Offset);
Devang Patelba5fbf12011-04-26 19:06:18 +0000518}
519
520/// addAddress - Add an address attribute to a die based on the location
521/// provided.
Eric Christophera5a79422013-12-09 23:32:48 +0000522void DwarfUnit::addAddress(DIE *Die, dwarf::Attribute Attribute,
523 const MachineLocation &Location, bool Indirect) {
Eric Christopher4a741042014-02-16 08:46:55 +0000524 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
Devang Patelba5fbf12011-04-26 19:06:18 +0000525
David Blaikieea2605d2013-06-20 00:25:24 +0000526 if (Location.isReg() && !Indirect)
Eric Christopher4a741042014-02-16 08:46:55 +0000527 addRegisterOp(Loc, Location.getReg());
David Blaikieea2605d2013-06-20 00:25:24 +0000528 else {
Eric Christopher4a741042014-02-16 08:46:55 +0000529 addRegisterOffset(Loc, Location.getReg(), Location.getOffset());
David Blaikieea2605d2013-06-20 00:25:24 +0000530 if (Indirect && !Location.isReg()) {
Eric Christopher4a741042014-02-16 08:46:55 +0000531 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
David Blaikieea2605d2013-06-20 00:25:24 +0000532 }
533 }
Devang Patelba5fbf12011-04-26 19:06:18 +0000534
535 // Now attach the location information to the DIE.
Eric Christopher4a741042014-02-16 08:46:55 +0000536 addBlock(Die, Attribute, Loc);
Devang Patelba5fbf12011-04-26 19:06:18 +0000537}
538
Devang Patel0e821f42011-04-12 23:21:44 +0000539/// addComplexAddress - Start with the address based on the location provided,
540/// and generate the DWARF information necessary to find the actual variable
Eric Christopher1c70b672013-12-05 00:13:15 +0000541/// given the extra address information encoded in the DbgVariable, starting
542/// from the starting location. Add the DWARF information to the die.
Devang Patel0e821f42011-04-12 23:21:44 +0000543///
Eric Christophera5a79422013-12-09 23:32:48 +0000544void DwarfUnit::addComplexAddress(const DbgVariable &DV, DIE *Die,
545 dwarf::Attribute Attribute,
546 const MachineLocation &Location) {
Eric Christopher4a741042014-02-16 08:46:55 +0000547 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
Eric Christopherbf2d23c2013-06-24 21:07:27 +0000548 unsigned N = DV.getNumAddrElements();
Devang Patel3e021532011-04-28 02:22:40 +0000549 unsigned i = 0;
550 if (Location.isReg()) {
Eric Christopherbf2d23c2013-06-24 21:07:27 +0000551 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
Devang Patel3e021532011-04-28 02:22:40 +0000552 // If first address element is OpPlus then emit
553 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
Eric Christopher4a741042014-02-16 08:46:55 +0000554 addRegisterOffset(Loc, Location.getReg(), DV.getAddrElement(1));
Devang Patel3e021532011-04-28 02:22:40 +0000555 i = 2;
556 } else
Eric Christopher4a741042014-02-16 08:46:55 +0000557 addRegisterOp(Loc, Location.getReg());
Eric Christopherc2697f82013-10-19 01:04:47 +0000558 } else
Eric Christopher4a741042014-02-16 08:46:55 +0000559 addRegisterOffset(Loc, Location.getReg(), Location.getOffset());
Devang Patel0e821f42011-04-12 23:21:44 +0000560
Eric Christopherc2697f82013-10-19 01:04:47 +0000561 for (; i < N; ++i) {
Eric Christopherbf2d23c2013-06-24 21:07:27 +0000562 uint64_t Element = DV.getAddrElement(i);
Devang Patel0e821f42011-04-12 23:21:44 +0000563 if (Element == DIBuilder::OpPlus) {
Eric Christopher4a741042014-02-16 08:46:55 +0000564 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
565 addUInt(Loc, dwarf::DW_FORM_udata, DV.getAddrElement(++i));
Devang Patel0e821f42011-04-12 23:21:44 +0000566 } else if (Element == DIBuilder::OpDeref) {
Eric Christopher4d250522012-05-08 18:56:00 +0000567 if (!Location.isReg())
Eric Christopher4a741042014-02-16 08:46:55 +0000568 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
Eric Christopherc2697f82013-10-19 01:04:47 +0000569 } else
570 llvm_unreachable("unknown DIBuilder Opcode");
Devang Patel0e821f42011-04-12 23:21:44 +0000571 }
572
573 // Now attach the location information to the DIE.
Eric Christopher4a741042014-02-16 08:46:55 +0000574 addBlock(Die, Attribute, Loc);
Devang Patel0e821f42011-04-12 23:21:44 +0000575}
576
577/* Byref variables, in Blocks, are declared by the programmer as "SomeType
578 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
579 gives the variable VarName either the struct, or a pointer to the struct, as
580 its type. This is necessary for various behind-the-scenes things the
581 compiler needs to do with by-reference variables in Blocks.
582
583 However, as far as the original *programmer* is concerned, the variable
584 should still have type 'SomeType', as originally declared.
585
586 The function getBlockByrefType dives into the __Block_byref_x_VarName
587 struct to find the original type of the variable, which is then assigned to
588 the variable's Debug Information Entry as its real type. So far, so good.
589 However now the debugger will expect the variable VarName to have the type
590 SomeType. So we need the location attribute for the variable to be an
591 expression that explains to the debugger how to navigate through the
592 pointers and struct to find the actual variable of type SomeType.
593
594 The following function does just that. We start by getting
595 the "normal" location for the variable. This will be the location
596 of either the struct __Block_byref_x_VarName or the pointer to the
597 struct __Block_byref_x_VarName.
598
599 The struct will look something like:
600
601 struct __Block_byref_x_VarName {
602 ... <various fields>
603 struct __Block_byref_x_VarName *forwarding;
604 ... <various other fields>
605 SomeType VarName;
606 ... <maybe more fields>
607 };
608
609 If we are given the struct directly (as our starting point) we
610 need to tell the debugger to:
611
612 1). Add the offset of the forwarding field.
613
614 2). Follow that pointer to get the real __Block_byref_x_VarName
615 struct to use (the real one may have been copied onto the heap).
616
617 3). Add the offset for the field VarName, to find the actual variable.
618
619 If we started with a pointer to the struct, then we need to
620 dereference that pointer first, before the other steps.
621 Translating this into DWARF ops, we will need to append the following
622 to the current location description for the variable:
623
624 DW_OP_deref -- optional, if we start with a pointer
625 DW_OP_plus_uconst <forward_fld_offset>
626 DW_OP_deref
627 DW_OP_plus_uconst <varName_fld_offset>
628
629 That is what this function does. */
630
631/// addBlockByrefAddress - Start with the address based on the location
632/// provided, and generate the DWARF information necessary to find the
633/// actual Block variable (navigating the Block struct) based on the
634/// starting location. Add the DWARF information to the die. For
635/// more information, read large comment just above here.
636///
Eric Christophera5a79422013-12-09 23:32:48 +0000637void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE *Die,
638 dwarf::Attribute Attribute,
639 const MachineLocation &Location) {
Eric Christopherbf2d23c2013-06-24 21:07:27 +0000640 DIType Ty = DV.getType();
Devang Patel0e821f42011-04-12 23:21:44 +0000641 DIType TmpTy = Ty;
Eric Christopher31b05762013-08-08 01:41:00 +0000642 uint16_t Tag = Ty.getTag();
Devang Patel0e821f42011-04-12 23:21:44 +0000643 bool isPointer = false;
644
Eric Christopherbf2d23c2013-06-24 21:07:27 +0000645 StringRef varName = DV.getName();
Devang Patel0e821f42011-04-12 23:21:44 +0000646
647 if (Tag == dwarf::DW_TAG_pointer_type) {
David Blaikie4f6bf27a2013-11-18 23:33:32 +0000648 DIDerivedType DTy(Ty);
Manman Ren93b30902013-10-08 18:42:58 +0000649 TmpTy = resolve(DTy.getTypeDerivedFrom());
Devang Patel0e821f42011-04-12 23:21:44 +0000650 isPointer = true;
651 }
652
David Blaikie4f6bf27a2013-11-18 23:33:32 +0000653 DICompositeType blockStruct(TmpTy);
Devang Patel0e821f42011-04-12 23:21:44 +0000654
655 // Find the __forwarding field and the variable field in the __Block_byref
656 // struct.
657 DIArray Fields = blockStruct.getTypeArray();
David Blaikie4f6bf27a2013-11-18 23:33:32 +0000658 DIDerivedType varField;
659 DIDerivedType forwardingField;
Devang Patel0e821f42011-04-12 23:21:44 +0000660
661 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
David Blaikie4f6bf27a2013-11-18 23:33:32 +0000662 DIDerivedType DT(Fields.getElement(i));
Devang Patel0e821f42011-04-12 23:21:44 +0000663 StringRef fieldName = DT.getName();
664 if (fieldName == "__forwarding")
David Blaikie4f6bf27a2013-11-18 23:33:32 +0000665 forwardingField = DT;
Devang Patel0e821f42011-04-12 23:21:44 +0000666 else if (fieldName == varName)
David Blaikie4f6bf27a2013-11-18 23:33:32 +0000667 varField = DT;
Devang Patel0e821f42011-04-12 23:21:44 +0000668 }
669
670 // Get the offsets for the forwarding field and the variable field.
David Blaikie4f6bf27a2013-11-18 23:33:32 +0000671 unsigned forwardingFieldOffset = forwardingField.getOffsetInBits() >> 3;
672 unsigned varFieldOffset = varField.getOffsetInBits() >> 2;
Devang Patel0e821f42011-04-12 23:21:44 +0000673
674 // Decode the original location, and use that as the start of the byref
675 // variable's location.
Eric Christopher4a741042014-02-16 08:46:55 +0000676 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
Devang Patel0e821f42011-04-12 23:21:44 +0000677
Eric Christopheref9d7102012-07-04 02:02:18 +0000678 if (Location.isReg())
Eric Christopher4a741042014-02-16 08:46:55 +0000679 addRegisterOp(Loc, Location.getReg());
Eric Christopheref9d7102012-07-04 02:02:18 +0000680 else
Eric Christopher4a741042014-02-16 08:46:55 +0000681 addRegisterOffset(Loc, Location.getReg(), Location.getOffset());
Devang Patel0e821f42011-04-12 23:21:44 +0000682
683 // If we started with a pointer to the __Block_byref... struct, then
684 // the first thing we need to do is dereference the pointer (DW_OP_deref).
685 if (isPointer)
Eric Christopher4a741042014-02-16 08:46:55 +0000686 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
Devang Patel0e821f42011-04-12 23:21:44 +0000687
688 // Next add the offset for the '__forwarding' field:
689 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
690 // adding the offset if it's 0.
691 if (forwardingFieldOffset > 0) {
Eric Christopher4a741042014-02-16 08:46:55 +0000692 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
693 addUInt(Loc, dwarf::DW_FORM_udata, forwardingFieldOffset);
Devang Patel0e821f42011-04-12 23:21:44 +0000694 }
695
696 // Now dereference the __forwarding field to get to the real __Block_byref
697 // struct: DW_OP_deref.
Eric Christopher4a741042014-02-16 08:46:55 +0000698 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
Devang Patel0e821f42011-04-12 23:21:44 +0000699
700 // Now that we've got the real __Block_byref... struct, add the offset
701 // for the variable's field to get to the location of the actual variable:
702 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
703 if (varFieldOffset > 0) {
Eric Christopher4a741042014-02-16 08:46:55 +0000704 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
705 addUInt(Loc, dwarf::DW_FORM_udata, varFieldOffset);
Devang Patel0e821f42011-04-12 23:21:44 +0000706 }
707
708 // Now attach the location information to the DIE.
Eric Christopher4a741042014-02-16 08:46:55 +0000709 addBlock(Die, Attribute, Loc);
Devang Patel0e821f42011-04-12 23:21:44 +0000710}
711
Devang Patelbcd50a12011-07-20 21:57:04 +0000712/// isTypeSigned - Return true if the type is signed.
Manman Renb3388602013-10-05 01:43:03 +0000713static bool isTypeSigned(DwarfDebug *DD, DIType Ty, int *SizeInBits) {
Devang Patelbcd50a12011-07-20 21:57:04 +0000714 if (Ty.isDerivedType())
Manman Renb3388602013-10-05 01:43:03 +0000715 return isTypeSigned(DD, DD->resolve(DIDerivedType(Ty).getTypeDerivedFrom()),
716 SizeInBits);
Devang Patelbcd50a12011-07-20 21:57:04 +0000717 if (Ty.isBasicType())
Eric Christopherc2697f82013-10-19 01:04:47 +0000718 if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed ||
719 DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
Devang Patelbcd50a12011-07-20 21:57:04 +0000720 *SizeInBits = Ty.getSizeInBits();
721 return true;
722 }
723 return false;
724}
725
Manman Renb3388602013-10-05 01:43:03 +0000726/// Return true if type encoding is unsigned.
727static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
728 DIDerivedType DTy(Ty);
729 if (DTy.isDerivedType())
730 return isUnsignedDIType(DD, DD->resolve(DTy.getTypeDerivedFrom()));
731
732 DIBasicType BTy(Ty);
733 if (BTy.isBasicType()) {
734 unsigned Encoding = BTy.getEncoding();
735 if (Encoding == dwarf::DW_ATE_unsigned ||
736 Encoding == dwarf::DW_ATE_unsigned_char ||
737 Encoding == dwarf::DW_ATE_boolean)
738 return true;
739 }
740 return false;
741}
742
743/// If this type is derived from a base type then return base type size.
Manman Renbda410f2013-10-08 18:46:58 +0000744static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
Manman Renb3388602013-10-05 01:43:03 +0000745 unsigned Tag = Ty.getTag();
746
747 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
748 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
749 Tag != dwarf::DW_TAG_restrict_type)
750 return Ty.getSizeInBits();
751
752 DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
753
Eric Christopher8cc04fc2014-03-12 18:18:05 +0000754 // If this type is not derived from any type or the type is a declaration then
755 // take conservative approach.
756 if (!BaseType.isValid() || BaseType.isForwardDecl())
Manman Renb3388602013-10-05 01:43:03 +0000757 return Ty.getSizeInBits();
758
759 // If this is a derived type, go ahead and get the base type, unless it's a
760 // reference then it's just the size of the field. Pointer types have no need
761 // of this since they're a different type of qualification on the type.
762 if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
763 BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
764 return Ty.getSizeInBits();
765
766 if (BaseType.isDerivedType())
Manman Renbda410f2013-10-08 18:46:58 +0000767 return getBaseTypeSize(DD, DIDerivedType(BaseType));
Manman Renb3388602013-10-05 01:43:03 +0000768
769 return BaseType.getSizeInBits();
770}
771
Devang Patel0e821f42011-04-12 23:21:44 +0000772/// addConstantValue - Add constant value entry in variable DIE.
Eric Christophera5a79422013-12-09 23:32:48 +0000773void DwarfUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
774 DIType Ty) {
David Blaikiea1e813d2013-05-10 21:52:07 +0000775 // FIXME: This is a bit conservative/simple - it emits negative values at
776 // their maximum bit width which is a bit unfortunate (& doesn't prefer
777 // udata/sdata over dataN as suggested by the DWARF spec)
Nick Lewycky654f5ce2011-10-26 22:55:33 +0000778 assert(MO.isImm() && "Invalid machine operand!");
Devang Patelbcd50a12011-07-20 21:57:04 +0000779 int SizeInBits = -1;
Manman Renb3388602013-10-05 01:43:03 +0000780 bool SignedConstant = isTypeSigned(DD, Ty, &SizeInBits);
David Blaikief2443192013-10-21 17:28:37 +0000781 dwarf::Form Form;
Devang Patelf1d04702011-05-27 18:15:52 +0000782
Eric Christopher9d1daa82013-08-27 23:49:04 +0000783 // If we're a signed constant definitely use sdata.
784 if (SignedConstant) {
785 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, MO.getImm());
786 return;
787 }
788
789 // Else use data for now unless it's larger than we can deal with.
790 switch (SizeInBits) {
791 case 8:
792 Form = dwarf::DW_FORM_data1;
793 break;
794 case 16:
795 Form = dwarf::DW_FORM_data2;
796 break;
797 case 32:
798 Form = dwarf::DW_FORM_data4;
799 break;
800 case 64:
801 Form = dwarf::DW_FORM_data8;
802 break;
803 default:
804 Form = dwarf::DW_FORM_udata;
805 addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
806 return;
807 }
808 addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
Devang Patel0e821f42011-04-12 23:21:44 +0000809}
810
811/// addConstantFPValue - Add constant value entry in variable DIE.
Eric Christophera5a79422013-12-09 23:32:48 +0000812void DwarfUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
Eric Christopherc2697f82013-10-19 01:04:47 +0000813 assert(MO.isFPImm() && "Invalid machine operand!");
Devang Patel0e821f42011-04-12 23:21:44 +0000814 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
815 APFloat FPImm = MO.getFPImm()->getValueAPF();
816
817 // Get the raw data form of the floating point.
818 const APInt FltVal = FPImm.bitcastToAPInt();
Eric Christopherc2697f82013-10-19 01:04:47 +0000819 const char *FltPtr = (const char *)FltVal.getRawData();
Devang Patel0e821f42011-04-12 23:21:44 +0000820
821 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
Micah Villmowcdfe20b2012-10-08 16:38:25 +0000822 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
Devang Patel0e821f42011-04-12 23:21:44 +0000823 int Incr = (LittleEndian ? 1 : -1);
824 int Start = (LittleEndian ? 0 : NumBytes - 1);
825 int Stop = (LittleEndian ? NumBytes : -1);
826
827 // Output the constant to DWARF one byte at a time.
828 for (; Start != Stop; Start += Incr)
Eric Christopher98b7f172013-11-11 18:52:36 +0000829 addUInt(Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
Devang Patel0e821f42011-04-12 23:21:44 +0000830
David Blaikief2443192013-10-21 17:28:37 +0000831 addBlock(Die, dwarf::DW_AT_const_value, Block);
Devang Patel0e821f42011-04-12 23:21:44 +0000832}
833
David Blaikiea39a76e2013-01-20 01:18:01 +0000834/// addConstantFPValue - Add constant value entry in variable DIE.
Eric Christophera5a79422013-12-09 23:32:48 +0000835void DwarfUnit::addConstantFPValue(DIE *Die, const ConstantFP *CFP) {
Eric Christopher9d1daa82013-08-27 23:49:04 +0000836 // Pass this down to addConstantValue as an unsigned bag of bits.
837 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
David Blaikiea39a76e2013-01-20 01:18:01 +0000838}
839
Devang Patel0e821f42011-04-12 23:21:44 +0000840/// addConstantValue - Add constant value entry in variable DIE.
Eric Christophera5a79422013-12-09 23:32:48 +0000841void DwarfUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
842 bool Unsigned) {
Eric Christopher78fcf4902013-07-03 01:08:30 +0000843 addConstantValue(Die, CI->getValue(), Unsigned);
David Blaikiea39a76e2013-01-20 01:18:01 +0000844}
845
846// addConstantValue - Add constant value entry in variable DIE.
Eric Christophera5a79422013-12-09 23:32:48 +0000847void DwarfUnit::addConstantValue(DIE *Die, const APInt &Val, bool Unsigned) {
David Blaikiea39a76e2013-01-20 01:18:01 +0000848 unsigned CIBitWidth = Val.getBitWidth();
Devang Patel8816bbc2011-05-28 00:39:18 +0000849 if (CIBitWidth <= 64) {
Eric Christopher9d1daa82013-08-27 23:49:04 +0000850 // If we're a signed constant definitely use sdata.
851 if (!Unsigned) {
852 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
853 Val.getSExtValue());
854 return;
Devang Patel8816bbc2011-05-28 00:39:18 +0000855 }
Eric Christopher9d1daa82013-08-27 23:49:04 +0000856
857 // Else use data for now unless it's larger than we can deal with.
David Blaikief2443192013-10-21 17:28:37 +0000858 dwarf::Form Form;
Eric Christopher9d1daa82013-08-27 23:49:04 +0000859 switch (CIBitWidth) {
860 case 8:
861 Form = dwarf::DW_FORM_data1;
862 break;
863 case 16:
864 Form = dwarf::DW_FORM_data2;
865 break;
866 case 32:
867 Form = dwarf::DW_FORM_data4;
868 break;
869 case 64:
870 Form = dwarf::DW_FORM_data8;
871 break;
872 default:
873 addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
874 Val.getZExtValue());
875 return;
876 }
877 addUInt(Die, dwarf::DW_AT_const_value, Form, Val.getZExtValue());
Eric Christopher78fcf4902013-07-03 01:08:30 +0000878 return;
Devang Patel0e821f42011-04-12 23:21:44 +0000879 }
880
881 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
882
883 // Get the raw data form of the large APInt.
NAKAMURA Takumi29ccdd82011-10-28 14:12:22 +0000884 const uint64_t *Ptr64 = Val.getRawData();
Devang Patel0e821f42011-04-12 23:21:44 +0000885
886 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
Micah Villmowcdfe20b2012-10-08 16:38:25 +0000887 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
Devang Patel0e821f42011-04-12 23:21:44 +0000888
889 // Output the constant to DWARF one byte at a time.
NAKAMURA Takumi29ccdd82011-10-28 14:12:22 +0000890 for (int i = 0; i < NumBytes; i++) {
891 uint8_t c;
892 if (LittleEndian)
893 c = Ptr64[i / 8] >> (8 * (i & 7));
894 else
895 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
David Blaikief2443192013-10-21 17:28:37 +0000896 addUInt(Block, dwarf::DW_FORM_data1, c);
NAKAMURA Takumi29ccdd82011-10-28 14:12:22 +0000897 }
Devang Patel0e821f42011-04-12 23:21:44 +0000898
David Blaikief2443192013-10-21 17:28:37 +0000899 addBlock(Die, dwarf::DW_AT_const_value, Block);
Devang Patel0e821f42011-04-12 23:21:44 +0000900}
901
Eric Christopher25e35092013-04-22 07:47:40 +0000902/// addTemplateParams - Add template parameters into buffer.
Eric Christophera5a79422013-12-09 23:32:48 +0000903void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
Devang Patel0e821f42011-04-12 23:21:44 +0000904 // Add template parameters.
905 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
906 DIDescriptor Element = TParams.getElement(i);
907 if (Element.isTemplateTypeParameter())
Manman Renffc9a712013-10-23 23:05:28 +0000908 constructTemplateTypeParameterDIE(Buffer,
909 DITemplateTypeParameter(Element));
Devang Patel0e821f42011-04-12 23:21:44 +0000910 else if (Element.isTemplateValueParameter())
Manman Renffc9a712013-10-23 23:05:28 +0000911 constructTemplateValueParameterDIE(Buffer,
912 DITemplateValueParameter(Element));
Devang Patel0e821f42011-04-12 23:21:44 +0000913 }
Devang Patel0e821f42011-04-12 23:21:44 +0000914}
Nick Lewycky654f5ce2011-10-26 22:55:33 +0000915
Eric Christopher4d23a4a2013-01-16 01:22:23 +0000916/// getOrCreateContextDIE - Get context owner's DIE.
Eric Christophera5a79422013-12-09 23:32:48 +0000917DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
David Blaikiebd700e42013-11-14 21:24:34 +0000918 if (!Context || Context.isFile())
David Blaikie2a80e442013-12-02 22:09:48 +0000919 return getUnitDie();
Eric Christopher4d23a4a2013-01-16 01:22:23 +0000920 if (Context.isType())
921 return getOrCreateTypeDIE(DIType(Context));
David Blaikie1dbca702013-11-14 19:37:56 +0000922 if (Context.isNameSpace())
Eric Christopher4d23a4a2013-01-16 01:22:23 +0000923 return getOrCreateNameSpace(DINameSpace(Context));
David Blaikie1dbca702013-11-14 19:37:56 +0000924 if (Context.isSubprogram())
Eric Christopher4d23a4a2013-01-16 01:22:23 +0000925 return getOrCreateSubprogramDIE(DISubprogram(Context));
Adrian Prantl7d828bb2013-11-15 21:05:09 +0000926 return getDIE(Context);
Eric Christopher4d23a4a2013-01-16 01:22:23 +0000927}
928
Eric Christophera5a79422013-12-09 23:32:48 +0000929DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
David Blaikie9d861be2013-11-26 00:15:27 +0000930 DIScope Context = resolve(Ty.getContext());
931 DIE *ContextDIE = getOrCreateContextDIE(Context);
David Blaikie409dd9c2013-11-19 23:08:21 +0000932
933 DIE *TyDIE = getDIE(Ty);
934 if (TyDIE)
935 return TyDIE;
936
937 // Create new type.
938 TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
939
David Blaikiefbd29eb2013-11-26 00:35:04 +0000940 constructTypeDIE(*TyDIE, Ty);
David Blaikie409dd9c2013-11-19 23:08:21 +0000941
David Blaikie9d861be2013-11-26 00:15:27 +0000942 updateAcceleratorTables(Context, Ty, TyDIE);
David Blaikie409dd9c2013-11-19 23:08:21 +0000943 return TyDIE;
944}
945
Devang Patel0e821f42011-04-12 23:21:44 +0000946/// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
947/// given DIType.
Eric Christophera5a79422013-12-09 23:32:48 +0000948DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
David Blaikie32887552013-11-14 22:25:02 +0000949 if (!TyNode)
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000950 return NULL;
Manman Renf4c339e2013-10-29 22:49:29 +0000951
David Blaikie32887552013-11-14 22:25:02 +0000952 DIType Ty(TyNode);
953 assert(Ty.isType());
954
Manman Renf4c339e2013-10-29 22:49:29 +0000955 // Construct the context before querying for the existence of the DIE in case
956 // such construction creates the DIE.
David Blaikie9d861be2013-11-26 00:15:27 +0000957 DIScope Context = resolve(Ty.getContext());
958 DIE *ContextDIE = getOrCreateContextDIE(Context);
Adrian Prantl4583f7d2013-11-15 23:21:39 +0000959 assert(ContextDIE);
Manman Renf4c339e2013-10-29 22:49:29 +0000960
Eric Christophere595bae2013-10-04 17:08:38 +0000961 DIE *TyDIE = getDIE(Ty);
Devang Patel0e821f42011-04-12 23:21:44 +0000962 if (TyDIE)
963 return TyDIE;
964
965 // Create new type.
Manman Renf4c339e2013-10-29 22:49:29 +0000966 TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
967
David Blaikiec3d9e9e2014-03-06 01:42:00 +0000968 updateAcceleratorTables(Context, Ty, TyDIE);
969
Devang Patel0e821f42011-04-12 23:21:44 +0000970 if (Ty.isBasicType())
971 constructTypeDIE(*TyDIE, DIBasicType(Ty));
David Blaikie8a263cb2013-11-26 00:22:37 +0000972 else if (Ty.isCompositeType()) {
973 DICompositeType CTy(Ty);
David Blaikiecfb21152014-01-03 18:59:42 +0000974 if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
975 if (MDString *TypeId = CTy.getIdentifier()) {
David Blaikie15632ae2014-02-12 00:31:30 +0000976 DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
Adrian Prantle2da17f2014-03-14 23:08:17 +0000977 // Skip updating the accelerator tables since this is not the full type.
David Blaikiecfb21152014-01-03 18:59:42 +0000978 return TyDIE;
979 }
David Blaikiefbd29eb2013-11-26 00:35:04 +0000980 constructTypeDIE(*TyDIE, CTy);
David Blaikie8a263cb2013-11-26 00:22:37 +0000981 } else {
Devang Patel0e821f42011-04-12 23:21:44 +0000982 assert(Ty.isDerivedType() && "Unknown kind of DIType");
983 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
984 }
David Blaikie2ea848b2013-11-19 22:51:04 +0000985
David Blaikie2ea848b2013-11-19 22:51:04 +0000986 return TyDIE;
987}
988
Eric Christophera5a79422013-12-09 23:32:48 +0000989void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
990 const DIE *TyDIE) {
Eric Christopher21bde872012-01-06 04:35:23 +0000991 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
992 bool IsImplementation = 0;
993 if (Ty.isCompositeType()) {
994 DICompositeType CT(Ty);
Eric Christopher8ea8e4f2012-01-06 23:03:37 +0000995 // A runtime language of 0 actually means C/C++ and that any
996 // non-negative value is some version of Objective-C/C++.
Eric Christopherc2697f82013-10-19 01:04:47 +0000997 IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
Eric Christopher21bde872012-01-06 04:35:23 +0000998 }
Eric Christophercf7289f2013-09-05 18:20:16 +0000999 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
Eric Christopher8ea8e4f2012-01-06 23:03:37 +00001000 addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
David Blaikie9d861be2013-11-26 00:15:27 +00001001
David Blaikieadbea1e2014-03-12 03:34:38 +00001002 if ((!Context || Context.isCompileUnit() || Context.isFile() ||
1003 Context.isNameSpace()) &&
1004 getCUNode().getEmissionKind() != DIBuilder::LineTablesOnly)
David Blaikie9d861be2013-11-26 00:15:27 +00001005 GlobalTypes[getParentContextString(Context) + Ty.getName().str()] = TyDIE;
Eric Christopher21bde872012-01-06 04:35:23 +00001006 }
Devang Patel0e821f42011-04-12 23:21:44 +00001007}
1008
1009/// addType - Add a new type attribute to the specified entity.
Eric Christophera5a79422013-12-09 23:32:48 +00001010void DwarfUnit::addType(DIE *Entity, DIType Ty, dwarf::Attribute Attribute) {
Eric Christopher0df08e22013-08-08 07:40:37 +00001011 assert(Ty && "Trying to add a type that doesn't exist?");
Devang Patel0e821f42011-04-12 23:21:44 +00001012
1013 // Check for pre-existence.
1014 DIEEntry *Entry = getDIEEntry(Ty);
1015 // If it exists then use the existing value.
1016 if (Entry) {
Manman Ren4dbdc902013-10-31 17:54:35 +00001017 addDIEEntry(Entity, Attribute, Entry);
Devang Patel0e821f42011-04-12 23:21:44 +00001018 return;
1019 }
1020
1021 // Construct type.
1022 DIE *Buffer = getOrCreateTypeDIE(Ty);
1023
1024 // Set up proxy.
1025 Entry = createDIEEntry(Buffer);
1026 insertDIEEntry(Ty, Entry);
Manman Ren4dbdc902013-10-31 17:54:35 +00001027 addDIEEntry(Entity, Attribute, Entry);
Devang Patel1cb8ab42011-05-31 23:30:30 +00001028}
1029
Eric Christopher9cd26af2013-09-20 23:22:52 +00001030// Accelerator table mutators - add each name along with its companion
1031// DIE to the proper table while ensuring that the name that we're going
1032// to reference is in the string table. We do this since the names we
1033// add may not only be identical to the names in the DIE.
Eric Christophera5a79422013-12-09 23:32:48 +00001034void DwarfUnit::addAccelName(StringRef Name, const DIE *Die) {
Eric Christopherd0d5bba2014-02-12 22:47:09 +00001035 if (!DD->useDwarfAccelTables())
1036 return;
Eric Christopher9cd26af2013-09-20 23:22:52 +00001037 DU->getStringPoolEntry(Name);
David Blaikie2ea848b2013-11-19 22:51:04 +00001038 std::vector<const DIE *> &DIEs = AccelNames[Name];
Eric Christopher9cd26af2013-09-20 23:22:52 +00001039 DIEs.push_back(Die);
1040}
1041
Eric Christophera5a79422013-12-09 23:32:48 +00001042void DwarfUnit::addAccelObjC(StringRef Name, const DIE *Die) {
Eric Christopherd0d5bba2014-02-12 22:47:09 +00001043 if (!DD->useDwarfAccelTables())
1044 return;
Eric Christopher9cd26af2013-09-20 23:22:52 +00001045 DU->getStringPoolEntry(Name);
David Blaikie2ea848b2013-11-19 22:51:04 +00001046 std::vector<const DIE *> &DIEs = AccelObjC[Name];
Eric Christopher9cd26af2013-09-20 23:22:52 +00001047 DIEs.push_back(Die);
1048}
1049
Eric Christophera5a79422013-12-09 23:32:48 +00001050void DwarfUnit::addAccelNamespace(StringRef Name, const DIE *Die) {
Eric Christopherd0d5bba2014-02-12 22:47:09 +00001051 if (!DD->useDwarfAccelTables())
1052 return;
Eric Christopher9cd26af2013-09-20 23:22:52 +00001053 DU->getStringPoolEntry(Name);
David Blaikie2ea848b2013-11-19 22:51:04 +00001054 std::vector<const DIE *> &DIEs = AccelNamespace[Name];
Eric Christopher9cd26af2013-09-20 23:22:52 +00001055 DIEs.push_back(Die);
1056}
1057
Eric Christophera5a79422013-12-09 23:32:48 +00001058void DwarfUnit::addAccelType(StringRef Name,
1059 std::pair<const DIE *, unsigned> Die) {
Eric Christopherd0d5bba2014-02-12 22:47:09 +00001060 if (!DD->useDwarfAccelTables())
1061 return;
Eric Christopher9cd26af2013-09-20 23:22:52 +00001062 DU->getStringPoolEntry(Name);
David Blaikie2ea848b2013-11-19 22:51:04 +00001063 std::vector<std::pair<const DIE *, unsigned> > &DIEs = AccelTypes[Name];
Eric Christopher9cd26af2013-09-20 23:22:52 +00001064 DIEs.push_back(Die);
1065}
1066
Eric Christopher9c58f312013-09-20 22:20:55 +00001067/// addGlobalName - Add a new global name to the compile unit.
Eric Christophera5a79422013-12-09 23:32:48 +00001068void DwarfUnit::addGlobalName(StringRef Name, DIE *Die, DIScope Context) {
David Blaikieadbea1e2014-03-12 03:34:38 +00001069 if (getCUNode().getEmissionKind() == DIBuilder::LineTablesOnly)
1070 return;
Eric Christopher8dba0d52013-10-19 01:04:42 +00001071 std::string FullName = getParentContextString(Context) + Name.str();
Eric Christopher2c8b7902013-10-17 02:06:06 +00001072 GlobalNames[FullName] = Die;
Eric Christopher9c58f312013-09-20 22:20:55 +00001073}
1074
Eric Christopher2c8b7902013-10-17 02:06:06 +00001075/// getParentContextString - Walks the metadata parent chain in a language
1076/// specific manner (using the compile unit language) and returns
1077/// it as a string. This is done at the metadata level because DIEs may
1078/// not currently have been added to the parent context and walking the
1079/// DIEs looking for names is more expensive than walking the metadata.
Eric Christophera5a79422013-12-09 23:32:48 +00001080std::string DwarfUnit::getParentContextString(DIScope Context) const {
Eric Christopher2c8b7902013-10-17 02:06:06 +00001081 if (!Context)
1082 return "";
1083
1084 // FIXME: Decide whether to implement this for non-C++ languages.
1085 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
1086 return "";
1087
Eric Christopher8dba0d52013-10-19 01:04:42 +00001088 std::string CS;
Eric Christopher2c8b7902013-10-17 02:06:06 +00001089 SmallVector<DIScope, 1> Parents;
1090 while (!Context.isCompileUnit()) {
1091 Parents.push_back(Context);
1092 if (Context.getContext())
1093 Context = resolve(Context.getContext());
1094 else
1095 // Structure, etc types will have a NULL context if they're at the top
1096 // level.
1097 break;
1098 }
1099
1100 // Reverse iterate over our list to go from the outermost construct to the
1101 // innermost.
1102 for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
1103 E = Parents.rend();
1104 I != E; ++I) {
1105 DIScope Ctx = *I;
1106 StringRef Name = Ctx.getName();
Eric Christopher8dba0d52013-10-19 01:04:42 +00001107 if (!Name.empty()) {
Eric Christopher2c8b7902013-10-17 02:06:06 +00001108 CS += Name;
1109 CS += "::";
1110 }
1111 }
1112 return CS;
Devang Patel0e821f42011-04-12 23:21:44 +00001113}
1114
1115/// constructTypeDIE - Construct basic type die from DIBasicType.
Eric Christophera5a79422013-12-09 23:32:48 +00001116void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
Devang Patel0e821f42011-04-12 23:21:44 +00001117 // Get core information.
1118 StringRef Name = BTy.getName();
Devang Patel0e821f42011-04-12 23:21:44 +00001119 // Add name if not anonymous or intermediate type.
1120 if (!Name.empty())
Nick Lewyckyd59c0ca2011-10-27 06:44:11 +00001121 addString(&Buffer, dwarf::DW_AT_name, Name);
Devang Patel04d6d472011-09-14 23:13:28 +00001122
David Blaikiefac56122013-10-04 23:21:16 +00001123 // An unspecified type only has a name attribute.
1124 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
Devang Patel04d6d472011-09-14 23:13:28 +00001125 return;
Devang Patel04d6d472011-09-14 23:13:28 +00001126
Nick Lewycky654f5ce2011-10-26 22:55:33 +00001127 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
Devang Pateld925d1a2012-02-07 23:33:58 +00001128 BTy.getEncoding());
Devang Patel04d6d472011-09-14 23:13:28 +00001129
Devang Patel0e821f42011-04-12 23:21:44 +00001130 uint64_t Size = BTy.getSizeInBits() >> 3;
David Blaikief2443192013-10-21 17:28:37 +00001131 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
Devang Patel0e821f42011-04-12 23:21:44 +00001132}
1133
1134/// constructTypeDIE - Construct derived type die from DIDerivedType.
Eric Christophera5a79422013-12-09 23:32:48 +00001135void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
Devang Patel0e821f42011-04-12 23:21:44 +00001136 // Get core information.
1137 StringRef Name = DTy.getName();
1138 uint64_t Size = DTy.getSizeInBits() >> 3;
David Blaikiefac56122013-10-04 23:21:16 +00001139 uint16_t Tag = Buffer.getTag();
Devang Patel0e821f42011-04-12 23:21:44 +00001140
1141 // Map to main type, void will not have a type.
Manman Ren93b30902013-10-08 18:42:58 +00001142 DIType FromTy = resolve(DTy.getTypeDerivedFrom());
Eric Christopher0df08e22013-08-08 07:40:37 +00001143 if (FromTy)
1144 addType(&Buffer, FromTy);
Devang Patel0e821f42011-04-12 23:21:44 +00001145
1146 // Add name if not anonymous or intermediate type.
1147 if (!Name.empty())
Nick Lewyckyd59c0ca2011-10-27 06:44:11 +00001148 addString(&Buffer, dwarf::DW_AT_name, Name);
Devang Patel0e821f42011-04-12 23:21:44 +00001149
1150 // Add size if non-zero (derived types might be zero-sized.)
Eric Christopher85757902012-02-21 22:25:53 +00001151 if (Size && Tag != dwarf::DW_TAG_pointer_type)
David Blaikief2443192013-10-21 17:28:37 +00001152 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
Devang Patel0e821f42011-04-12 23:21:44 +00001153
David Blaikie5d3249b2013-01-07 05:51:15 +00001154 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
Eric Christopherc2697f82013-10-19 01:04:47 +00001155 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1156 getOrCreateTypeDIE(resolve(DTy.getClassType())));
Devang Patel0e821f42011-04-12 23:21:44 +00001157 // Add source line info if available and TyDesc is not a forward declaration.
1158 if (!DTy.isForwardDecl())
1159 addSourceLine(&Buffer, DTy);
1160}
1161
Adrian Prantl3f49c892014-02-25 19:57:42 +00001162/// constructSubprogramArguments - Construct function argument DIEs.
1163void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DIArray Args) {
Adrian Prantl69140d22014-02-25 22:27:14 +00001164 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1165 DIDescriptor Ty = Args.getElement(i);
1166 if (Ty.isUnspecifiedParameter()) {
1167 assert(i == N-1 && "Unspecified parameter must be the last argument");
1168 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1169 } else {
1170 DIE *Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1171 addType(Arg, DIType(Ty));
1172 if (DIType(Ty).isArtificial())
1173 addFlag(Arg, dwarf::DW_AT_artificial);
Adrian Prantl3f49c892014-02-25 19:57:42 +00001174 }
Adrian Prantl69140d22014-02-25 22:27:14 +00001175 }
Adrian Prantl3f49c892014-02-25 19:57:42 +00001176}
1177
Devang Patel0e821f42011-04-12 23:21:44 +00001178/// constructTypeDIE - Construct type DIE from DICompositeType.
Eric Christophera5a79422013-12-09 23:32:48 +00001179void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
David Blaikie409dd9c2013-11-19 23:08:21 +00001180 // Add name if not anonymous or intermediate type.
Devang Patel0e821f42011-04-12 23:21:44 +00001181 StringRef Name = CTy.getName();
1182
1183 uint64_t Size = CTy.getSizeInBits() >> 3;
David Blaikiefac56122013-10-04 23:21:16 +00001184 uint16_t Tag = Buffer.getTag();
Devang Patel0e821f42011-04-12 23:21:44 +00001185
1186 switch (Tag) {
Devang Patel0e821f42011-04-12 23:21:44 +00001187 case dwarf::DW_TAG_array_type:
Eric Christopherdf9955d2013-11-11 18:52:31 +00001188 constructArrayTypeDIE(Buffer, CTy);
Devang Patel0e821f42011-04-12 23:21:44 +00001189 break;
Eric Christopheraeb105f2013-11-11 18:52:39 +00001190 case dwarf::DW_TAG_enumeration_type:
1191 constructEnumTypeDIE(Buffer, CTy);
1192 break;
Devang Patel0e821f42011-04-12 23:21:44 +00001193 case dwarf::DW_TAG_subroutine_type: {
Eric Christopher0df08e22013-08-08 07:40:37 +00001194 // Add return type. A void return won't have a type.
Devang Patel0e821f42011-04-12 23:21:44 +00001195 DIArray Elements = CTy.getTypeArray();
David Blaikie4f6bf27a2013-11-18 23:33:32 +00001196 DIType RTy(Elements.getElement(0));
Eric Christopher0df08e22013-08-08 07:40:37 +00001197 if (RTy)
David Blaikie4f6bf27a2013-11-18 23:33:32 +00001198 addType(&Buffer, RTy);
Devang Patel0e821f42011-04-12 23:21:44 +00001199
1200 bool isPrototyped = true;
Adrian Prantl3f49c892014-02-25 19:57:42 +00001201 if (Elements.getNumElements() == 2 &&
1202 Elements.getElement(1).isUnspecifiedParameter())
1203 isPrototyped = false;
1204
1205 constructSubprogramArguments(Buffer, Elements);
1206
Eric Christopher5cd2a9d2012-02-22 08:46:21 +00001207 // Add prototype flag if we're dealing with a C language and the
1208 // function has been prototyped.
David Blaikiecb8e4352013-11-15 23:50:53 +00001209 uint16_t Language = getLanguage();
Eric Christopher5cd2a9d2012-02-22 08:46:21 +00001210 if (isPrototyped &&
Eric Christopherc2697f82013-10-19 01:04:47 +00001211 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
Eric Christopherd42b92f2012-05-22 18:45:24 +00001212 Language == dwarf::DW_LANG_ObjC))
Eric Christopherbb69a272012-08-24 01:14:27 +00001213 addFlag(&Buffer, dwarf::DW_AT_prototyped);
Adrian Prantl99c7af22013-12-18 21:48:19 +00001214
1215 if (CTy.isLValueReference())
1216 addFlag(&Buffer, dwarf::DW_AT_reference);
1217
1218 if (CTy.isRValueReference())
1219 addFlag(&Buffer, dwarf::DW_AT_rvalue_reference);
Eric Christopherc2697f82013-10-19 01:04:47 +00001220 } break;
Devang Patel0e821f42011-04-12 23:21:44 +00001221 case dwarf::DW_TAG_structure_type:
1222 case dwarf::DW_TAG_union_type:
1223 case dwarf::DW_TAG_class_type: {
Devang Patel0e821f42011-04-12 23:21:44 +00001224 // Add elements to structure type.
David Blaikiea1ae0e62013-08-01 20:30:22 +00001225 DIArray Elements = CTy.getTypeArray();
1226 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
Devang Patel0e821f42011-04-12 23:21:44 +00001227 DIDescriptor Element = Elements.getElement(i);
1228 DIE *ElemDie = NULL;
Adrian Prantlef129fb2014-01-18 02:12:00 +00001229 if (Element.isSubprogram())
1230 ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
1231 else if (Element.isDerivedType()) {
Eric Christopherd42b92f2012-05-22 18:45:24 +00001232 DIDerivedType DDTy(Element);
1233 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
Manman Renb987e512013-10-29 00:53:03 +00001234 ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
Manman Ren93b30902013-10-08 18:42:58 +00001235 addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
Manman Renb3388602013-10-05 01:43:03 +00001236 dwarf::DW_AT_friend);
Manman Renc6b63922013-10-14 20:33:57 +00001237 } else if (DDTy.isStaticMember()) {
Manman Ren57e6ff72013-10-23 22:57:12 +00001238 getOrCreateStaticMemberDIE(DDTy);
Manman Renc6b63922013-10-14 20:33:57 +00001239 } else {
Manman Ren230ec862013-10-23 23:00:44 +00001240 constructMemberDIE(Buffer, DDTy);
Manman Renc6b63922013-10-14 20:33:57 +00001241 }
Eric Christopher7285c7d2012-03-28 07:34:31 +00001242 } else if (Element.isObjCProperty()) {
Devang Pateld925d1a2012-02-07 23:33:58 +00001243 DIObjCProperty Property(Element);
Manman Renb987e512013-10-29 00:53:03 +00001244 ElemDie = createAndAddDIE(Property.getTag(), Buffer);
Devang Pateld925d1a2012-02-07 23:33:58 +00001245 StringRef PropertyName = Property.getObjCPropertyName();
1246 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
Eric Christopher4c960562014-01-23 19:16:28 +00001247 if (Property.getType())
1248 addType(ElemDie, Property.getType());
Eric Christopherd42b92f2012-05-22 18:45:24 +00001249 addSourceLine(ElemDie, Property);
Devang Pateld925d1a2012-02-07 23:33:58 +00001250 StringRef GetterName = Property.getObjCPropertyGetterName();
1251 if (!GetterName.empty())
1252 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1253 StringRef SetterName = Property.getObjCPropertySetterName();
1254 if (!SetterName.empty())
1255 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1256 unsigned PropertyAttributes = 0;
Devang Patel403e8192012-02-04 01:30:32 +00001257 if (Property.isReadOnlyObjCProperty())
1258 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1259 if (Property.isReadWriteObjCProperty())
1260 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1261 if (Property.isAssignObjCProperty())
1262 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1263 if (Property.isRetainObjCProperty())
1264 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1265 if (Property.isCopyObjCProperty())
1266 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1267 if (Property.isNonAtomicObjCProperty())
1268 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1269 if (PropertyAttributes)
David Blaikief2443192013-10-21 17:28:37 +00001270 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
Eric Christopherc2697f82013-10-19 01:04:47 +00001271 PropertyAttributes);
Devang Patel44882172012-02-06 17:49:43 +00001272
Devang Pateld925d1a2012-02-07 23:33:58 +00001273 DIEEntry *Entry = getDIEEntry(Element);
1274 if (!Entry) {
1275 Entry = createDIEEntry(ElemDie);
1276 insertDIEEntry(Element, Entry);
1277 }
Devang Patel403e8192012-02-04 01:30:32 +00001278 } else
Devang Patel0e821f42011-04-12 23:21:44 +00001279 continue;
Devang Patel0e821f42011-04-12 23:21:44 +00001280 }
1281
1282 if (CTy.isAppleBlockExtension())
Eric Christopherbb69a272012-08-24 01:14:27 +00001283 addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
Devang Patel0e821f42011-04-12 23:21:44 +00001284
Eric Christopher9e429ae2013-10-05 00:27:02 +00001285 DICompositeType ContainingType(resolve(CTy.getContainingType()));
David Blaikie4f6bf27a2013-11-18 23:33:32 +00001286 if (ContainingType)
Manman Ren4c4b69c2013-10-11 23:58:05 +00001287 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
David Blaikie4f6bf27a2013-11-18 23:33:32 +00001288 getOrCreateTypeDIE(ContainingType));
Devang Patel0e821f42011-04-12 23:21:44 +00001289
Devang Patel12419ae2011-05-12 21:29:42 +00001290 if (CTy.isObjcClassComplete())
Eric Christopherbb69a272012-08-24 01:14:27 +00001291 addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
Devang Patel2409e782011-05-12 19:06:16 +00001292
Eric Christopherda011dd2011-12-16 23:42:42 +00001293 // Add template parameters to a class, structure or union types.
1294 // FIXME: The support isn't in the metadata for this yet.
1295 if (Tag == dwarf::DW_TAG_class_type ||
Eric Christopherc2697f82013-10-19 01:04:47 +00001296 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
Devang Patel0e821f42011-04-12 23:21:44 +00001297 addTemplateParams(Buffer, CTy.getTemplateParams());
1298
1299 break;
1300 }
1301 default:
1302 break;
1303 }
1304
1305 // Add name if not anonymous or intermediate type.
1306 if (!Name.empty())
Nick Lewyckyd59c0ca2011-10-27 06:44:11 +00001307 addString(&Buffer, dwarf::DW_AT_name, Name);
Devang Patel0e821f42011-04-12 23:21:44 +00001308
Eric Christopher775cbd22012-05-22 18:45:18 +00001309 if (Tag == dwarf::DW_TAG_enumeration_type ||
Eric Christopherc2697f82013-10-19 01:04:47 +00001310 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
Eric Christopher775cbd22012-05-22 18:45:18 +00001311 Tag == dwarf::DW_TAG_union_type) {
Devang Patel0e821f42011-04-12 23:21:44 +00001312 // Add size if non-zero (derived types might be zero-sized.)
Eric Christopher1cf33382012-06-01 00:22:32 +00001313 // TODO: Do we care about size for enum forward declarations?
Devang Patel0e821f42011-04-12 23:21:44 +00001314 if (Size)
David Blaikief2443192013-10-21 17:28:37 +00001315 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
Eric Christopher1cf33382012-06-01 00:22:32 +00001316 else if (!CTy.isForwardDecl())
Devang Patel0e821f42011-04-12 23:21:44 +00001317 // Add zero size if it is not a forward declaration.
David Blaikief2443192013-10-21 17:28:37 +00001318 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, 0);
Eric Christopher1cf33382012-06-01 00:22:32 +00001319
1320 // If we're a forward decl, say so.
1321 if (CTy.isForwardDecl())
Eric Christopherbb69a272012-08-24 01:14:27 +00001322 addFlag(&Buffer, dwarf::DW_AT_declaration);
Devang Patel0e821f42011-04-12 23:21:44 +00001323
1324 // Add source line info if available.
1325 if (!CTy.isForwardDecl())
1326 addSourceLine(&Buffer, CTy);
Eric Christopher54cf8ff2012-03-07 00:15:19 +00001327
1328 // No harm in adding the runtime language to the declaration.
1329 unsigned RLang = CTy.getRunTimeLang();
1330 if (RLang)
Eric Christopherc2697f82013-10-19 01:04:47 +00001331 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1332 RLang);
Devang Patel0e821f42011-04-12 23:21:44 +00001333 }
1334}
1335
Manman Renffc9a712013-10-23 23:05:28 +00001336/// constructTemplateTypeParameterDIE - Construct new DIE for the given
1337/// DITemplateTypeParameter.
Eric Christophera5a79422013-12-09 23:32:48 +00001338void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1339 DITemplateTypeParameter TP) {
Manman Renb987e512013-10-29 00:53:03 +00001340 DIE *ParamDIE =
1341 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
Eric Christopher056b6472013-08-08 08:09:43 +00001342 // Add the type if it exists, it could be void and therefore no type.
1343 if (TP.getType())
Manman Ren88b0f942013-10-09 19:46:28 +00001344 addType(ParamDIE, resolve(TP.getType()));
David Blaikie2b380232013-06-22 18:59:11 +00001345 if (!TP.getName().empty())
1346 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
Devang Patel0e821f42011-04-12 23:21:44 +00001347}
1348
Manman Renffc9a712013-10-23 23:05:28 +00001349/// constructTemplateValueParameterDIE - Construct new DIE for the given
1350/// DITemplateValueParameter.
Eric Christophera5a79422013-12-09 23:32:48 +00001351void
1352DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
David Blaikie319a05f2013-12-02 19:33:10 +00001353 DITemplateValueParameter VP) {
Manman Renb987e512013-10-29 00:53:03 +00001354 DIE *ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
Eric Christopher0df08e22013-08-08 07:40:37 +00001355
1356 // Add the type if there is one, template template and template parameter
1357 // packs will not have a type.
Eric Christopher691281b2013-10-21 17:48:51 +00001358 if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
Manman Ren88b0f942013-10-09 19:46:28 +00001359 addType(ParamDIE, resolve(VP.getType()));
Eric Christopherafb2c412013-08-08 07:40:31 +00001360 if (!VP.getName().empty())
1361 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1362 if (Value *Val = VP.getValue()) {
David Blaikiea1e813d2013-05-10 21:52:07 +00001363 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
Manman Ren88b0f942013-10-09 19:46:28 +00001364 addConstantValue(ParamDIE, CI,
1365 isUnsignedDIType(DD, resolve(VP.getType())));
David Blaikiea1e813d2013-05-10 21:52:07 +00001366 else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1367 // For declaration non-type template parameters (such as global values and
1368 // functions)
Eric Christopher4a741042014-02-16 08:46:55 +00001369 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1370 addOpAddress(Loc, Asm->getSymbol(GV));
David Blaikiea1e813d2013-05-10 21:52:07 +00001371 // Emit DW_OP_stack_value to use the address as the immediate value of the
1372 // parameter, rather than a pointer to it.
Eric Christopher4a741042014-02-16 08:46:55 +00001373 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1374 addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
Eric Christopherafb2c412013-08-08 07:40:31 +00001375 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
David Blaikie2b380232013-06-22 18:59:11 +00001376 assert(isa<MDString>(Val));
1377 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1378 cast<MDString>(Val)->getString());
Eric Christopherafb2c412013-08-08 07:40:31 +00001379 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
David Blaikie2b380232013-06-22 18:59:11 +00001380 assert(isa<MDNode>(Val));
1381 DIArray A(cast<MDNode>(Val));
1382 addTemplateParams(*ParamDIE, A);
David Blaikiea1e813d2013-05-10 21:52:07 +00001383 }
1384 }
Devang Patel0e821f42011-04-12 23:21:44 +00001385}
1386
Devang Patel17b53272011-05-06 16:57:54 +00001387/// getOrCreateNameSpace - Create a DIE for DINameSpace.
Eric Christophera5a79422013-12-09 23:32:48 +00001388DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
Manman Renf6b936b2013-10-29 05:49:41 +00001389 // Construct the context before querying for the existence of the DIE in case
1390 // such construction creates the DIE.
1391 DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
Manman Renf6b936b2013-10-29 05:49:41 +00001392
Devang Patel17b53272011-05-06 16:57:54 +00001393 DIE *NDie = getDIE(NS);
1394 if (NDie)
1395 return NDie;
Manman Renf6b936b2013-10-29 05:49:41 +00001396 NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1397
Eric Christopher4996c702011-11-07 09:24:32 +00001398 if (!NS.getName().empty()) {
Nick Lewyckyd59c0ca2011-10-27 06:44:11 +00001399 addString(NDie, dwarf::DW_AT_name, NS.getName());
Eric Christopher4996c702011-11-07 09:24:32 +00001400 addAccelNamespace(NS.getName(), NDie);
Eric Christopher2c8b7902013-10-17 02:06:06 +00001401 addGlobalName(NS.getName(), NDie, NS.getContext());
Eric Christopher4996c702011-11-07 09:24:32 +00001402 } else
1403 addAccelNamespace("(anonymous namespace)", NDie);
Devang Patel17b53272011-05-06 16:57:54 +00001404 addSourceLine(NDie, NS);
Devang Patel17b53272011-05-06 16:57:54 +00001405 return NDie;
1406}
1407
Adrian Prantld1e6a4e2014-03-14 23:08:25 +00001408/// Unique C++ member function declarations based on their
1409/// context and mangled name.
1410DISubprogram
1411DwarfUnit::getOdrUniqueSubprogram(DIScope Context, DISubprogram SP) const {
1412 if (!hasODR() ||
1413 !Context.isCompositeType() ||
1414 SP.getLinkageName().empty() ||
1415 SP.isDefinition())
1416 return SP;
1417 // Create a key with the UID of the parent class and this SP's name.
1418 Twine Key = SP.getContext().getName() + SP.getLinkageName();
1419 const MDNode *&Entry = DD->getOrCreateOdrMember(Key.str());
1420 if (!Entry)
1421 Entry = &*SP;
1422
1423 return DISubprogram(Entry);
1424}
1425
Devang Patel89543712011-08-15 17:24:54 +00001426/// getOrCreateSubprogramDIE - Create new DIE using SP.
Eric Christophera5a79422013-12-09 23:32:48 +00001427DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
David Blaikie309ffe42013-10-04 01:39:59 +00001428 // Construct the context before querying for the existence of the DIE in case
1429 // such construction creates the DIE (as is the case for member function
1430 // declarations).
Adrian Prantld1e6a4e2014-03-14 23:08:25 +00001431 DIScope Context = resolve(SP.getContext());
1432 DIE *ContextDIE = getOrCreateContextDIE(Context);
1433 // Unique declarations based on the ODR, where applicable.
1434 SP = getOdrUniqueSubprogram(Context, SP);
David Blaikie309ffe42013-10-04 01:39:59 +00001435
Eric Christophere595bae2013-10-04 17:08:38 +00001436 DIE *SPDie = getDIE(SP);
Devang Patel89543712011-08-15 17:24:54 +00001437 if (SPDie)
1438 return SPDie;
1439
Manman Ren73d697c2013-10-29 00:58:04 +00001440 DISubprogram SPDecl = SP.getFunctionDeclaration();
1441 if (SPDecl.isSubprogram())
1442 // Add subprogram definitions to the CU die directly.
David Blaikie2a80e442013-12-02 22:09:48 +00001443 ContextDIE = UnitDie.get();
Peter Collingbourne4d358b52012-05-27 18:36:44 +00001444
1445 // DW_TAG_inlined_subroutine may refer to this DIE.
Manman Ren73d697c2013-10-29 00:58:04 +00001446 SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
Peter Collingbourne4d358b52012-05-27 18:36:44 +00001447
Rafael Espindola79278362011-11-10 22:34:29 +00001448 DIE *DeclDie = NULL;
Manman Renb9512a72013-10-23 22:12:26 +00001449 if (SPDecl.isSubprogram())
Rafael Espindola79278362011-11-10 22:34:29 +00001450 DeclDie = getOrCreateSubprogramDIE(SPDecl);
Rafael Espindola79278362011-11-10 22:34:29 +00001451
Devang Patel89543712011-08-15 17:24:54 +00001452 // Add function template parameters.
1453 addTemplateParams(*SPDie, SP.getTemplateParams());
1454
Devang Patel89543712011-08-15 17:24:54 +00001455 // If this DIE is going to refer declaration info using AT_specification
Eric Christopherf20ff972013-05-09 00:42:33 +00001456 // then there is no need to add other attributes.
Rafael Espindola79278362011-11-10 22:34:29 +00001457 if (DeclDie) {
1458 // Refer function declaration directly.
Manman Ren4c4b69c2013-10-11 23:58:05 +00001459 addDIEEntry(SPDie, dwarf::DW_AT_specification, DeclDie);
Rafael Espindola79278362011-11-10 22:34:29 +00001460
Devang Patel89543712011-08-15 17:24:54 +00001461 return SPDie;
Rafael Espindola79278362011-11-10 22:34:29 +00001462 }
Devang Patel89543712011-08-15 17:24:54 +00001463
Eric Christopheracb71152012-08-23 22:52:55 +00001464 // Add the linkage name if we have one.
Michael Gottesmanc89466f2013-09-04 04:39:38 +00001465 StringRef LinkageName = SP.getLinkageName();
1466 if (!LinkageName.empty())
Eric Christopheracb71152012-08-23 22:52:55 +00001467 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
Benjamin Kramer7c275642013-06-01 17:51:14 +00001468 GlobalValue::getRealLinkageName(LinkageName));
Eric Christopheracb71152012-08-23 22:52:55 +00001469
Devang Patel89543712011-08-15 17:24:54 +00001470 // Constructors and operators for anonymous aggregates do not have names.
1471 if (!SP.getName().empty())
Nick Lewyckyd59c0ca2011-10-27 06:44:11 +00001472 addString(SPDie, dwarf::DW_AT_name, SP.getName());
Devang Patel89543712011-08-15 17:24:54 +00001473
1474 addSourceLine(SPDie, SP);
1475
Eric Christopher5cd2a9d2012-02-22 08:46:21 +00001476 // Add the prototype if we have a prototype and we have a C like
1477 // language.
David Blaikiecb8e4352013-11-15 23:50:53 +00001478 uint16_t Language = getLanguage();
Eric Christopher5cd2a9d2012-02-22 08:46:21 +00001479 if (SP.isPrototyped() &&
Eric Christopherc2697f82013-10-19 01:04:47 +00001480 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
Eric Christopher5cd2a9d2012-02-22 08:46:21 +00001481 Language == dwarf::DW_LANG_ObjC))
Eric Christopherbb69a272012-08-24 01:14:27 +00001482 addFlag(SPDie, dwarf::DW_AT_prototyped);
Devang Patel89543712011-08-15 17:24:54 +00001483
Devang Patel89543712011-08-15 17:24:54 +00001484 DICompositeType SPTy = SP.getType();
David Blaikie5174c842013-05-22 23:22:18 +00001485 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1486 "the type of a subprogram should be a subroutine");
Devang Patel89543712011-08-15 17:24:54 +00001487
David Blaikie5174c842013-05-22 23:22:18 +00001488 DIArray Args = SPTy.getTypeArray();
Eric Christopher691281b2013-10-21 17:48:51 +00001489 // Add a return type. If this is a type like a C/C++ void type we don't add a
1490 // return type.
Eric Christopher0df08e22013-08-08 07:40:37 +00001491 if (Args.getElement(0))
1492 addType(SPDie, DIType(Args.getElement(0)));
Devang Patel89543712011-08-15 17:24:54 +00001493
1494 unsigned VK = SP.getVirtuality();
1495 if (VK) {
Nick Lewyckycfde1a22011-12-14 00:56:07 +00001496 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
Eric Christopher4a741042014-02-16 08:46:55 +00001497 DIELoc *Block = getDIELoc();
David Blaikief2443192013-10-21 17:28:37 +00001498 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1499 addUInt(Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1500 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
Eric Christopher98b7f172013-11-11 18:52:36 +00001501 ContainingTypeMap.insert(
1502 std::make_pair(SPDie, resolve(SP.getContainingType())));
Devang Patel89543712011-08-15 17:24:54 +00001503 }
1504
1505 if (!SP.isDefinition()) {
Eric Christopherbb69a272012-08-24 01:14:27 +00001506 addFlag(SPDie, dwarf::DW_AT_declaration);
Eric Christopher92331fd2012-11-21 00:34:38 +00001507
Devang Patel89543712011-08-15 17:24:54 +00001508 // Add arguments. Do not add arguments for subprogram definition. They will
1509 // be handled while processing variables.
Adrian Prantl3f49c892014-02-25 19:57:42 +00001510 constructSubprogramArguments(*SPDie, Args);
Devang Patel89543712011-08-15 17:24:54 +00001511 }
1512
1513 if (SP.isArtificial())
Eric Christopherbb69a272012-08-24 01:14:27 +00001514 addFlag(SPDie, dwarf::DW_AT_artificial);
Devang Patel89543712011-08-15 17:24:54 +00001515
1516 if (!SP.isLocalToUnit())
Eric Christopherbb69a272012-08-24 01:14:27 +00001517 addFlag(SPDie, dwarf::DW_AT_external);
Devang Patel89543712011-08-15 17:24:54 +00001518
1519 if (SP.isOptimized())
Eric Christopherbb69a272012-08-24 01:14:27 +00001520 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
Devang Patel89543712011-08-15 17:24:54 +00001521
1522 if (unsigned isa = Asm->getISAEncoding()) {
1523 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1524 }
1525
Adrian Prantl99c7af22013-12-18 21:48:19 +00001526 if (SP.isLValueReference())
1527 addFlag(SPDie, dwarf::DW_AT_reference);
1528
1529 if (SP.isRValueReference())
1530 addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1531
Adrian Prantlef129fb2014-01-18 02:12:00 +00001532 if (SP.isProtected())
1533 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1534 dwarf::DW_ACCESS_protected);
1535 else if (SP.isPrivate())
1536 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1537 dwarf::DW_ACCESS_private);
1538 else
1539 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1540 dwarf::DW_ACCESS_public);
1541
1542 if (SP.isExplicit())
1543 addFlag(SPDie, dwarf::DW_AT_explicit);
1544
Devang Patel89543712011-08-15 17:24:54 +00001545 return SPDie;
1546}
1547
Devang Pateldfd6ec32011-08-15 17:57:41 +00001548// Return const expression if value is a GEP to access merged global
1549// constant. e.g.
1550// i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1551static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1552 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1553 if (!CE || CE->getNumOperands() != 3 ||
1554 CE->getOpcode() != Instruction::GetElementPtr)
1555 return NULL;
1556
1557 // First operand points to a global struct.
1558 Value *Ptr = CE->getOperand(0);
1559 if (!isa<GlobalValue>(Ptr) ||
1560 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1561 return NULL;
1562
1563 // Second operand is zero.
1564 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1565 if (!CI || !CI->isZero())
1566 return NULL;
1567
1568 // Third operand is offset.
1569 if (!isa<ConstantInt>(CE->getOperand(2)))
1570 return NULL;
1571
1572 return CE;
1573}
1574
1575/// createGlobalVariableDIE - create global variable DIE.
Eric Christopher4287a492013-12-09 23:57:44 +00001576void DwarfCompileUnit::createGlobalVariableDIE(DIGlobalVariable GV) {
Devang Pateldfd6ec32011-08-15 17:57:41 +00001577 // Check for pre-existence.
David Blaikie2ad00162013-11-15 23:09:13 +00001578 if (getDIE(GV))
Devang Pateldfd6ec32011-08-15 17:57:41 +00001579 return;
1580
David Blaikie5e390e42014-02-04 01:23:52 +00001581 assert(GV.isGlobalVariable());
Devang Patel0ecbcbd2011-08-18 23:17:55 +00001582
Eric Christopher08f7c8f2013-10-04 23:49:26 +00001583 DIScope GVContext = GV.getContext();
Eric Christopher4d23a4a2013-01-16 01:22:23 +00001584 DIType GTy = GV.getType();
1585
1586 // If this is a static data member definition, some attributes belong
1587 // to the declaration DIE.
1588 DIE *VariableDIE = NULL;
Manman Rene697d3c2013-02-01 23:54:37 +00001589 bool IsStaticMember = false;
Eric Christopher4d23a4a2013-01-16 01:22:23 +00001590 DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1591 if (SDMDecl.Verify()) {
1592 assert(SDMDecl.isStaticMember() && "Expected static member decl");
1593 // We need the declaration DIE that is in the static member's class.
Manman Renc6b63922013-10-14 20:33:57 +00001594 VariableDIE = getOrCreateStaticMemberDIE(SDMDecl);
Manman Rene697d3c2013-02-01 23:54:37 +00001595 IsStaticMember = true;
Eric Christopher4d23a4a2013-01-16 01:22:23 +00001596 }
1597
1598 // If this is not a static data member definition, create the variable
1599 // DIE and add the initial set of attributes to it.
1600 if (!VariableDIE) {
Manman Renf6b936b2013-10-29 05:49:41 +00001601 // Construct the context before querying for the existence of the DIE in
1602 // case such construction creates the DIE.
1603 DIE *ContextDIE = getOrCreateContextDIE(GVContext);
Manman Renf6b936b2013-10-29 05:49:41 +00001604
Eric Christopher4d23a4a2013-01-16 01:22:23 +00001605 // Add to map.
David Blaikie52c50202013-11-16 00:29:01 +00001606 VariableDIE = createAndAddDIE(GV.getTag(), *ContextDIE, GV);
Eric Christopher4d23a4a2013-01-16 01:22:23 +00001607
1608 // Add name and type.
1609 addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1610 addType(VariableDIE, GTy);
1611
1612 // Add scoping info.
Eric Christopherd2b497b2013-10-16 01:37:49 +00001613 if (!GV.isLocalToUnit())
Eric Christopher4d23a4a2013-01-16 01:22:23 +00001614 addFlag(VariableDIE, dwarf::DW_AT_external);
1615
1616 // Add line number info.
1617 addSourceLine(VariableDIE, GV);
Eric Christopher4d23a4a2013-01-16 01:22:23 +00001618 }
1619
Devang Pateldfd6ec32011-08-15 17:57:41 +00001620 // Add location.
Eric Christopher4996c702011-11-07 09:24:32 +00001621 bool addToAccelTable = false;
Eric Christopher0a917b72011-11-11 03:16:32 +00001622 DIE *VariableSpecDIE = NULL;
Eric Christopher4d23a4a2013-01-16 01:22:23 +00001623 bool isGlobalVariable = GV.getGlobal() != NULL;
Devang Pateldfd6ec32011-08-15 17:57:41 +00001624 if (isGlobalVariable) {
Eric Christopher4996c702011-11-07 09:24:32 +00001625 addToAccelTable = true;
Eric Christopher4a741042014-02-16 08:46:55 +00001626 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
Rafael Espindola79858aa2013-10-29 17:07:16 +00001627 const MCSymbol *Sym = Asm->getSymbol(GV.getGlobal());
David Blaikief2694972013-06-28 20:05:11 +00001628 if (GV.getGlobal()->isThreadLocal()) {
1629 // FIXME: Make this work with -gsplit-dwarf.
1630 unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1631 assert((PointerSize == 4 || PointerSize == 8) &&
1632 "Add support for other sizes if necessary");
1633 // Based on GCC's support for TLS:
David Blaikie8466ca82013-07-01 23:55:52 +00001634 if (!DD->useSplitDwarf()) {
1635 // 1) Start with a constNu of the appropriate pointer size
Eric Christopher4a741042014-02-16 08:46:55 +00001636 addUInt(Loc, dwarf::DW_FORM_data1,
David Blaikie8466ca82013-07-01 23:55:52 +00001637 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
Richard Mitton0aafb582013-10-07 18:39:18 +00001638 // 2) containing the (relocated) offset of the TLS variable
1639 // within the module's TLS block.
Eric Christopher4a741042014-02-16 08:46:55 +00001640 addExpr(Loc, dwarf::DW_FORM_udata,
David Blaikief1a6dea2014-02-15 19:34:03 +00001641 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym));
David Blaikie8466ca82013-07-01 23:55:52 +00001642 } else {
Eric Christopher4a741042014-02-16 08:46:55 +00001643 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1644 addUInt(Loc, dwarf::DW_FORM_udata,
David Blaikief1a6dea2014-02-15 19:34:03 +00001645 DU->getAddrPoolIndex(Sym, /* TLS */ true));
David Blaikie8466ca82013-07-01 23:55:52 +00001646 }
Richard Mitton0aafb582013-10-07 18:39:18 +00001647 // 3) followed by a custom OP to make the debugger do a TLS lookup.
Eric Christopher4a741042014-02-16 08:46:55 +00001648 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_push_tls_address);
David Blaikiebc7e0d42013-11-27 23:53:52 +00001649 } else {
1650 DD->addArangeLabel(SymbolCU(this, Sym));
Eric Christopher4a741042014-02-16 08:46:55 +00001651 addOpAddress(Loc, Sym);
David Blaikiebc7e0d42013-11-27 23:53:52 +00001652 }
Devang Pateldfd6ec32011-08-15 17:57:41 +00001653 // Do not create specification DIE if context is either compile unit
1654 // or a subprogram.
Devang Patel5e6b65c2011-09-21 23:41:11 +00001655 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
Manman Ren3eb9dff2013-09-09 19:05:21 +00001656 !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
Devang Pateldfd6ec32011-08-15 17:57:41 +00001657 // Create specification DIE.
David Blaikie2a80e442013-12-02 22:09:48 +00001658 VariableSpecDIE = createAndAddDIE(dwarf::DW_TAG_variable, *UnitDie);
Manman Ren4c4b69c2013-10-11 23:58:05 +00001659 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, VariableDIE);
Eric Christopher4a741042014-02-16 08:46:55 +00001660 addBlock(VariableSpecDIE, dwarf::DW_AT_location, Loc);
Eric Christopher4d23a4a2013-01-16 01:22:23 +00001661 // A static member's declaration is already flagged as such.
1662 if (!SDMDecl.Verify())
1663 addFlag(VariableDIE, dwarf::DW_AT_declaration);
Devang Pateldfd6ec32011-08-15 17:57:41 +00001664 } else {
Eric Christopher4a741042014-02-16 08:46:55 +00001665 addBlock(VariableDIE, dwarf::DW_AT_location, Loc);
Eric Christopher4996c702011-11-07 09:24:32 +00001666 }
Michael Gottesmanc89466f2013-09-04 04:39:38 +00001667 // Add the linkage name.
Eric Christopher4d23a4a2013-01-16 01:22:23 +00001668 StringRef LinkageName = GV.getLinkageName();
Michael Gottesmanc89466f2013-09-04 04:39:38 +00001669 if (!LinkageName.empty())
Eric Christopher3f79b8c2013-02-27 23:49:47 +00001670 // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1671 // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1672 // TAG_variable.
Eric Christopherc2697f82013-10-19 01:04:47 +00001673 addString(IsStaticMember && VariableSpecDIE ? VariableSpecDIE
1674 : VariableDIE,
Eric Christopheraf7eca22014-03-13 23:26:25 +00001675 DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
1676 : dwarf::DW_AT_MIPS_linkage_name,
Benjamin Kramer7c275642013-06-01 17:51:14 +00001677 GlobalValue::getRealLinkageName(LinkageName));
Eric Christopher92331fd2012-11-21 00:34:38 +00001678 } else if (const ConstantInt *CI =
Eric Christopherc2697f82013-10-19 01:04:47 +00001679 dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
Adrian Prantl322f41d2013-04-04 22:56:49 +00001680 // AT_const_value was added when the static member was created. To avoid
Manman Rene697d3c2013-02-01 23:54:37 +00001681 // emitting AT_const_value multiple times, we only add AT_const_value when
1682 // it is not a static member.
1683 if (!IsStaticMember)
Manman Renb3388602013-10-05 01:43:03 +00001684 addConstantValue(VariableDIE, CI, isUnsignedDIType(DD, GTy));
David Blaikiea781b25b2013-11-17 21:55:13 +00001685 } else if (const ConstantExpr *CE = getMergedGlobalExpr(GV->getOperand(11))) {
Eric Christopher4996c702011-11-07 09:24:32 +00001686 addToAccelTable = true;
Devang Pateldfd6ec32011-08-15 17:57:41 +00001687 // GV is a merged global.
Eric Christopher4a741042014-02-16 08:46:55 +00001688 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
Devang Pateldfd6ec32011-08-15 17:57:41 +00001689 Value *Ptr = CE->getOperand(0);
David Blaikiebc7e0d42013-11-27 23:53:52 +00001690 MCSymbol *Sym = Asm->getSymbol(cast<GlobalValue>(Ptr));
1691 DD->addArangeLabel(SymbolCU(this, Sym));
Eric Christopher4a741042014-02-16 08:46:55 +00001692 addOpAddress(Loc, Sym);
1693 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
Eric Christopherc2697f82013-10-19 01:04:47 +00001694 SmallVector<Value *, 3> Idx(CE->op_begin() + 1, CE->op_end());
Eric Christopher4a741042014-02-16 08:46:55 +00001695 addUInt(Loc, dwarf::DW_FORM_udata,
Eric Christopherc2697f82013-10-19 01:04:47 +00001696 Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
Eric Christopher4a741042014-02-16 08:46:55 +00001697 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1698 addBlock(VariableDIE, dwarf::DW_AT_location, Loc);
Devang Pateldfd6ec32011-08-15 17:57:41 +00001699 }
1700
Eric Christopherc12c2112011-11-11 01:55:22 +00001701 if (addToAccelTable) {
1702 DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1703 addAccelName(GV.getName(), AddrDIE);
Eric Christopher4996c702011-11-07 09:24:32 +00001704
Eric Christopherc12c2112011-11-11 01:55:22 +00001705 // If the linkage name is different than the name, go ahead and output
1706 // that as well into the name table.
1707 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1708 addAccelName(GV.getLinkageName(), AddrDIE);
1709 }
Eric Christopherd2b497b2013-10-16 01:37:49 +00001710
1711 if (!GV.isLocalToUnit())
Eric Christopher2c8b7902013-10-17 02:06:06 +00001712 addGlobalName(GV.getName(), VariableSpecDIE ? VariableSpecDIE : VariableDIE,
1713 GV.getContext());
Devang Pateldfd6ec32011-08-15 17:57:41 +00001714}
1715
Devang Patel0e821f42011-04-12 23:21:44 +00001716/// constructSubrangeDIE - Construct subrange DIE from DISubrange.
Eric Christophera5a79422013-12-09 23:32:48 +00001717void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
Manman Renb987e512013-10-29 00:53:03 +00001718 DIE *DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
Manman Ren4c4b69c2013-10-11 23:58:05 +00001719 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, IndexTy);
Devang Patel0e821f42011-04-12 23:21:44 +00001720
Bill Wendling28fe9e72012-12-06 07:38:10 +00001721 // The LowerBound value defines the lower bounds which is typically zero for
1722 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1723 // Count == -1 then the array is unbounded and we do not emit
1724 // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1725 // Count == 0, then the array has zero elements in which case we do not emit
1726 // an upper bound.
1727 int64_t LowerBound = SR.getLo();
Bill Wendling3495f9b2012-12-06 07:55:19 +00001728 int64_t DefaultLowerBound = getDefaultLowerBound();
Bill Wendlingd7767122012-12-04 21:34:03 +00001729 int64_t Count = SR.getCount();
Devang Patel0e821f42011-04-12 23:21:44 +00001730
Bill Wendling3495f9b2012-12-06 07:55:19 +00001731 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
David Blaikief2443192013-10-21 17:28:37 +00001732 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
Bill Wendling28fe9e72012-12-06 07:38:10 +00001733
1734 if (Count != -1 && Count != 0)
Bill Wendlingd7767122012-12-04 21:34:03 +00001735 // FIXME: An unbounded array should reference the expression that defines
1736 // the array.
Eric Christopher98b7f172013-11-11 18:52:36 +00001737 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, None,
1738 LowerBound + Count - 1);
Devang Patel0e821f42011-04-12 23:21:44 +00001739}
1740
1741/// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
Eric Christophera5a79422013-12-09 23:32:48 +00001742void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
Eric Christopherdf9955d2013-11-11 18:52:31 +00001743 if (CTy.isVector())
Eric Christopherbb69a272012-08-24 01:14:27 +00001744 addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
Devang Patel0e821f42011-04-12 23:21:44 +00001745
Eric Christopher0df08e22013-08-08 07:40:37 +00001746 // Emit the element type.
Eric Christopherdf9955d2013-11-11 18:52:31 +00001747 addType(&Buffer, resolve(CTy.getTypeDerivedFrom()));
Devang Patel0e821f42011-04-12 23:21:44 +00001748
1749 // Get an anonymous type for index type.
Eric Christophercad9b532013-01-04 21:51:53 +00001750 // FIXME: This type should be passed down from the front end
1751 // as different languages may have different sizes for indexes.
Devang Patel0e821f42011-04-12 23:21:44 +00001752 DIE *IdxTy = getIndexTyDie();
1753 if (!IdxTy) {
1754 // Construct an anonymous type for index type.
David Blaikie2a80e442013-12-02 22:09:48 +00001755 IdxTy = createAndAddDIE(dwarf::DW_TAG_base_type, *UnitDie);
Eric Christophercad9b532013-01-04 21:51:53 +00001756 addString(IdxTy, dwarf::DW_AT_name, "int");
David Blaikief2443192013-10-21 17:28:37 +00001757 addUInt(IdxTy, dwarf::DW_AT_byte_size, None, sizeof(int32_t));
Devang Patel0e821f42011-04-12 23:21:44 +00001758 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1759 dwarf::DW_ATE_signed);
Devang Patel0e821f42011-04-12 23:21:44 +00001760 setIndexTyDie(IdxTy);
1761 }
1762
1763 // Add subranges to array type.
Eric Christopherdf9955d2013-11-11 18:52:31 +00001764 DIArray Elements = CTy.getTypeArray();
Devang Patel0e821f42011-04-12 23:21:44 +00001765 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1766 DIDescriptor Element = Elements.getElement(i);
1767 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1768 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1769 }
1770}
1771
Eric Christopheraeb105f2013-11-11 18:52:39 +00001772/// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
Eric Christophera5a79422013-12-09 23:32:48 +00001773void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
Eric Christopheraeb105f2013-11-11 18:52:39 +00001774 DIArray Elements = CTy.getTypeArray();
1775
1776 // Add enumerators to enumeration type.
1777 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
David Blaikie4f6bf27a2013-11-18 23:33:32 +00001778 DIEnumerator Enum(Elements.getElement(i));
Eric Christopheraeb105f2013-11-11 18:52:39 +00001779 if (Enum.isEnumerator()) {
1780 DIE *Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
David Blaikie4f6bf27a2013-11-18 23:33:32 +00001781 StringRef Name = Enum.getName();
Eric Christopheraeb105f2013-11-11 18:52:39 +00001782 addString(Enumerator, dwarf::DW_AT_name, Name);
David Blaikie4f6bf27a2013-11-18 23:33:32 +00001783 int64_t Value = Enum.getEnumValue();
Eric Christophera07e4f52013-11-19 09:28:34 +00001784 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1785 Value);
Eric Christopheraeb105f2013-11-11 18:52:39 +00001786 }
1787 }
1788 DIType DTy = resolve(CTy.getTypeDerivedFrom());
1789 if (DTy) {
1790 addType(&Buffer, DTy);
1791 addFlag(&Buffer, dwarf::DW_AT_enum_class);
1792 }
Devang Patel0e821f42011-04-12 23:21:44 +00001793}
1794
Devang Patel89543712011-08-15 17:24:54 +00001795/// constructContainingTypeDIEs - Construct DIEs for types that contain
1796/// vtables.
Eric Christophera5a79422013-12-09 23:32:48 +00001797void DwarfUnit::constructContainingTypeDIEs() {
Devang Patel89543712011-08-15 17:24:54 +00001798 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
Eric Christopherc2697f82013-10-19 01:04:47 +00001799 CE = ContainingTypeMap.end();
1800 CI != CE; ++CI) {
Devang Patel89543712011-08-15 17:24:54 +00001801 DIE *SPDie = CI->first;
David Blaikie2ad00162013-11-15 23:09:13 +00001802 DIDescriptor D(CI->second);
1803 if (!D)
Eric Christopherc2697f82013-10-19 01:04:47 +00001804 continue;
David Blaikie2ad00162013-11-15 23:09:13 +00001805 DIE *NDie = getDIE(D);
Eric Christopherc2697f82013-10-19 01:04:47 +00001806 if (!NDie)
1807 continue;
Manman Ren4c4b69c2013-10-11 23:58:05 +00001808 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, NDie);
Devang Patel89543712011-08-15 17:24:54 +00001809 }
1810}
1811
Devang Patel3acc70e2011-08-15 22:04:40 +00001812/// constructVariableDIE - Construct a DIE for the given DbgVariable.
Eric Christophera5a79422013-12-09 23:32:48 +00001813DIE *DwarfUnit::constructVariableDIE(DbgVariable &DV, bool isScopeAbstract) {
Eric Christopher34a2c872013-11-15 01:43:19 +00001814 StringRef Name = DV.getName();
Devang Patel3acc70e2011-08-15 22:04:40 +00001815
Devang Patel3acc70e2011-08-15 22:04:40 +00001816 // Define variable debug information entry.
Eric Christopher34a2c872013-11-15 01:43:19 +00001817 DIE *VariableDie = new DIE(DV.getTag());
1818 DbgVariable *AbsVar = DV.getAbstractVariable();
Devang Patel3acc70e2011-08-15 22:04:40 +00001819 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
Manman Ren4213c392013-05-29 17:16:59 +00001820 if (AbsDIE)
Manman Ren4c4b69c2013-10-11 23:58:05 +00001821 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin, AbsDIE);
Devang Patel3acc70e2011-08-15 22:04:40 +00001822 else {
David Blaikie715528b2013-08-19 03:34:03 +00001823 if (!Name.empty())
1824 addString(VariableDie, dwarf::DW_AT_name, Name);
Eric Christopher34a2c872013-11-15 01:43:19 +00001825 addSourceLine(VariableDie, DV.getVariable());
1826 addType(VariableDie, DV.getType());
Devang Patel3acc70e2011-08-15 22:04:40 +00001827 }
1828
Eric Christopher34a2c872013-11-15 01:43:19 +00001829 if (DV.isArtificial())
Eric Christopherbb69a272012-08-24 01:14:27 +00001830 addFlag(VariableDie, dwarf::DW_AT_artificial);
Devang Patel3acc70e2011-08-15 22:04:40 +00001831
1832 if (isScopeAbstract) {
Eric Christopher34a2c872013-11-15 01:43:19 +00001833 DV.setDIE(VariableDie);
Devang Patel3acc70e2011-08-15 22:04:40 +00001834 return VariableDie;
1835 }
1836
1837 // Add variable address.
1838
Eric Christopher34a2c872013-11-15 01:43:19 +00001839 unsigned Offset = DV.getDotDebugLocOffset();
Devang Patel3acc70e2011-08-15 22:04:40 +00001840 if (Offset != ~0U) {
Eric Christophera27220f2014-03-05 22:41:20 +00001841 addLocationList(VariableDie, dwarf::DW_AT_location, Offset);
Eric Christopher34a2c872013-11-15 01:43:19 +00001842 DV.setDIE(VariableDie);
Devang Patel3acc70e2011-08-15 22:04:40 +00001843 return VariableDie;
1844 }
1845
Eric Christophercead0332011-10-03 15:49:20 +00001846 // Check if variable is described by a DBG_VALUE instruction.
Eric Christopher34a2c872013-11-15 01:43:19 +00001847 if (const MachineInstr *DVInsn = DV.getMInsn()) {
David Blaikie0252265b2013-06-16 20:34:15 +00001848 assert(DVInsn->getNumOperands() == 3);
1849 if (DVInsn->getOperand(0).isReg()) {
1850 const MachineOperand RegOp = DVInsn->getOperand(0);
Adrian Prantl19942882013-07-09 21:44:06 +00001851 // If the second operand is an immediate, this is an indirect value.
Adrian Prantl418d1d12013-07-09 20:28:37 +00001852 if (DVInsn->getOperand(1).isImm()) {
Eric Christopherc2697f82013-10-19 01:04:47 +00001853 MachineLocation Location(RegOp.getReg(),
1854 DVInsn->getOperand(1).getImm());
Eric Christopher34a2c872013-11-15 01:43:19 +00001855 addVariableAddress(DV, VariableDie, Location);
David Blaikie0252265b2013-06-16 20:34:15 +00001856 } else if (RegOp.getReg())
Eric Christopher34a2c872013-11-15 01:43:19 +00001857 addVariableAddress(DV, VariableDie, MachineLocation(RegOp.getReg()));
David Blaikie0252265b2013-06-16 20:34:15 +00001858 } else if (DVInsn->getOperand(0).isImm())
Eric Christopher34a2c872013-11-15 01:43:19 +00001859 addConstantValue(VariableDie, DVInsn->getOperand(0), DV.getType());
David Blaikie0252265b2013-06-16 20:34:15 +00001860 else if (DVInsn->getOperand(0).isFPImm())
Eric Christopher78fcf4902013-07-03 01:08:30 +00001861 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
David Blaikie0252265b2013-06-16 20:34:15 +00001862 else if (DVInsn->getOperand(0).isCImm())
Eric Christopher78fcf4902013-07-03 01:08:30 +00001863 addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
Eric Christopher34a2c872013-11-15 01:43:19 +00001864 isUnsignedDIType(DD, DV.getType()));
Eric Christopher78fcf4902013-07-03 01:08:30 +00001865
Eric Christopher34a2c872013-11-15 01:43:19 +00001866 DV.setDIE(VariableDie);
Devang Patel3acc70e2011-08-15 22:04:40 +00001867 return VariableDie;
1868 } else {
1869 // .. else use frame index.
Eric Christopher34a2c872013-11-15 01:43:19 +00001870 int FI = DV.getFrameIndex();
Devang Patel3acc70e2011-08-15 22:04:40 +00001871 if (FI != ~0) {
1872 unsigned FrameReg = 0;
1873 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
Eric Christopherc2697f82013-10-19 01:04:47 +00001874 int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
Devang Patel3acc70e2011-08-15 22:04:40 +00001875 MachineLocation Location(FrameReg, Offset);
Eric Christopher34a2c872013-11-15 01:43:19 +00001876 addVariableAddress(DV, VariableDie, Location);
Devang Patel3acc70e2011-08-15 22:04:40 +00001877 }
1878 }
1879
Eric Christopher34a2c872013-11-15 01:43:19 +00001880 DV.setDIE(VariableDie);
Devang Patel3acc70e2011-08-15 22:04:40 +00001881 return VariableDie;
1882}
1883
Manman Ren230ec862013-10-23 23:00:44 +00001884/// constructMemberDIE - Construct member DIE from DIDerivedType.
Eric Christophera5a79422013-12-09 23:32:48 +00001885void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
Manman Renb987e512013-10-29 00:53:03 +00001886 DIE *MemberDie = createAndAddDIE(DT.getTag(), Buffer);
Devang Patel0e821f42011-04-12 23:21:44 +00001887 StringRef Name = DT.getName();
1888 if (!Name.empty())
Nick Lewyckyd59c0ca2011-10-27 06:44:11 +00001889 addString(MemberDie, dwarf::DW_AT_name, Name);
Devang Patel0e821f42011-04-12 23:21:44 +00001890
Manman Ren93b30902013-10-08 18:42:58 +00001891 addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
Devang Patel0e821f42011-04-12 23:21:44 +00001892
1893 addSourceLine(MemberDie, DT);
1894
Eric Christopherc2697f82013-10-19 01:04:47 +00001895 if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
Devang Patel0e821f42011-04-12 23:21:44 +00001896
1897 // For C++, virtual base classes are not at fixed offset. Use following
1898 // expression to extract appropriate offset from vtable.
1899 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1900
Eric Christopher4a741042014-02-16 08:46:55 +00001901 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
David Blaikief2443192013-10-21 17:28:37 +00001902 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1903 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1904 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1905 addUInt(VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1906 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1907 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1908 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
Devang Patel0e821f42011-04-12 23:21:44 +00001909
David Blaikief2443192013-10-21 17:28:37 +00001910 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
David Blaikie71d34a22013-11-01 00:25:45 +00001911 } else {
1912 uint64_t Size = DT.getSizeInBits();
1913 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1914 uint64_t OffsetInBytes;
1915
1916 if (Size != FieldSize) {
Eric Christopher1acdbb82014-03-12 17:14:46 +00001917 // Handle bitfield, assume bytes are 8 bits.
1918 addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1919 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
David Blaikie71d34a22013-11-01 00:25:45 +00001920
1921 uint64_t Offset = DT.getOffsetInBits();
1922 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1923 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1924 uint64_t FieldOffset = (HiMark - FieldSize);
1925 Offset -= FieldOffset;
1926
1927 // Maybe we need to work from the other end.
1928 if (Asm->getDataLayout().isLittleEndian())
1929 Offset = FieldSize - (Offset + Size);
1930 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1931
Adrian Prantlc67655a2014-01-28 18:13:47 +00001932 // Here DW_AT_data_member_location points to the anonymous
David Blaikie71d34a22013-11-01 00:25:45 +00001933 // field that includes this bit field.
1934 OffsetInBytes = FieldOffset >> 3;
1935 } else
1936 // This is not a bitfield.
1937 OffsetInBytes = DT.getOffsetInBits() >> 3;
David Blaikie2ada1162014-01-03 00:48:38 +00001938
David Blaikie22b29a52014-01-03 01:30:05 +00001939 if (DD->getDwarfVersion() <= 2) {
Eric Christopher4a741042014-02-16 08:46:55 +00001940 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
David Blaikie22b29a52014-01-03 01:30:05 +00001941 addUInt(MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1942 addUInt(MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1943 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1944 } else
1945 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1946 OffsetInBytes);
David Blaikie71d34a22013-11-01 00:25:45 +00001947 }
Devang Patel0e821f42011-04-12 23:21:44 +00001948
1949 if (DT.isProtected())
Nick Lewyckycb918492011-12-13 05:09:11 +00001950 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
Devang Patel0e821f42011-04-12 23:21:44 +00001951 dwarf::DW_ACCESS_protected);
1952 else if (DT.isPrivate())
Nick Lewyckycb918492011-12-13 05:09:11 +00001953 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
Devang Patel0e821f42011-04-12 23:21:44 +00001954 dwarf::DW_ACCESS_private);
1955 // Otherwise C++ member and base classes are considered public.
Eric Christopher92331fd2012-11-21 00:34:38 +00001956 else
Nick Lewyckycb918492011-12-13 05:09:11 +00001957 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
Devang Patel0e821f42011-04-12 23:21:44 +00001958 dwarf::DW_ACCESS_public);
1959 if (DT.isVirtual())
Nick Lewyckycfde1a22011-12-14 00:56:07 +00001960 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
Devang Patel0e821f42011-04-12 23:21:44 +00001961 dwarf::DW_VIRTUALITY_virtual);
Devang Patel514b4002011-04-16 00:11:51 +00001962
1963 // Objective-C properties.
Devang Patel44882172012-02-06 17:49:43 +00001964 if (MDNode *PNode = DT.getObjCProperty())
1965 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
Eric Christopher92331fd2012-11-21 00:34:38 +00001966 MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
Devang Patel44882172012-02-06 17:49:43 +00001967 PropertyDie);
1968
David Blaikie37fefc32012-12-13 22:43:07 +00001969 if (DT.isArtificial())
1970 addFlag(MemberDie, dwarf::DW_AT_artificial);
Devang Patel0e821f42011-04-12 23:21:44 +00001971}
Eric Christopher4d23a4a2013-01-16 01:22:23 +00001972
Manman Renc6b63922013-10-14 20:33:57 +00001973/// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
Eric Christophera5a79422013-12-09 23:32:48 +00001974DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
Eric Christopher4d23a4a2013-01-16 01:22:23 +00001975 if (!DT.Verify())
1976 return NULL;
1977
Manman Renc6b63922013-10-14 20:33:57 +00001978 // Construct the context before querying for the existence of the DIE in case
1979 // such construction creates the DIE.
1980 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
David Blaikiebd700e42013-11-14 21:24:34 +00001981 assert(dwarf::isType(ContextDIE->getTag()) &&
1982 "Static member should belong to a type.");
Manman Renc6b63922013-10-14 20:33:57 +00001983
1984 DIE *StaticMemberDIE = getDIE(DT);
1985 if (StaticMemberDIE)
1986 return StaticMemberDIE;
1987
Manman Renb987e512013-10-29 00:53:03 +00001988 StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
Manman Renc6b63922013-10-14 20:33:57 +00001989
Manman Ren93b30902013-10-08 18:42:58 +00001990 DIType Ty = resolve(DT.getTypeDerivedFrom());
Eric Christopher4d23a4a2013-01-16 01:22:23 +00001991
1992 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1993 addType(StaticMemberDIE, Ty);
1994 addSourceLine(StaticMemberDIE, DT);
1995 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1996 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1997
1998 // FIXME: We could omit private if the parent is a class_type, and
1999 // public if the parent is something else.
2000 if (DT.isProtected())
2001 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
2002 dwarf::DW_ACCESS_protected);
2003 else if (DT.isPrivate())
2004 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
2005 dwarf::DW_ACCESS_private);
2006 else
2007 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
2008 dwarf::DW_ACCESS_public);
2009
2010 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
Manman Renb3388602013-10-05 01:43:03 +00002011 addConstantValue(StaticMemberDIE, CI, isUnsignedDIType(DD, Ty));
David Blaikiea39a76e2013-01-20 01:18:01 +00002012 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
2013 addConstantFPValue(StaticMemberDIE, CFP);
Eric Christopher4d23a4a2013-01-16 01:22:23 +00002014
Eric Christopher4d23a4a2013-01-16 01:22:23 +00002015 return StaticMemberDIE;
2016}
David Blaikie6b288cf2013-10-30 20:42:41 +00002017
Eric Christophera5a79422013-12-09 23:32:48 +00002018void DwarfUnit::emitHeader(const MCSection *ASection,
David Blaikie3332d4c2013-12-11 21:14:02 +00002019 const MCSymbol *ASectionSym) const {
David Blaikie6b288cf2013-10-30 20:42:41 +00002020 Asm->OutStreamer.AddComment("DWARF version number");
2021 Asm->EmitInt16(DD->getDwarfVersion());
2022 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
David Blaikie6896e192013-12-04 23:39:02 +00002023 // We share one abbreviations table across all units so it's always at the
2024 // start of the section. Use a relocatable offset where needed to ensure
2025 // linking doesn't invalidate that offset.
David Blaikie91db9ab2013-12-04 18:12:28 +00002026 Asm->EmitSectionOffset(ASectionSym, ASectionSym);
David Blaikie6b288cf2013-10-30 20:42:41 +00002027 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2028 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2029}
David Blaikiebc563272013-12-13 21:33:40 +00002030
David Blaikie2494fdb2014-02-14 22:41:51 +00002031void DwarfCompileUnit::initStmtList(MCSymbol *DwarfLineSectionSym) {
2032 // Define start line table label for each Compile Unit.
2033 MCSymbol *LineTableStartSym =
2034 Asm->GetTempSymbol("line_table_start", getUniqueID());
2035 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
2036 getUniqueID());
2037
2038 // Use a single line table if we are generating assembly.
2039 bool UseTheFirstCU =
2040 Asm->OutStreamer.hasRawTextSupport() || (getUniqueID() == 0);
2041
David Blaikie60e63862014-02-14 23:58:13 +00002042 stmtListIndex = UnitDie->getValues().size();
2043
David Blaikie2494fdb2014-02-14 22:41:51 +00002044 // DW_AT_stmt_list is a offset of line number information for this
2045 // compile unit in debug_line section. For split dwarf this is
2046 // left in the skeleton CU and so not included.
2047 // The line table entries are not always emitted in assembly, so it
2048 // is not okay to use line_table_start here.
2049 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2050 addSectionLabel(UnitDie.get(), dwarf::DW_AT_stmt_list,
2051 UseTheFirstCU ? DwarfLineSectionSym : LineTableStartSym);
2052 else if (UseTheFirstCU)
2053 addSectionOffset(UnitDie.get(), dwarf::DW_AT_stmt_list, 0);
2054 else
2055 addSectionDelta(UnitDie.get(), dwarf::DW_AT_stmt_list, LineTableStartSym,
2056 DwarfLineSectionSym);
2057}
2058
David Blaikie60e63862014-02-14 23:58:13 +00002059void DwarfCompileUnit::applyStmtList(DIE &D) {
2060 D.addValue(dwarf::DW_AT_stmt_list,
2061 UnitDie->getAbbrev().getData()[stmtListIndex].getForm(),
2062 UnitDie->getValues()[stmtListIndex]);
2063}
2064
David Blaikiebc563272013-12-13 21:33:40 +00002065void DwarfTypeUnit::emitHeader(const MCSection *ASection,
2066 const MCSymbol *ASectionSym) const {
2067 DwarfUnit::emitHeader(ASection, ASectionSym);
2068 Asm->OutStreamer.AddComment("Type Signature");
2069 Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
2070 Asm->OutStreamer.AddComment("Type DIE Offset");
David Blaikie15ed5eb2014-01-10 01:38:41 +00002071 // In a skeleton type unit there is no type DIE so emit a zero offset.
2072 Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
2073 sizeof(Ty->getOffset()));
David Blaikiebc563272013-12-13 21:33:40 +00002074}
2075
2076void DwarfTypeUnit::initSection(const MCSection *Section) {
2077 assert(!this->Section);
2078 this->Section = Section;
2079 // Since each type unit is contained in its own COMDAT section, the begin
2080 // label and the section label are the same. Using the begin label emission in
2081 // DwarfDebug to emit the section label as well is slightly subtle/sneaky, but
2082 // the only other alternative of lazily constructing start-of-section labels
2083 // and storing a mapping in DwarfDebug (or AsmPrinter).
2084 this->SectionSym = this->LabelBegin =
2085 Asm->GetTempSymbol(Section->getLabelBeginName(), getUniqueID());
2086 this->LabelEnd =
2087 Asm->GetTempSymbol(Section->getLabelEndName(), getUniqueID());
2088 this->LabelRange = Asm->GetTempSymbol("gnu_ranges", getUniqueID());
2089}