1 //===--- lib/CodeGen/DIE.cpp - DWARF Info Entries -------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // Data structures for DWARF info entries.
12 //===----------------------------------------------------------------------===//
15 #include "DwarfPrinter.h"
16 #include "llvm/CodeGen/AsmPrinter.h"
17 #include "llvm/Target/TargetAsmInfo.h"
18 #include "llvm/Target/TargetData.h"
22 //===----------------------------------------------------------------------===//
23 // DIEAbbrevData Implementation
24 //===----------------------------------------------------------------------===//
26 /// Profile - Used to gather unique data for the abbreviation folding set.
28 void DIEAbbrevData::Profile(FoldingSetNodeID &ID) const {
29 ID.AddInteger(Attribute);
33 //===----------------------------------------------------------------------===//
34 // DIEAbbrev Implementation
35 //===----------------------------------------------------------------------===//
37 /// Profile - Used to gather unique data for the abbreviation folding set.
39 void DIEAbbrev::Profile(FoldingSetNodeID &ID) const {
41 ID.AddInteger(ChildrenFlag);
43 // For each attribute description.
44 for (unsigned i = 0, N = Data.size(); i < N; ++i)
48 /// Emit - Print the abbreviation using the specified asm printer.
50 void DIEAbbrev::Emit(const AsmPrinter *Asm) const {
51 // Emit its Dwarf tag type.
52 Asm->EmitULEB128Bytes(Tag);
53 Asm->EOL(dwarf::TagString(Tag));
55 // Emit whether it has children DIEs.
56 Asm->EmitULEB128Bytes(ChildrenFlag);
57 Asm->EOL(dwarf::ChildrenString(ChildrenFlag));
59 // For each attribute description.
60 for (unsigned i = 0, N = Data.size(); i < N; ++i) {
61 const DIEAbbrevData &AttrData = Data[i];
63 // Emit attribute type.
64 Asm->EmitULEB128Bytes(AttrData.getAttribute());
65 Asm->EOL(dwarf::AttributeString(AttrData.getAttribute()));
68 Asm->EmitULEB128Bytes(AttrData.getForm());
69 Asm->EOL(dwarf::FormEncodingString(AttrData.getForm()));
72 // Mark end of abbreviation.
73 Asm->EmitULEB128Bytes(0); Asm->EOL("EOM(1)");
74 Asm->EmitULEB128Bytes(0); Asm->EOL("EOM(2)");
78 void DIEAbbrev::print(std::ostream &O) {
80 << std::hex << (intptr_t)this << std::dec
82 << dwarf::TagString(Tag)
84 << dwarf::ChildrenString(ChildrenFlag)
87 for (unsigned i = 0, N = Data.size(); i < N; ++i) {
89 << dwarf::AttributeString(Data[i].getAttribute())
91 << dwarf::FormEncodingString(Data[i].getForm())
95 void DIEAbbrev::dump() { print(cerr); }
98 //===----------------------------------------------------------------------===//
100 //===----------------------------------------------------------------------===//
103 for (unsigned i = 0, N = Children.size(); i < N; ++i)
107 /// AddSiblingOffset - Add a sibling offset field to the front of the DIE.
109 void DIE::AddSiblingOffset() {
110 DIEInteger *DI = new DIEInteger(0);
111 Values.insert(Values.begin(), DI);
112 Abbrev.AddFirstAttribute(dwarf::DW_AT_sibling, dwarf::DW_FORM_ref4);
115 /// Profile - Used to gather unique data for the value folding set.
117 void DIE::Profile(FoldingSetNodeID &ID) {
120 for (unsigned i = 0, N = Children.size(); i < N; ++i)
121 ID.AddPointer(Children[i]);
123 for (unsigned j = 0, M = Values.size(); j < M; ++j)
124 ID.AddPointer(Values[j]);
128 void DIE::print(std::ostream &O, unsigned IncIndent) {
129 IndentCount += IncIndent;
130 const std::string Indent(IndentCount, ' ');
131 bool isBlock = Abbrev.getTag() == 0;
136 << "0x" << std::hex << (intptr_t)this << std::dec
137 << ", Offset: " << Offset
138 << ", Size: " << Size
142 << dwarf::TagString(Abbrev.getTag())
144 << dwarf::ChildrenString(Abbrev.getChildrenFlag());
146 O << "Size: " << Size;
150 const SmallVector<DIEAbbrevData, 8> &Data = Abbrev.getData();
153 for (unsigned i = 0, N = Data.size(); i < N; ++i) {
157 O << dwarf::AttributeString(Data[i].getAttribute());
159 O << "Blk[" << i << "]";
162 << dwarf::FormEncodingString(Data[i].getForm())
169 for (unsigned j = 0, M = Children.size(); j < M; ++j) {
170 Children[j]->print(O, 4);
173 if (!isBlock) O << "\n";
174 IndentCount -= IncIndent;
184 void DIEValue::dump() {
189 //===----------------------------------------------------------------------===//
190 // DIEInteger Implementation
191 //===----------------------------------------------------------------------===//
193 /// EmitValue - Emit integer of appropriate size.
195 void DIEInteger::EmitValue(Dwarf *D, unsigned Form) const {
196 const AsmPrinter *Asm = D->getAsm();
198 case dwarf::DW_FORM_flag: // Fall thru
199 case dwarf::DW_FORM_ref1: // Fall thru
200 case dwarf::DW_FORM_data1: Asm->EmitInt8(Integer); break;
201 case dwarf::DW_FORM_ref2: // Fall thru
202 case dwarf::DW_FORM_data2: Asm->EmitInt16(Integer); break;
203 case dwarf::DW_FORM_ref4: // Fall thru
204 case dwarf::DW_FORM_data4: Asm->EmitInt32(Integer); break;
205 case dwarf::DW_FORM_ref8: // Fall thru
206 case dwarf::DW_FORM_data8: Asm->EmitInt64(Integer); break;
207 case dwarf::DW_FORM_udata: Asm->EmitULEB128Bytes(Integer); break;
208 case dwarf::DW_FORM_sdata: Asm->EmitSLEB128Bytes(Integer); break;
209 default: assert(0 && "DIE Value form not supported yet"); break;
213 /// SizeOf - Determine size of integer value in bytes.
215 unsigned DIEInteger::SizeOf(const TargetData *TD, unsigned Form) const {
217 case dwarf::DW_FORM_flag: // Fall thru
218 case dwarf::DW_FORM_ref1: // Fall thru
219 case dwarf::DW_FORM_data1: return sizeof(int8_t);
220 case dwarf::DW_FORM_ref2: // Fall thru
221 case dwarf::DW_FORM_data2: return sizeof(int16_t);
222 case dwarf::DW_FORM_ref4: // Fall thru
223 case dwarf::DW_FORM_data4: return sizeof(int32_t);
224 case dwarf::DW_FORM_ref8: // Fall thru
225 case dwarf::DW_FORM_data8: return sizeof(int64_t);
226 case dwarf::DW_FORM_udata: return TargetAsmInfo::getULEB128Size(Integer);
227 case dwarf::DW_FORM_sdata: return TargetAsmInfo::getSLEB128Size(Integer);
228 default: assert(0 && "DIE Value form not supported yet"); break;
233 /// Profile - Used to gather unique data for the value folding set.
235 void DIEInteger::Profile(FoldingSetNodeID &ID, unsigned Int) {
236 ID.AddInteger(isInteger);
239 void DIEInteger::Profile(FoldingSetNodeID &ID) {
240 Profile(ID, Integer);
244 void DIEInteger::print(std::ostream &O) {
245 O << "Int: " << (int64_t)Integer
246 << " 0x" << std::hex << Integer << std::dec;
250 //===----------------------------------------------------------------------===//
251 // DIEString Implementation
252 //===----------------------------------------------------------------------===//
254 /// EmitValue - Emit string value.
256 void DIEString::EmitValue(Dwarf *D, unsigned Form) const {
257 D->getAsm()->EmitString(Str);
260 /// Profile - Used to gather unique data for the value folding set.
262 void DIEString::Profile(FoldingSetNodeID &ID, const std::string &Str) {
263 ID.AddInteger(isString);
266 void DIEString::Profile(FoldingSetNodeID &ID) {
271 void DIEString::print(std::ostream &O) {
272 O << "Str: \"" << Str << "\"";
276 //===----------------------------------------------------------------------===//
277 // DIEDwarfLabel Implementation
278 //===----------------------------------------------------------------------===//
280 /// EmitValue - Emit label value.
282 void DIEDwarfLabel::EmitValue(Dwarf *D, unsigned Form) const {
283 bool IsSmall = Form == dwarf::DW_FORM_data4;
284 D->EmitReference(Label, false, IsSmall);
287 /// SizeOf - Determine size of label value in bytes.
289 unsigned DIEDwarfLabel::SizeOf(const TargetData *TD, unsigned Form) const {
290 if (Form == dwarf::DW_FORM_data4) return 4;
291 return TD->getPointerSize();
294 /// Profile - Used to gather unique data for the value folding set.
296 void DIEDwarfLabel::Profile(FoldingSetNodeID &ID, const DWLabel &Label) {
297 ID.AddInteger(isLabel);
300 void DIEDwarfLabel::Profile(FoldingSetNodeID &ID) {
305 void DIEDwarfLabel::print(std::ostream &O) {
311 //===----------------------------------------------------------------------===//
312 // DIEObjectLabel Implementation
313 //===----------------------------------------------------------------------===//
315 /// EmitValue - Emit label value.
317 void DIEObjectLabel::EmitValue(Dwarf *D, unsigned Form) const {
318 bool IsSmall = Form == dwarf::DW_FORM_data4;
319 D->EmitReference(Label, false, IsSmall);
322 /// SizeOf - Determine size of label value in bytes.
324 unsigned DIEObjectLabel::SizeOf(const TargetData *TD, unsigned Form) const {
325 if (Form == dwarf::DW_FORM_data4) return 4;
326 return TD->getPointerSize();
329 /// Profile - Used to gather unique data for the value folding set.
331 void DIEObjectLabel::Profile(FoldingSetNodeID &ID, const std::string &Label) {
332 ID.AddInteger(isAsIsLabel);
335 void DIEObjectLabel::Profile(FoldingSetNodeID &ID) {
336 Profile(ID, Label.c_str());
340 void DIEObjectLabel::print(std::ostream &O) {
341 O << "Obj: " << Label;
345 //===----------------------------------------------------------------------===//
346 // DIESectionOffset Implementation
347 //===----------------------------------------------------------------------===//
349 /// EmitValue - Emit delta value.
351 void DIESectionOffset::EmitValue(Dwarf *D, unsigned Form) const {
352 bool IsSmall = Form == dwarf::DW_FORM_data4;
353 D->EmitSectionOffset(Label.getTag(), Section.getTag(),
354 Label.getNumber(), Section.getNumber(),
355 IsSmall, IsEH, UseSet);
358 /// SizeOf - Determine size of delta value in bytes.
360 unsigned DIESectionOffset::SizeOf(const TargetData *TD, unsigned Form) const {
361 if (Form == dwarf::DW_FORM_data4) return 4;
362 return TD->getPointerSize();
365 /// Profile - Used to gather unique data for the value folding set.
367 void DIESectionOffset::Profile(FoldingSetNodeID &ID, const DWLabel &Label,
368 const DWLabel &Section) {
369 ID.AddInteger(isSectionOffset);
372 // IsEH and UseSet are specific to the Label/Section that we will emit the
373 // offset for; so Label/Section are enough for uniqueness.
375 void DIESectionOffset::Profile(FoldingSetNodeID &ID) {
376 Profile(ID, Label, Section);
380 void DIESectionOffset::print(std::ostream &O) {
385 O << "-" << IsEH << "-" << UseSet;
389 //===----------------------------------------------------------------------===//
390 // DIEDelta Implementation
391 //===----------------------------------------------------------------------===//
393 /// EmitValue - Emit delta value.
395 void DIEDelta::EmitValue(Dwarf *D, unsigned Form) const {
396 bool IsSmall = Form == dwarf::DW_FORM_data4;
397 D->EmitDifference(LabelHi, LabelLo, IsSmall);
400 /// SizeOf - Determine size of delta value in bytes.
402 unsigned DIEDelta::SizeOf(const TargetData *TD, unsigned Form) const {
403 if (Form == dwarf::DW_FORM_data4) return 4;
404 return TD->getPointerSize();
407 /// Profile - Used to gather unique data for the value folding set.
409 void DIEDelta::Profile(FoldingSetNodeID &ID, const DWLabel &LabelHi,
410 const DWLabel &LabelLo) {
411 ID.AddInteger(isDelta);
415 void DIEDelta::Profile(FoldingSetNodeID &ID) {
416 Profile(ID, LabelHi, LabelLo);
420 void DIEDelta::print(std::ostream &O) {
428 //===----------------------------------------------------------------------===//
429 // DIEEntry Implementation
430 //===----------------------------------------------------------------------===//
432 /// EmitValue - Emit debug information entry offset.
434 void DIEEntry::EmitValue(Dwarf *D, unsigned Form) const {
435 D->getAsm()->EmitInt32(Entry->getOffset());
438 /// Profile - Used to gather unique data for the value folding set.
440 void DIEEntry::Profile(FoldingSetNodeID &ID, DIE *Entry) {
441 ID.AddInteger(isEntry);
442 ID.AddPointer(Entry);
444 void DIEEntry::Profile(FoldingSetNodeID &ID) {
445 ID.AddInteger(isEntry);
448 ID.AddPointer(Entry);
454 void DIEEntry::print(std::ostream &O) {
455 O << "Die: 0x" << std::hex << (intptr_t)Entry << std::dec;
459 //===----------------------------------------------------------------------===//
460 // DIEBlock Implementation
461 //===----------------------------------------------------------------------===//
463 /// ComputeSize - calculate the size of the block.
465 unsigned DIEBlock::ComputeSize(const TargetData *TD) {
467 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev.getData();
468 for (unsigned i = 0, N = Values.size(); i < N; ++i)
469 Size += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
475 /// EmitValue - Emit block data.
477 void DIEBlock::EmitValue(Dwarf *D, unsigned Form) const {
478 const AsmPrinter *Asm = D->getAsm();
480 case dwarf::DW_FORM_block1: Asm->EmitInt8(Size); break;
481 case dwarf::DW_FORM_block2: Asm->EmitInt16(Size); break;
482 case dwarf::DW_FORM_block4: Asm->EmitInt32(Size); break;
483 case dwarf::DW_FORM_block: Asm->EmitULEB128Bytes(Size); break;
484 default: assert(0 && "Improper form for block"); break;
487 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev.getData();
488 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
490 Values[i]->EmitValue(D, AbbrevData[i].getForm());
494 /// SizeOf - Determine size of block data in bytes.
496 unsigned DIEBlock::SizeOf(const TargetData *TD, unsigned Form) const {
498 case dwarf::DW_FORM_block1: return Size + sizeof(int8_t);
499 case dwarf::DW_FORM_block2: return Size + sizeof(int16_t);
500 case dwarf::DW_FORM_block4: return Size + sizeof(int32_t);
501 case dwarf::DW_FORM_block: return Size + TargetAsmInfo::getULEB128Size(Size);
502 default: assert(0 && "Improper form for block"); break;
507 void DIEBlock::Profile(FoldingSetNodeID &ID) {
508 ID.AddInteger(isBlock);
513 void DIEBlock::print(std::ostream &O) {