MCDwarf.cpp revision f4f14f68f6078ea6681ee27b5bf42719d7db3441 
1//===- lib/MC/MCDwarf.cpp - MCDwarf implementation ------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "llvm/MC/MCDwarf.h"
11#include "llvm/MC/MCAsmInfo.h"
12#include "llvm/MC/MCContext.h"
13#include "llvm/MC/MCObjectFileInfo.h"
14#include "llvm/MC/MCObjectWriter.h"
15#include "llvm/MC/MCRegisterInfo.h"
16#include "llvm/MC/MCStreamer.h"
17#include "llvm/MC/MCSymbol.h"
18#include "llvm/MC/MCExpr.h"
19#include "llvm/Support/Debug.h"
20#include "llvm/Support/ErrorHandling.h"
21#include "llvm/Support/raw_ostream.h"
22#include "llvm/Support/LEB128.h"
23#include "llvm/Support/Path.h"
24#include "llvm/Support/SourceMgr.h"
25#include "llvm/ADT/Hashing.h"
26#include "llvm/ADT/SmallString.h"
27#include "llvm/ADT/Twine.h"
28#include "llvm/Config/config.h"
29using namespace llvm;
30
31// Given a special op, return the address skip amount (in units of
32// DWARF2_LINE_MIN_INSN_LENGTH.
33#define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
34
35// The maximum address skip amount that can be encoded with a special op.
36#define MAX_SPECIAL_ADDR_DELTA         SPECIAL_ADDR(255)
37
38// First special line opcode - leave room for the standard opcodes.
39// Note: If you want to change this, you'll have to update the
40// "standard_opcode_lengths" table that is emitted in DwarfFileTable::Emit().
41#define DWARF2_LINE_OPCODE_BASE         13
42
43// Minimum line offset in a special line info. opcode.  This value
44// was chosen to give a reasonable range of values.
45#define DWARF2_LINE_BASE                -5
46
47// Range of line offsets in a special line info. opcode.
48#define DWARF2_LINE_RANGE               14
49
50// Define the architecture-dependent minimum instruction length (in bytes).
51// This value should be rather too small than too big.
52#define DWARF2_LINE_MIN_INSN_LENGTH     1
53
54// Note: when DWARF2_LINE_MIN_INSN_LENGTH == 1 which is the current setting,
55// this routine is a nop and will be optimized away.
56static inline uint64_t ScaleAddrDelta(uint64_t AddrDelta) {
57  if (DWARF2_LINE_MIN_INSN_LENGTH == 1)
58    return AddrDelta;
59  if (AddrDelta % DWARF2_LINE_MIN_INSN_LENGTH != 0) {
60    // TODO: report this error, but really only once.
61    ;
62  }
63  return AddrDelta / DWARF2_LINE_MIN_INSN_LENGTH;
64}
65
66//
67// This is called when an instruction is assembled into the specified section
68// and if there is information from the last .loc directive that has yet to have
69// a line entry made for it is made.
70//
71void MCLineEntry::Make(MCStreamer *MCOS, const MCSection *Section) {
72  if (!MCOS->getContext().getDwarfLocSeen())
73    return;
74
75  // Create a symbol at in the current section for use in the line entry.
76  MCSymbol *LineSym = MCOS->getContext().CreateTempSymbol();
77  // Set the value of the symbol to use for the MCLineEntry.
78  MCOS->EmitLabel(LineSym);
79
80  // Get the current .loc info saved in the context.
81  const MCDwarfLoc &DwarfLoc = MCOS->getContext().getCurrentDwarfLoc();
82
83  // Create a (local) line entry with the symbol and the current .loc info.
84  MCLineEntry LineEntry(LineSym, DwarfLoc);
85
86  // clear DwarfLocSeen saying the current .loc info is now used.
87  MCOS->getContext().ClearDwarfLocSeen();
88
89  // Get the MCLineSection for this section, if one does not exist for this
90  // section create it.
91  const DenseMap<const MCSection *, MCLineSection *> &MCLineSections =
92    MCOS->getContext().getMCLineSections();
93  MCLineSection *LineSection = MCLineSections.lookup(Section);
94  if (!LineSection) {
95    // Create a new MCLineSection.  This will be deleted after the dwarf line
96    // table is created using it by iterating through the MCLineSections
97    // DenseMap.
98    LineSection = new MCLineSection;
99    // Save a pointer to the new LineSection into the MCLineSections DenseMap.
100    MCOS->getContext().addMCLineSection(Section, LineSection);
101  }
102
103  // Add the line entry to this section's entries.
104  LineSection->addLineEntry(LineEntry);
105}
106
107//
108// This helper routine returns an expression of End - Start + IntVal .
109//
110static inline const MCExpr *MakeStartMinusEndExpr(const MCStreamer &MCOS,
111                                                  const MCSymbol &Start,
112                                                  const MCSymbol &End,
113                                                  int IntVal) {
114  MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None;
115  const MCExpr *Res =
116    MCSymbolRefExpr::Create(&End, Variant, MCOS.getContext());
117  const MCExpr *RHS =
118    MCSymbolRefExpr::Create(&Start, Variant, MCOS.getContext());
119  const MCExpr *Res1 =
120    MCBinaryExpr::Create(MCBinaryExpr::Sub, Res, RHS, MCOS.getContext());
121  const MCExpr *Res2 =
122    MCConstantExpr::Create(IntVal, MCOS.getContext());
123  const MCExpr *Res3 =
124    MCBinaryExpr::Create(MCBinaryExpr::Sub, Res1, Res2, MCOS.getContext());
125  return Res3;
126}
127
128//
129// This emits the Dwarf line table for the specified section from the entries
130// in the LineSection.
131//
132static inline void EmitDwarfLineTable(MCStreamer *MCOS,
133                                      const MCSection *Section,
134                                      const MCLineSection *LineSection) {
135  unsigned FileNum = 1;
136  unsigned LastLine = 1;
137  unsigned Column = 0;
138  unsigned Flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0;
139  unsigned Isa = 0;
140  MCSymbol *LastLabel = NULL;
141
142  // Loop through each MCLineEntry and encode the dwarf line number table.
143  for (MCLineSection::const_iterator
144         it = LineSection->getMCLineEntries()->begin(),
145         ie = LineSection->getMCLineEntries()->end(); it != ie; ++it) {
146
147    if (FileNum != it->getFileNum()) {
148      FileNum = it->getFileNum();
149      MCOS->EmitIntValue(dwarf::DW_LNS_set_file, 1);
150      MCOS->EmitULEB128IntValue(FileNum);
151    }
152    if (Column != it->getColumn()) {
153      Column = it->getColumn();
154      MCOS->EmitIntValue(dwarf::DW_LNS_set_column, 1);
155      MCOS->EmitULEB128IntValue(Column);
156    }
157    if (Isa != it->getIsa()) {
158      Isa = it->getIsa();
159      MCOS->EmitIntValue(dwarf::DW_LNS_set_isa, 1);
160      MCOS->EmitULEB128IntValue(Isa);
161    }
162    if ((it->getFlags() ^ Flags) & DWARF2_FLAG_IS_STMT) {
163      Flags = it->getFlags();
164      MCOS->EmitIntValue(dwarf::DW_LNS_negate_stmt, 1);
165    }
166    if (it->getFlags() & DWARF2_FLAG_BASIC_BLOCK)
167      MCOS->EmitIntValue(dwarf::DW_LNS_set_basic_block, 1);
168    if (it->getFlags() & DWARF2_FLAG_PROLOGUE_END)
169      MCOS->EmitIntValue(dwarf::DW_LNS_set_prologue_end, 1);
170    if (it->getFlags() & DWARF2_FLAG_EPILOGUE_BEGIN)
171      MCOS->EmitIntValue(dwarf::DW_LNS_set_epilogue_begin, 1);
172
173    int64_t LineDelta = static_cast<int64_t>(it->getLine()) - LastLine;
174    MCSymbol *Label = it->getLabel();
175
176    // At this point we want to emit/create the sequence to encode the delta in
177    // line numbers and the increment of the address from the previous Label
178    // and the current Label.
179    const MCAsmInfo &asmInfo = MCOS->getContext().getAsmInfo();
180    MCOS->EmitDwarfAdvanceLineAddr(LineDelta, LastLabel, Label,
181                                   asmInfo.getPointerSize());
182
183    LastLine = it->getLine();
184    LastLabel = Label;
185  }
186
187  // Emit a DW_LNE_end_sequence for the end of the section.
188  // Using the pointer Section create a temporary label at the end of the
189  // section and use that and the LastLabel to compute the address delta
190  // and use INT64_MAX as the line delta which is the signal that this is
191  // actually a DW_LNE_end_sequence.
192
193  // Switch to the section to be able to create a symbol at its end.
194  MCOS->SwitchSection(Section);
195
196  MCContext &context = MCOS->getContext();
197  // Create a symbol at the end of the section.
198  MCSymbol *SectionEnd = context.CreateTempSymbol();
199  // Set the value of the symbol, as we are at the end of the section.
200  MCOS->EmitLabel(SectionEnd);
201
202  // Switch back the dwarf line section.
203  MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfLineSection());
204
205  const MCAsmInfo &asmInfo = MCOS->getContext().getAsmInfo();
206  MCOS->EmitDwarfAdvanceLineAddr(INT64_MAX, LastLabel, SectionEnd,
207                                 asmInfo.getPointerSize());
208}
209
210//
211// This emits the Dwarf file and the line tables.
212//
213const MCSymbol *MCDwarfFileTable::Emit(MCStreamer *MCOS) {
214  MCContext &context = MCOS->getContext();
215  // Switch to the section where the table will be emitted into.
216  MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfLineSection());
217
218  // Create a symbol at the beginning of this section.
219  MCSymbol *LineStartSym = context.CreateTempSymbol();
220  // Set the value of the symbol, as we are at the start of the section.
221  MCOS->EmitLabel(LineStartSym);
222
223  // Create a symbol for the end of the section (to be set when we get there).
224  MCSymbol *LineEndSym = context.CreateTempSymbol();
225
226  // The first 4 bytes is the total length of the information for this
227  // compilation unit (not including these 4 bytes for the length).
228  MCOS->EmitAbsValue(MakeStartMinusEndExpr(*MCOS, *LineStartSym, *LineEndSym,4),
229                     4);
230
231  // Next 2 bytes is the Version, which is Dwarf 2.
232  MCOS->EmitIntValue(2, 2);
233
234  // Create a symbol for the end of the prologue (to be set when we get there).
235  MCSymbol *ProEndSym = context.CreateTempSymbol(); // Lprologue_end
236
237  // Length of the prologue, is the next 4 bytes.  Which is the start of the
238  // section to the end of the prologue.  Not including the 4 bytes for the
239  // total length, the 2 bytes for the version, and these 4 bytes for the
240  // length of the prologue.
241  MCOS->EmitAbsValue(MakeStartMinusEndExpr(*MCOS, *LineStartSym, *ProEndSym,
242                                        (4 + 2 + 4)),
243                  4, 0);
244
245  // Parameters of the state machine, are next.
246  MCOS->EmitIntValue(DWARF2_LINE_MIN_INSN_LENGTH, 1);
247  MCOS->EmitIntValue(DWARF2_LINE_DEFAULT_IS_STMT, 1);
248  MCOS->EmitIntValue(DWARF2_LINE_BASE, 1);
249  MCOS->EmitIntValue(DWARF2_LINE_RANGE, 1);
250  MCOS->EmitIntValue(DWARF2_LINE_OPCODE_BASE, 1);
251
252  // Standard opcode lengths
253  MCOS->EmitIntValue(0, 1); // length of DW_LNS_copy
254  MCOS->EmitIntValue(1, 1); // length of DW_LNS_advance_pc
255  MCOS->EmitIntValue(1, 1); // length of DW_LNS_advance_line
256  MCOS->EmitIntValue(1, 1); // length of DW_LNS_set_file
257  MCOS->EmitIntValue(1, 1); // length of DW_LNS_set_column
258  MCOS->EmitIntValue(0, 1); // length of DW_LNS_negate_stmt
259  MCOS->EmitIntValue(0, 1); // length of DW_LNS_set_basic_block
260  MCOS->EmitIntValue(0, 1); // length of DW_LNS_const_add_pc
261  MCOS->EmitIntValue(1, 1); // length of DW_LNS_fixed_advance_pc
262  MCOS->EmitIntValue(0, 1); // length of DW_LNS_set_prologue_end
263  MCOS->EmitIntValue(0, 1); // length of DW_LNS_set_epilogue_begin
264  MCOS->EmitIntValue(1, 1); // DW_LNS_set_isa
265
266  // Put out the directory and file tables.
267
268  // First the directory table.
269  const std::vector<StringRef> &MCDwarfDirs =
270    context.getMCDwarfDirs();
271  for (unsigned i = 0; i < MCDwarfDirs.size(); i++) {
272    MCOS->EmitBytes(MCDwarfDirs[i], 0); // the DirectoryName
273    MCOS->EmitBytes(StringRef("\0", 1), 0); // the null term. of the string
274  }
275  MCOS->EmitIntValue(0, 1); // Terminate the directory list
276
277  // Second the file table.
278  const std::vector<MCDwarfFile *> &MCDwarfFiles =
279    MCOS->getContext().getMCDwarfFiles();
280  for (unsigned i = 1; i < MCDwarfFiles.size(); i++) {
281    MCOS->EmitBytes(MCDwarfFiles[i]->getName(), 0); // FileName
282    MCOS->EmitBytes(StringRef("\0", 1), 0); // the null term. of the string
283    // the Directory num
284    MCOS->EmitULEB128IntValue(MCDwarfFiles[i]->getDirIndex());
285    MCOS->EmitIntValue(0, 1); // last modification timestamp (always 0)
286    MCOS->EmitIntValue(0, 1); // filesize (always 0)
287  }
288  MCOS->EmitIntValue(0, 1); // Terminate the file list
289
290  // This is the end of the prologue, so set the value of the symbol at the
291  // end of the prologue (that was used in a previous expression).
292  MCOS->EmitLabel(ProEndSym);
293
294  // Put out the line tables.
295  const DenseMap<const MCSection *, MCLineSection *> &MCLineSections =
296    MCOS->getContext().getMCLineSections();
297  const std::vector<const MCSection *> &MCLineSectionOrder =
298    MCOS->getContext().getMCLineSectionOrder();
299  for (std::vector<const MCSection*>::const_iterator it =
300         MCLineSectionOrder.begin(), ie = MCLineSectionOrder.end(); it != ie;
301       ++it) {
302    const MCSection *Sec = *it;
303    const MCLineSection *Line = MCLineSections.lookup(Sec);
304    EmitDwarfLineTable(MCOS, Sec, Line);
305
306    // Now delete the MCLineSections that were created in MCLineEntry::Make()
307    // and used to emit the line table.
308    delete Line;
309  }
310
311  if (MCOS->getContext().getAsmInfo().getLinkerRequiresNonEmptyDwarfLines()
312      && MCLineSectionOrder.begin() == MCLineSectionOrder.end()) {
313    // The darwin9 linker has a bug (see PR8715). For for 32-bit architectures
314    // it requires:
315    // total_length >= prologue_length + 10
316    // We are 4 bytes short, since we have total_length = 51 and
317    // prologue_length = 45
318
319    // The regular end_sequence should be sufficient.
320    MCDwarfLineAddr::Emit(MCOS, INT64_MAX, 0);
321  }
322
323  // This is the end of the section, so set the value of the symbol at the end
324  // of this section (that was used in a previous expression).
325  MCOS->EmitLabel(LineEndSym);
326
327  return LineStartSym;
328}
329
330/// Utility function to write the encoding to an object writer.
331void MCDwarfLineAddr::Write(MCObjectWriter *OW, int64_t LineDelta,
332                            uint64_t AddrDelta) {
333  SmallString<256> Tmp;
334  raw_svector_ostream OS(Tmp);
335  MCDwarfLineAddr::Encode(LineDelta, AddrDelta, OS);
336  OW->WriteBytes(OS.str());
337}
338
339/// Utility function to emit the encoding to a streamer.
340void MCDwarfLineAddr::Emit(MCStreamer *MCOS, int64_t LineDelta,
341                           uint64_t AddrDelta) {
342  SmallString<256> Tmp;
343  raw_svector_ostream OS(Tmp);
344  MCDwarfLineAddr::Encode(LineDelta, AddrDelta, OS);
345  MCOS->EmitBytes(OS.str(), /*AddrSpace=*/0);
346}
347
348/// Utility function to encode a Dwarf pair of LineDelta and AddrDeltas.
349void MCDwarfLineAddr::Encode(int64_t LineDelta, uint64_t AddrDelta,
350                             raw_ostream &OS) {
351  uint64_t Temp, Opcode;
352  bool NeedCopy = false;
353
354  // Scale the address delta by the minimum instruction length.
355  AddrDelta = ScaleAddrDelta(AddrDelta);
356
357  // A LineDelta of INT64_MAX is a signal that this is actually a
358  // DW_LNE_end_sequence. We cannot use special opcodes here, since we want the
359  // end_sequence to emit the matrix entry.
360  if (LineDelta == INT64_MAX) {
361    if (AddrDelta == MAX_SPECIAL_ADDR_DELTA)
362      OS << char(dwarf::DW_LNS_const_add_pc);
363    else {
364      OS << char(dwarf::DW_LNS_advance_pc);
365      encodeULEB128(AddrDelta, OS);
366    }
367    OS << char(dwarf::DW_LNS_extended_op);
368    OS << char(1);
369    OS << char(dwarf::DW_LNE_end_sequence);
370    return;
371  }
372
373  // Bias the line delta by the base.
374  Temp = LineDelta - DWARF2_LINE_BASE;
375
376  // If the line increment is out of range of a special opcode, we must encode
377  // it with DW_LNS_advance_line.
378  if (Temp >= DWARF2_LINE_RANGE) {
379    OS << char(dwarf::DW_LNS_advance_line);
380    encodeSLEB128(LineDelta, OS);
381
382    LineDelta = 0;
383    Temp = 0 - DWARF2_LINE_BASE;
384    NeedCopy = true;
385  }
386
387  // Use DW_LNS_copy instead of a "line +0, addr +0" special opcode.
388  if (LineDelta == 0 && AddrDelta == 0) {
389    OS << char(dwarf::DW_LNS_copy);
390    return;
391  }
392
393  // Bias the opcode by the special opcode base.
394  Temp += DWARF2_LINE_OPCODE_BASE;
395
396  // Avoid overflow when addr_delta is large.
397  if (AddrDelta < 256 + MAX_SPECIAL_ADDR_DELTA) {
398    // Try using a special opcode.
399    Opcode = Temp + AddrDelta * DWARF2_LINE_RANGE;
400    if (Opcode <= 255) {
401      OS << char(Opcode);
402      return;
403    }
404
405    // Try using DW_LNS_const_add_pc followed by special op.
406    Opcode = Temp + (AddrDelta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
407    if (Opcode <= 255) {
408      OS << char(dwarf::DW_LNS_const_add_pc);
409      OS << char(Opcode);
410      return;
411    }
412  }
413
414  // Otherwise use DW_LNS_advance_pc.
415  OS << char(dwarf::DW_LNS_advance_pc);
416  encodeULEB128(AddrDelta, OS);
417
418  if (NeedCopy)
419    OS << char(dwarf::DW_LNS_copy);
420  else
421    OS << char(Temp);
422}
423
424void MCDwarfFile::print(raw_ostream &OS) const {
425  OS << '"' << getName() << '"';
426}
427
428#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
429void MCDwarfFile::dump() const {
430  print(dbgs());
431}
432#endif
433
434// Utility function to write a tuple for .debug_abbrev.
435static void EmitAbbrev(MCStreamer *MCOS, uint64_t Name, uint64_t Form) {
436  MCOS->EmitULEB128IntValue(Name);
437  MCOS->EmitULEB128IntValue(Form);
438}
439
440// When generating dwarf for assembly source files this emits
441// the data for .debug_abbrev section which contains three DIEs.
442static void EmitGenDwarfAbbrev(MCStreamer *MCOS) {
443  MCContext &context = MCOS->getContext();
444  MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfAbbrevSection());
445
446  // DW_TAG_compile_unit DIE abbrev (1).
447  MCOS->EmitULEB128IntValue(1);
448  MCOS->EmitULEB128IntValue(dwarf::DW_TAG_compile_unit);
449  MCOS->EmitIntValue(dwarf::DW_CHILDREN_yes, 1);
450  EmitAbbrev(MCOS, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4);
451  EmitAbbrev(MCOS, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr);
452  EmitAbbrev(MCOS, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr);
453  EmitAbbrev(MCOS, dwarf::DW_AT_name, dwarf::DW_FORM_string);
454  EmitAbbrev(MCOS, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string);
455  StringRef DwarfDebugFlags = context.getDwarfDebugFlags();
456  if (!DwarfDebugFlags.empty())
457    EmitAbbrev(MCOS, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string);
458  EmitAbbrev(MCOS, dwarf::DW_AT_producer, dwarf::DW_FORM_string);
459  EmitAbbrev(MCOS, dwarf::DW_AT_language, dwarf::DW_FORM_data2);
460  EmitAbbrev(MCOS, 0, 0);
461
462  // DW_TAG_label DIE abbrev (2).
463  MCOS->EmitULEB128IntValue(2);
464  MCOS->EmitULEB128IntValue(dwarf::DW_TAG_label);
465  MCOS->EmitIntValue(dwarf::DW_CHILDREN_yes, 1);
466  EmitAbbrev(MCOS, dwarf::DW_AT_name, dwarf::DW_FORM_string);
467  EmitAbbrev(MCOS, dwarf::DW_AT_decl_file, dwarf::DW_FORM_data4);
468  EmitAbbrev(MCOS, dwarf::DW_AT_decl_line, dwarf::DW_FORM_data4);
469  EmitAbbrev(MCOS, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr);
470  EmitAbbrev(MCOS, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag);
471  EmitAbbrev(MCOS, 0, 0);
472
473  // DW_TAG_unspecified_parameters DIE abbrev (3).
474  MCOS->EmitULEB128IntValue(3);
475  MCOS->EmitULEB128IntValue(dwarf::DW_TAG_unspecified_parameters);
476  MCOS->EmitIntValue(dwarf::DW_CHILDREN_no, 1);
477  EmitAbbrev(MCOS, 0, 0);
478
479  // Terminate the abbreviations for this compilation unit.
480  MCOS->EmitIntValue(0, 1);
481}
482
483// When generating dwarf for assembly source files this emits the data for
484// .debug_aranges section.  Which contains a header and a table of pairs of
485// PointerSize'ed values for the address and size of section(s) with line table
486// entries (just the default .text in our case) and a terminating pair of zeros.
487static void EmitGenDwarfAranges(MCStreamer *MCOS,
488                                const MCSymbol *InfoSectionSymbol) {
489  MCContext &context = MCOS->getContext();
490
491  // Create a symbol at the end of the section that we are creating the dwarf
492  // debugging info to use later in here as part of the expression to calculate
493  // the size of the section for the table.
494  MCOS->SwitchSection(context.getGenDwarfSection());
495  MCSymbol *SectionEndSym = context.CreateTempSymbol();
496  MCOS->EmitLabel(SectionEndSym);
497  context.setGenDwarfSectionEndSym(SectionEndSym);
498
499  MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfARangesSection());
500
501  // This will be the length of the .debug_aranges section, first account for
502  // the size of each item in the header (see below where we emit these items).
503  int Length = 4 + 2 + 4 + 1 + 1;
504
505  // Figure the padding after the header before the table of address and size
506  // pairs who's values are PointerSize'ed.
507  const MCAsmInfo &asmInfo = context.getAsmInfo();
508  int AddrSize = asmInfo.getPointerSize();
509  int Pad = 2 * AddrSize - (Length & (2 * AddrSize - 1));
510  if (Pad == 2 * AddrSize)
511    Pad = 0;
512  Length += Pad;
513
514  // Add the size of the pair of PointerSize'ed values for the address and size
515  // of the one default .text section we have in the table.
516  Length += 2 * AddrSize;
517  // And the pair of terminating zeros.
518  Length += 2 * AddrSize;
519
520
521  // Emit the header for this section.
522  // The 4 byte length not including the 4 byte value for the length.
523  MCOS->EmitIntValue(Length - 4, 4);
524  // The 2 byte version, which is 2.
525  MCOS->EmitIntValue(2, 2);
526  // The 4 byte offset to the compile unit in the .debug_info from the start
527  // of the .debug_info.
528  if (InfoSectionSymbol)
529    MCOS->EmitSymbolValue(InfoSectionSymbol, 4);
530  else
531    MCOS->EmitIntValue(0, 4);
532  // The 1 byte size of an address.
533  MCOS->EmitIntValue(AddrSize, 1);
534  // The 1 byte size of a segment descriptor, we use a value of zero.
535  MCOS->EmitIntValue(0, 1);
536  // Align the header with the padding if needed, before we put out the table.
537  for(int i = 0; i < Pad; i++)
538    MCOS->EmitIntValue(0, 1);
539
540  // Now emit the table of pairs of PointerSize'ed values for the section(s)
541  // address and size, in our case just the one default .text section.
542  const MCExpr *Addr = MCSymbolRefExpr::Create(
543    context.getGenDwarfSectionStartSym(), MCSymbolRefExpr::VK_None, context);
544  const MCExpr *Size = MakeStartMinusEndExpr(*MCOS,
545    *context.getGenDwarfSectionStartSym(), *SectionEndSym, 0);
546  MCOS->EmitAbsValue(Addr, AddrSize);
547  MCOS->EmitAbsValue(Size, AddrSize);
548
549  // And finally the pair of terminating zeros.
550  MCOS->EmitIntValue(0, AddrSize);
551  MCOS->EmitIntValue(0, AddrSize);
552}
553
554// When generating dwarf for assembly source files this emits the data for
555// .debug_info section which contains three parts.  The header, the compile_unit
556// DIE and a list of label DIEs.
557static void EmitGenDwarfInfo(MCStreamer *MCOS,
558                             const MCSymbol *AbbrevSectionSymbol,
559                             const MCSymbol *LineSectionSymbol) {
560  MCContext &context = MCOS->getContext();
561
562  MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfInfoSection());
563
564  // Create a symbol at the start and end of this section used in here for the
565  // expression to calculate the length in the header.
566  MCSymbol *InfoStart = context.CreateTempSymbol();
567  MCOS->EmitLabel(InfoStart);
568  MCSymbol *InfoEnd = context.CreateTempSymbol();
569
570  // First part: the header.
571
572  // The 4 byte total length of the information for this compilation unit, not
573  // including these 4 bytes.
574  const MCExpr *Length = MakeStartMinusEndExpr(*MCOS, *InfoStart, *InfoEnd, 4);
575  MCOS->EmitAbsValue(Length, 4);
576
577  // The 2 byte DWARF version, which is 2.
578  MCOS->EmitIntValue(2, 2);
579
580  // The 4 byte offset to the debug abbrevs from the start of the .debug_abbrev,
581  // it is at the start of that section so this is zero.
582  if (AbbrevSectionSymbol) {
583    MCOS->EmitSymbolValue(AbbrevSectionSymbol, 4);
584  } else {
585    MCOS->EmitIntValue(0, 4);
586  }
587
588  const MCAsmInfo &asmInfo = context.getAsmInfo();
589  int AddrSize = asmInfo.getPointerSize();
590  // The 1 byte size of an address.
591  MCOS->EmitIntValue(AddrSize, 1);
592
593  // Second part: the compile_unit DIE.
594
595  // The DW_TAG_compile_unit DIE abbrev (1).
596  MCOS->EmitULEB128IntValue(1);
597
598  // DW_AT_stmt_list, a 4 byte offset from the start of the .debug_line section,
599  // which is at the start of that section so this is zero.
600  if (LineSectionSymbol) {
601    MCOS->EmitSymbolValue(LineSectionSymbol, 4);
602  } else {
603    MCOS->EmitIntValue(0, 4);
604  }
605
606  // AT_low_pc, the first address of the default .text section.
607  const MCExpr *Start = MCSymbolRefExpr::Create(
608    context.getGenDwarfSectionStartSym(), MCSymbolRefExpr::VK_None, context);
609  MCOS->EmitAbsValue(Start, AddrSize);
610
611  // AT_high_pc, the last address of the default .text section.
612  const MCExpr *End = MCSymbolRefExpr::Create(
613    context.getGenDwarfSectionEndSym(), MCSymbolRefExpr::VK_None, context);
614  MCOS->EmitAbsValue(End, AddrSize);
615
616  // AT_name, the name of the source file.  Reconstruct from the first directory
617  // and file table entries.
618  const std::vector<StringRef> &MCDwarfDirs =
619    context.getMCDwarfDirs();
620  if (MCDwarfDirs.size() > 0) {
621    MCOS->EmitBytes(MCDwarfDirs[0], 0);
622    MCOS->EmitBytes("/", 0);
623  }
624  const std::vector<MCDwarfFile *> &MCDwarfFiles =
625    MCOS->getContext().getMCDwarfFiles();
626  MCOS->EmitBytes(MCDwarfFiles[1]->getName(), 0);
627  MCOS->EmitIntValue(0, 1); // NULL byte to terminate the string.
628
629  // AT_comp_dir, the working directory the assembly was done in.
630  llvm::sys::Path CWD = llvm::sys::Path::GetCurrentDirectory();
631  MCOS->EmitBytes(StringRef(CWD.c_str()), 0);
632  MCOS->EmitIntValue(0, 1); // NULL byte to terminate the string.
633
634  // AT_APPLE_flags, the command line arguments of the assembler tool.
635  StringRef DwarfDebugFlags = context.getDwarfDebugFlags();
636  if (!DwarfDebugFlags.empty()){
637    MCOS->EmitBytes(DwarfDebugFlags, 0);
638    MCOS->EmitIntValue(0, 1); // NULL byte to terminate the string.
639  }
640
641  // AT_producer, the version of the assembler tool.
642  MCOS->EmitBytes(StringRef("llvm-mc (based on LLVM "), 0);
643  MCOS->EmitBytes(StringRef(PACKAGE_VERSION), 0);
644  MCOS->EmitBytes(StringRef(")"), 0);
645  MCOS->EmitIntValue(0, 1); // NULL byte to terminate the string.
646
647  // AT_language, a 4 byte value.  We use DW_LANG_Mips_Assembler as the dwarf2
648  // draft has no standard code for assembler.
649  MCOS->EmitIntValue(dwarf::DW_LANG_Mips_Assembler, 2);
650
651  // Third part: the list of label DIEs.
652
653  // Loop on saved info for dwarf labels and create the DIEs for them.
654  const std::vector<const MCGenDwarfLabelEntry *> &Entries =
655    MCOS->getContext().getMCGenDwarfLabelEntries();
656  for (std::vector<const MCGenDwarfLabelEntry *>::const_iterator it =
657       Entries.begin(), ie = Entries.end(); it != ie;
658       ++it) {
659    const MCGenDwarfLabelEntry *Entry = *it;
660
661    // The DW_TAG_label DIE abbrev (2).
662    MCOS->EmitULEB128IntValue(2);
663
664    // AT_name, of the label without any leading underbar.
665    MCOS->EmitBytes(Entry->getName(), 0);
666    MCOS->EmitIntValue(0, 1); // NULL byte to terminate the string.
667
668    // AT_decl_file, index into the file table.
669    MCOS->EmitIntValue(Entry->getFileNumber(), 4);
670
671    // AT_decl_line, source line number.
672    MCOS->EmitIntValue(Entry->getLineNumber(), 4);
673
674    // AT_low_pc, start address of the label.
675    const MCExpr *AT_low_pc = MCSymbolRefExpr::Create(Entry->getLabel(),
676                                             MCSymbolRefExpr::VK_None, context);
677    MCOS->EmitAbsValue(AT_low_pc, AddrSize);
678
679    // DW_AT_prototyped, a one byte flag value of 0 saying we have no prototype.
680    MCOS->EmitIntValue(0, 1);
681
682    // The DW_TAG_unspecified_parameters DIE abbrev (3).
683    MCOS->EmitULEB128IntValue(3);
684
685    // Add the NULL DIE terminating the DW_TAG_unspecified_parameters DIE's.
686    MCOS->EmitIntValue(0, 1);
687  }
688  // Deallocate the MCGenDwarfLabelEntry classes that saved away the info
689  // for the dwarf labels.
690  for (std::vector<const MCGenDwarfLabelEntry *>::const_iterator it =
691       Entries.begin(), ie = Entries.end(); it != ie;
692       ++it) {
693    const MCGenDwarfLabelEntry *Entry = *it;
694    delete Entry;
695  }
696
697  // Add the NULL DIE terminating the Compile Unit DIE's.
698  MCOS->EmitIntValue(0, 1);
699
700  // Now set the value of the symbol at the end of the info section.
701  MCOS->EmitLabel(InfoEnd);
702}
703
704//
705// When generating dwarf for assembly source files this emits the Dwarf
706// sections.
707//
708void MCGenDwarfInfo::Emit(MCStreamer *MCOS, const MCSymbol *LineSectionSymbol) {
709  // Create the dwarf sections in this order (.debug_line already created).
710  MCContext &context = MCOS->getContext();
711  const MCAsmInfo &AsmInfo = context.getAsmInfo();
712  bool CreateDwarfSectionSymbols =
713      AsmInfo.doesDwarfUseRelocationsAcrossSections();
714  if (!CreateDwarfSectionSymbols)
715    LineSectionSymbol = NULL;
716  MCSymbol *AbbrevSectionSymbol = NULL;
717  MCSymbol *InfoSectionSymbol = NULL;
718  MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfInfoSection());
719  if (CreateDwarfSectionSymbols) {
720    InfoSectionSymbol = context.CreateTempSymbol();
721    MCOS->EmitLabel(InfoSectionSymbol);
722  }
723  MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfAbbrevSection());
724  if (CreateDwarfSectionSymbols) {
725    AbbrevSectionSymbol = context.CreateTempSymbol();
726    MCOS->EmitLabel(AbbrevSectionSymbol);
727  }
728  MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfARangesSection());
729
730  // If there are no line table entries then do not emit any section contents.
731  if (context.getMCLineSections().empty())
732    return;
733
734  // Output the data for .debug_aranges section.
735  EmitGenDwarfAranges(MCOS, InfoSectionSymbol);
736
737  // Output the data for .debug_abbrev section.
738  EmitGenDwarfAbbrev(MCOS);
739
740  // Output the data for .debug_info section.
741  EmitGenDwarfInfo(MCOS, AbbrevSectionSymbol, LineSectionSymbol);
742}
743
744//
745// When generating dwarf for assembly source files this is called when symbol
746// for a label is created.  If this symbol is not a temporary and is in the
747// section that dwarf is being generated for, save the needed info to create
748// a dwarf label.
749//
750void MCGenDwarfLabelEntry::Make(MCSymbol *Symbol, MCStreamer *MCOS,
751                                     SourceMgr &SrcMgr, SMLoc &Loc) {
752  // We won't create dwarf labels for temporary symbols or symbols not in
753  // the default text.
754  if (Symbol->isTemporary())
755    return;
756  MCContext &context = MCOS->getContext();
757  if (context.getGenDwarfSection() != MCOS->getCurrentSection())
758    return;
759
760  // The dwarf label's name does not have the symbol name's leading
761  // underbar if any.
762  StringRef Name = Symbol->getName();
763  if (Name.startswith("_"))
764    Name = Name.substr(1, Name.size()-1);
765
766  // Get the dwarf file number to be used for the dwarf label.
767  unsigned FileNumber = context.getGenDwarfFileNumber();
768
769  // Finding the line number is the expensive part which is why we just don't
770  // pass it in as for some symbols we won't create a dwarf label.
771  int CurBuffer = SrcMgr.FindBufferContainingLoc(Loc);
772  unsigned LineNumber = SrcMgr.FindLineNumber(Loc, CurBuffer);
773
774  // We create a temporary symbol for use for the AT_high_pc and AT_low_pc
775  // values so that they don't have things like an ARM thumb bit from the
776  // original symbol. So when used they won't get a low bit set after
777  // relocation.
778  MCSymbol *Label = context.CreateTempSymbol();
779  MCOS->EmitLabel(Label);
780
781  // Create and entry for the info and add it to the other entries.
782  MCGenDwarfLabelEntry *Entry =
783    new MCGenDwarfLabelEntry(Name, FileNumber, LineNumber, Label);
784  MCOS->getContext().addMCGenDwarfLabelEntry(Entry);
785}
786
787static int getDataAlignmentFactor(MCStreamer &streamer) {
788  MCContext &context = streamer.getContext();
789  const MCAsmInfo &asmInfo = context.getAsmInfo();
790  int size = asmInfo.getPointerSize();
791  if (asmInfo.isStackGrowthDirectionUp())
792    return size;
793  else
794    return -size;
795}
796
797static unsigned getSizeForEncoding(MCStreamer &streamer,
798                                   unsigned symbolEncoding) {
799  MCContext &context = streamer.getContext();
800  unsigned format = symbolEncoding & 0x0f;
801  switch (format) {
802  default: llvm_unreachable("Unknown Encoding");
803  case dwarf::DW_EH_PE_absptr:
804  case dwarf::DW_EH_PE_signed:
805    return context.getAsmInfo().getPointerSize();
806  case dwarf::DW_EH_PE_udata2:
807  case dwarf::DW_EH_PE_sdata2:
808    return 2;
809  case dwarf::DW_EH_PE_udata4:
810  case dwarf::DW_EH_PE_sdata4:
811    return 4;
812  case dwarf::DW_EH_PE_udata8:
813  case dwarf::DW_EH_PE_sdata8:
814    return 8;
815  }
816}
817
818static void EmitSymbol(MCStreamer &streamer, const MCSymbol &symbol,
819                       unsigned symbolEncoding, const char *comment = 0) {
820  MCContext &context = streamer.getContext();
821  const MCAsmInfo &asmInfo = context.getAsmInfo();
822  const MCExpr *v = asmInfo.getExprForFDESymbol(&symbol,
823                                                symbolEncoding,
824                                                streamer);
825  unsigned size = getSizeForEncoding(streamer, symbolEncoding);
826  if (streamer.isVerboseAsm() && comment) streamer.AddComment(comment);
827  streamer.EmitAbsValue(v, size);
828}
829
830static void EmitPersonality(MCStreamer &streamer, const MCSymbol &symbol,
831                            unsigned symbolEncoding) {
832  MCContext &context = streamer.getContext();
833  const MCAsmInfo &asmInfo = context.getAsmInfo();
834  const MCExpr *v = asmInfo.getExprForPersonalitySymbol(&symbol,
835                                                        symbolEncoding,
836                                                        streamer);
837  unsigned size = getSizeForEncoding(streamer, symbolEncoding);
838  streamer.EmitValue(v, size);
839}
840
841static const MachineLocation TranslateMachineLocation(
842                                                  const MCRegisterInfo &MRI,
843                                                  const MachineLocation &Loc) {
844  unsigned Reg = Loc.getReg() == MachineLocation::VirtualFP ?
845    MachineLocation::VirtualFP :
846    unsigned(MRI.getDwarfRegNum(Loc.getReg(), true));
847  const MachineLocation &NewLoc = Loc.isReg() ?
848    MachineLocation(Reg) : MachineLocation(Reg, Loc.getOffset());
849  return NewLoc;
850}
851
852namespace {
853  class FrameEmitterImpl {
854    int CFAOffset;
855    int CIENum;
856    bool UsingCFI;
857    bool IsEH;
858    const MCSymbol *SectionStart;
859  public:
860    FrameEmitterImpl(bool usingCFI, bool isEH)
861      : CFAOffset(0), CIENum(0), UsingCFI(usingCFI), IsEH(isEH),
862        SectionStart(0) {}
863
864    void setSectionStart(const MCSymbol *Label) { SectionStart = Label; }
865
866    /// EmitCompactUnwind - Emit the unwind information in a compact way. If
867    /// we're successful, return 'true'. Otherwise, return 'false' and it will
868    /// emit the normal CIE and FDE.
869    bool EmitCompactUnwind(MCStreamer &streamer,
870                           const MCDwarfFrameInfo &frame);
871
872    const MCSymbol &EmitCIE(MCStreamer &streamer,
873                            const MCSymbol *personality,
874                            unsigned personalityEncoding,
875                            const MCSymbol *lsda,
876                            bool IsSignalFrame,
877                            unsigned lsdaEncoding);
878    MCSymbol *EmitFDE(MCStreamer &streamer,
879                      const MCSymbol &cieStart,
880                      const MCDwarfFrameInfo &frame);
881    void EmitCFIInstructions(MCStreamer &streamer,
882                             const std::vector<MCCFIInstruction> &Instrs,
883                             MCSymbol *BaseLabel);
884    void EmitCFIInstruction(MCStreamer &Streamer,
885                            const MCCFIInstruction &Instr);
886  };
887
888} // end anonymous namespace
889
890static void EmitEncodingByte(MCStreamer &Streamer, unsigned Encoding,
891                             StringRef Prefix) {
892  if (Streamer.isVerboseAsm()) {
893    const char *EncStr;
894    switch (Encoding) {
895    default: EncStr = "<unknown encoding>"; break;
896    case dwarf::DW_EH_PE_absptr: EncStr = "absptr"; break;
897    case dwarf::DW_EH_PE_omit:   EncStr = "omit"; break;
898    case dwarf::DW_EH_PE_pcrel:  EncStr = "pcrel"; break;
899    case dwarf::DW_EH_PE_udata4: EncStr = "udata4"; break;
900    case dwarf::DW_EH_PE_udata8: EncStr = "udata8"; break;
901    case dwarf::DW_EH_PE_sdata4: EncStr = "sdata4"; break;
902    case dwarf::DW_EH_PE_sdata8: EncStr = "sdata8"; break;
903    case dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_udata4:
904      EncStr = "pcrel udata4";
905      break;
906    case dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4:
907      EncStr = "pcrel sdata4";
908      break;
909    case dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_udata8:
910      EncStr = "pcrel udata8";
911      break;
912    case dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata8:
913      EncStr = "screl sdata8";
914      break;
915    case dwarf::DW_EH_PE_indirect |dwarf::DW_EH_PE_pcrel|dwarf::DW_EH_PE_udata4:
916      EncStr = "indirect pcrel udata4";
917      break;
918    case dwarf::DW_EH_PE_indirect |dwarf::DW_EH_PE_pcrel|dwarf::DW_EH_PE_sdata4:
919      EncStr = "indirect pcrel sdata4";
920      break;
921    case dwarf::DW_EH_PE_indirect |dwarf::DW_EH_PE_pcrel|dwarf::DW_EH_PE_udata8:
922      EncStr = "indirect pcrel udata8";
923      break;
924    case dwarf::DW_EH_PE_indirect |dwarf::DW_EH_PE_pcrel|dwarf::DW_EH_PE_sdata8:
925      EncStr = "indirect pcrel sdata8";
926      break;
927    }
928
929    Streamer.AddComment(Twine(Prefix) + " = " + EncStr);
930  }
931
932  Streamer.EmitIntValue(Encoding, 1);
933}
934
935void FrameEmitterImpl::EmitCFIInstruction(MCStreamer &Streamer,
936                                          const MCCFIInstruction &Instr) {
937  int dataAlignmentFactor = getDataAlignmentFactor(Streamer);
938  bool VerboseAsm = Streamer.isVerboseAsm();
939
940  switch (Instr.getOperation()) {
941  case MCCFIInstruction::OpRegister: {
942    unsigned Reg1 = Instr.getRegister();
943    unsigned Reg2 = Instr.getRegister2();
944    if (VerboseAsm) {
945      Streamer.AddComment("DW_CFA_register");
946      Streamer.AddComment(Twine("Reg1 ") + Twine(Reg1));
947      Streamer.AddComment(Twine("Reg2 ") + Twine(Reg2));
948    }
949    Streamer.EmitIntValue(dwarf::DW_CFA_register, 1);
950    Streamer.EmitULEB128IntValue(Reg1);
951    Streamer.EmitULEB128IntValue(Reg2);
952    return;
953  }
954  case MCCFIInstruction::OpUndefined: {
955    unsigned Reg = Instr.getRegister();
956    if (VerboseAsm) {
957      Streamer.AddComment("DW_CFA_undefined");
958      Streamer.AddComment(Twine("Reg ") + Twine(Reg));
959    }
960    Streamer.EmitIntValue(dwarf::DW_CFA_undefined, 1);
961    Streamer.EmitULEB128IntValue(Reg);
962    return;
963  }
964  case MCCFIInstruction::OpAdjustCfaOffset:
965  case MCCFIInstruction::OpDefCfaOffset: {
966    const bool IsRelative =
967      Instr.getOperation() == MCCFIInstruction::OpAdjustCfaOffset;
968
969    if (VerboseAsm)
970      Streamer.AddComment("DW_CFA_def_cfa_offset");
971    Streamer.EmitIntValue(dwarf::DW_CFA_def_cfa_offset, 1);
972
973    if (IsRelative)
974      CFAOffset += Instr.getOffset();
975    else
976      CFAOffset = -Instr.getOffset();
977
978    if (VerboseAsm)
979      Streamer.AddComment(Twine("Offset " + Twine(CFAOffset)));
980    Streamer.EmitULEB128IntValue(CFAOffset);
981
982    return;
983  }
984  case MCCFIInstruction::OpDefCfa: {
985    if (VerboseAsm)
986      Streamer.AddComment("DW_CFA_def_cfa");
987    Streamer.EmitIntValue(dwarf::DW_CFA_def_cfa, 1);
988
989    if (VerboseAsm)
990      Streamer.AddComment(Twine("Reg ") + Twine(Instr.getRegister()));
991    Streamer.EmitULEB128IntValue(Instr.getRegister());
992
993    CFAOffset = -Instr.getOffset();
994
995    if (VerboseAsm)
996      Streamer.AddComment(Twine("Offset " + Twine(CFAOffset)));
997    Streamer.EmitULEB128IntValue(CFAOffset);
998
999    return;
1000  }
1001
1002  case MCCFIInstruction::OpDefCfaRegister: {
1003    if (VerboseAsm)
1004      Streamer.AddComment("DW_CFA_def_cfa_register");
1005    Streamer.EmitIntValue(dwarf::DW_CFA_def_cfa_register, 1);
1006
1007    if (VerboseAsm)
1008      Streamer.AddComment(Twine("Reg ") + Twine(Instr.getRegister()));
1009    Streamer.EmitULEB128IntValue(Instr.getRegister());
1010
1011    return;
1012  }
1013
1014  case MCCFIInstruction::OpOffset:
1015  case MCCFIInstruction::OpRelOffset: {
1016    const bool IsRelative =
1017      Instr.getOperation() == MCCFIInstruction::OpRelOffset;
1018
1019    unsigned Reg = Instr.getRegister();
1020    int Offset = Instr.getOffset();
1021    if (IsRelative)
1022      Offset -= CFAOffset;
1023    Offset = Offset / dataAlignmentFactor;
1024
1025    if (Offset < 0) {
1026      if (VerboseAsm) Streamer.AddComment("DW_CFA_offset_extended_sf");
1027      Streamer.EmitIntValue(dwarf::DW_CFA_offset_extended_sf, 1);
1028      if (VerboseAsm) Streamer.AddComment(Twine("Reg ") + Twine(Reg));
1029      Streamer.EmitULEB128IntValue(Reg);
1030      if (VerboseAsm) Streamer.AddComment(Twine("Offset ") + Twine(Offset));
1031      Streamer.EmitSLEB128IntValue(Offset);
1032    } else if (Reg < 64) {
1033      if (VerboseAsm) Streamer.AddComment(Twine("DW_CFA_offset + Reg(") +
1034                                          Twine(Reg) + ")");
1035      Streamer.EmitIntValue(dwarf::DW_CFA_offset + Reg, 1);
1036      if (VerboseAsm) Streamer.AddComment(Twine("Offset ") + Twine(Offset));
1037      Streamer.EmitULEB128IntValue(Offset);
1038    } else {
1039      if (VerboseAsm) Streamer.AddComment("DW_CFA_offset_extended");
1040      Streamer.EmitIntValue(dwarf::DW_CFA_offset_extended, 1);
1041      if (VerboseAsm) Streamer.AddComment(Twine("Reg ") + Twine(Reg));
1042      Streamer.EmitULEB128IntValue(Reg);
1043      if (VerboseAsm) Streamer.AddComment(Twine("Offset ") + Twine(Offset));
1044      Streamer.EmitULEB128IntValue(Offset);
1045    }
1046    return;
1047  }
1048  case MCCFIInstruction::OpRememberState:
1049    if (VerboseAsm) Streamer.AddComment("DW_CFA_remember_state");
1050    Streamer.EmitIntValue(dwarf::DW_CFA_remember_state, 1);
1051    return;
1052  case MCCFIInstruction::OpRestoreState:
1053    if (VerboseAsm) Streamer.AddComment("DW_CFA_restore_state");
1054    Streamer.EmitIntValue(dwarf::DW_CFA_restore_state, 1);
1055    return;
1056  case MCCFIInstruction::OpSameValue: {
1057    unsigned Reg = Instr.getRegister();
1058    if (VerboseAsm) Streamer.AddComment("DW_CFA_same_value");
1059    Streamer.EmitIntValue(dwarf::DW_CFA_same_value, 1);
1060    if (VerboseAsm) Streamer.AddComment(Twine("Reg ") + Twine(Reg));
1061    Streamer.EmitULEB128IntValue(Reg);
1062    return;
1063  }
1064  case MCCFIInstruction::OpRestore: {
1065    unsigned Reg = Instr.getRegister();
1066    if (VerboseAsm) {
1067      Streamer.AddComment("DW_CFA_restore");
1068      Streamer.AddComment(Twine("Reg ") + Twine(Reg));
1069    }
1070    Streamer.EmitIntValue(dwarf::DW_CFA_restore | Reg, 1);
1071    return;
1072  }
1073  case MCCFIInstruction::OpEscape:
1074    if (VerboseAsm) Streamer.AddComment("Escape bytes");
1075    Streamer.EmitBytes(Instr.getValues(), 0);
1076    return;
1077  }
1078  llvm_unreachable("Unhandled case in switch");
1079}
1080
1081/// EmitFrameMoves - Emit frame instructions to describe the layout of the
1082/// frame.
1083void FrameEmitterImpl::EmitCFIInstructions(MCStreamer &streamer,
1084                                    const std::vector<MCCFIInstruction> &Instrs,
1085                                           MCSymbol *BaseLabel) {
1086  for (unsigned i = 0, N = Instrs.size(); i < N; ++i) {
1087    const MCCFIInstruction &Instr = Instrs[i];
1088    MCSymbol *Label = Instr.getLabel();
1089    // Throw out move if the label is invalid.
1090    if (Label && !Label->isDefined()) continue; // Not emitted, in dead code.
1091
1092    // Advance row if new location.
1093    if (BaseLabel && Label) {
1094      MCSymbol *ThisSym = Label;
1095      if (ThisSym != BaseLabel) {
1096        if (streamer.isVerboseAsm()) streamer.AddComment("DW_CFA_advance_loc4");
1097        streamer.EmitDwarfAdvanceFrameAddr(BaseLabel, ThisSym);
1098        BaseLabel = ThisSym;
1099      }
1100    }
1101
1102    EmitCFIInstruction(streamer, Instr);
1103  }
1104}
1105
1106/// EmitCompactUnwind - Emit the unwind information in a compact way. If we're
1107/// successful, return 'true'. Otherwise, return 'false' and it will emit the
1108/// normal CIE and FDE.
1109bool FrameEmitterImpl::EmitCompactUnwind(MCStreamer &Streamer,
1110                                         const MCDwarfFrameInfo &Frame) {
1111  MCContext &Context = Streamer.getContext();
1112  const MCObjectFileInfo *MOFI = Context.getObjectFileInfo();
1113  bool VerboseAsm = Streamer.isVerboseAsm();
1114
1115  // range-start range-length  compact-unwind-enc personality-func   lsda
1116  //  _foo       LfooEnd-_foo  0x00000023          0                 0
1117  //  _bar       LbarEnd-_bar  0x00000025         __gxx_personality  except_tab1
1118  //
1119  //   .section __LD,__compact_unwind,regular,debug
1120  //
1121  //   # compact unwind for _foo
1122  //   .quad _foo
1123  //   .set L1,LfooEnd-_foo
1124  //   .long L1
1125  //   .long 0x01010001
1126  //   .quad 0
1127  //   .quad 0
1128  //
1129  //   # compact unwind for _bar
1130  //   .quad _bar
1131  //   .set L2,LbarEnd-_bar
1132  //   .long L2
1133  //   .long 0x01020011
1134  //   .quad __gxx_personality
1135  //   .quad except_tab1
1136
1137  uint32_t Encoding = Frame.CompactUnwindEncoding;
1138  if (!Encoding) return false;
1139
1140  // The encoding needs to know we have an LSDA.
1141  if (Frame.Lsda)
1142    Encoding |= 0x40000000;
1143
1144  Streamer.SwitchSection(MOFI->getCompactUnwindSection());
1145
1146  // Range Start
1147  unsigned FDEEncoding = MOFI->getFDEEncoding(UsingCFI);
1148  unsigned Size = getSizeForEncoding(Streamer, FDEEncoding);
1149  if (VerboseAsm) Streamer.AddComment("Range Start");
1150  Streamer.EmitSymbolValue(Frame.Function, Size);
1151
1152  // Range Length
1153  const MCExpr *Range = MakeStartMinusEndExpr(Streamer, *Frame.Begin,
1154                                              *Frame.End, 0);
1155  if (VerboseAsm) Streamer.AddComment("Range Length");
1156  Streamer.EmitAbsValue(Range, 4);
1157
1158  // Compact Encoding
1159  Size = getSizeForEncoding(Streamer, dwarf::DW_EH_PE_udata4);
1160  if (VerboseAsm) Streamer.AddComment("Compact Unwind Encoding: 0x" +
1161                                      Twine::utohexstr(Encoding));
1162  Streamer.EmitIntValue(Encoding, Size);
1163
1164
1165  // Personality Function
1166  Size = getSizeForEncoding(Streamer, dwarf::DW_EH_PE_absptr);
1167  if (VerboseAsm) Streamer.AddComment("Personality Function");
1168  if (Frame.Personality)
1169    Streamer.EmitSymbolValue(Frame.Personality, Size);
1170  else
1171    Streamer.EmitIntValue(0, Size); // No personality fn
1172
1173  // LSDA
1174  Size = getSizeForEncoding(Streamer, Frame.LsdaEncoding);
1175  if (VerboseAsm) Streamer.AddComment("LSDA");
1176  if (Frame.Lsda)
1177    Streamer.EmitSymbolValue(Frame.Lsda, Size);
1178  else
1179    Streamer.EmitIntValue(0, Size); // No LSDA
1180
1181  return true;
1182}
1183
1184const MCSymbol &FrameEmitterImpl::EmitCIE(MCStreamer &streamer,
1185                                          const MCSymbol *personality,
1186                                          unsigned personalityEncoding,
1187                                          const MCSymbol *lsda,
1188                                          bool IsSignalFrame,
1189                                          unsigned lsdaEncoding) {
1190  MCContext &context = streamer.getContext();
1191  const MCRegisterInfo &MRI = context.getRegisterInfo();
1192  const MCObjectFileInfo *MOFI = context.getObjectFileInfo();
1193  bool verboseAsm = streamer.isVerboseAsm();
1194
1195  MCSymbol *sectionStart;
1196  if (MOFI->isFunctionEHFrameSymbolPrivate() || !IsEH)
1197    sectionStart = context.CreateTempSymbol();
1198  else
1199    sectionStart = context.GetOrCreateSymbol(Twine("EH_frame") + Twine(CIENum));
1200
1201  streamer.EmitLabel(sectionStart);
1202  CIENum++;
1203
1204  MCSymbol *sectionEnd = context.CreateTempSymbol();
1205
1206  // Length
1207  const MCExpr *Length = MakeStartMinusEndExpr(streamer, *sectionStart,
1208                                               *sectionEnd, 4);
1209  if (verboseAsm) streamer.AddComment("CIE Length");
1210  streamer.EmitAbsValue(Length, 4);
1211
1212  // CIE ID
1213  unsigned CIE_ID = IsEH ? 0 : -1;
1214  if (verboseAsm) streamer.AddComment("CIE ID Tag");
1215  streamer.EmitIntValue(CIE_ID, 4);
1216
1217  // Version
1218  if (verboseAsm) streamer.AddComment("DW_CIE_VERSION");
1219  streamer.EmitIntValue(dwarf::DW_CIE_VERSION, 1);
1220
1221  // Augmentation String
1222  SmallString<8> Augmentation;
1223  if (IsEH) {
1224    if (verboseAsm) streamer.AddComment("CIE Augmentation");
1225    Augmentation += "z";
1226    if (personality)
1227      Augmentation += "P";
1228    if (lsda)
1229      Augmentation += "L";
1230    Augmentation += "R";
1231    if (IsSignalFrame)
1232      Augmentation += "S";
1233    streamer.EmitBytes(Augmentation.str(), 0);
1234  }
1235  streamer.EmitIntValue(0, 1);
1236
1237  // Code Alignment Factor
1238  if (verboseAsm) streamer.AddComment("CIE Code Alignment Factor");
1239  streamer.EmitULEB128IntValue(1);
1240
1241  // Data Alignment Factor
1242  if (verboseAsm) streamer.AddComment("CIE Data Alignment Factor");
1243  streamer.EmitSLEB128IntValue(getDataAlignmentFactor(streamer));
1244
1245  // Return Address Register
1246  if (verboseAsm) streamer.AddComment("CIE Return Address Column");
1247  streamer.EmitULEB128IntValue(MRI.getDwarfRegNum(MRI.getRARegister(), true));
1248
1249  // Augmentation Data Length (optional)
1250
1251  unsigned augmentationLength = 0;
1252  if (IsEH) {
1253    if (personality) {
1254      // Personality Encoding
1255      augmentationLength += 1;
1256      // Personality
1257      augmentationLength += getSizeForEncoding(streamer, personalityEncoding);
1258    }
1259    if (lsda)
1260      augmentationLength += 1;
1261    // Encoding of the FDE pointers
1262    augmentationLength += 1;
1263
1264    if (verboseAsm) streamer.AddComment("Augmentation Size");
1265    streamer.EmitULEB128IntValue(augmentationLength);
1266
1267    // Augmentation Data (optional)
1268    if (personality) {
1269      // Personality Encoding
1270      EmitEncodingByte(streamer, personalityEncoding,
1271                       "Personality Encoding");
1272      // Personality
1273      if (verboseAsm) streamer.AddComment("Personality");
1274      EmitPersonality(streamer, *personality, personalityEncoding);
1275    }
1276
1277    if (lsda)
1278      EmitEncodingByte(streamer, lsdaEncoding, "LSDA Encoding");
1279
1280    // Encoding of the FDE pointers
1281    EmitEncodingByte(streamer, MOFI->getFDEEncoding(UsingCFI),
1282                     "FDE Encoding");
1283  }
1284
1285  // Initial Instructions
1286
1287  const MCAsmInfo &MAI = context.getAsmInfo();
1288  const std::vector<MachineMove> &Moves = MAI.getInitialFrameState();
1289  std::vector<MCCFIInstruction> Instructions;
1290
1291  for (int i = 0, n = Moves.size(); i != n; ++i) {
1292    MCSymbol *Label = Moves[i].getLabel();
1293    const MachineLocation &Dst =
1294      TranslateMachineLocation(MRI, Moves[i].getDestination());
1295    const MachineLocation &Src =
1296      TranslateMachineLocation(MRI, Moves[i].getSource());
1297
1298    if (Dst.isReg()) {
1299      assert(Dst.getReg() == MachineLocation::VirtualFP);
1300      assert(!Src.isReg());
1301      MCCFIInstruction Inst =
1302        MCCFIInstruction::createDefCfa(Label, Src.getReg(), -Src.getOffset());
1303      Instructions.push_back(Inst);
1304    } else {
1305      assert(Src.isReg());
1306      unsigned Reg = Src.getReg();
1307      int Offset = Dst.getOffset();
1308      MCCFIInstruction Inst =
1309        MCCFIInstruction::createOffset(Label, Reg, Offset);
1310      Instructions.push_back(Inst);
1311    }
1312  }
1313
1314  EmitCFIInstructions(streamer, Instructions, NULL);
1315
1316  // Padding
1317  streamer.EmitValueToAlignment(IsEH
1318                                ? 4 : context.getAsmInfo().getPointerSize());
1319
1320  streamer.EmitLabel(sectionEnd);
1321  return *sectionStart;
1322}
1323
1324MCSymbol *FrameEmitterImpl::EmitFDE(MCStreamer &streamer,
1325                                    const MCSymbol &cieStart,
1326                                    const MCDwarfFrameInfo &frame) {
1327  MCContext &context = streamer.getContext();
1328  MCSymbol *fdeStart = context.CreateTempSymbol();
1329  MCSymbol *fdeEnd = context.CreateTempSymbol();
1330  const MCObjectFileInfo *MOFI = context.getObjectFileInfo();
1331  bool verboseAsm = streamer.isVerboseAsm();
1332
1333  if (IsEH && frame.Function && !MOFI->isFunctionEHFrameSymbolPrivate()) {
1334    MCSymbol *EHSym =
1335      context.GetOrCreateSymbol(frame.Function->getName() + Twine(".eh"));
1336    streamer.EmitEHSymAttributes(frame.Function, EHSym);
1337    streamer.EmitLabel(EHSym);
1338  }
1339
1340  // Length
1341  const MCExpr *Length = MakeStartMinusEndExpr(streamer, *fdeStart, *fdeEnd, 0);
1342  if (verboseAsm) streamer.AddComment("FDE Length");
1343  streamer.EmitAbsValue(Length, 4);
1344
1345  streamer.EmitLabel(fdeStart);
1346
1347  // CIE Pointer
1348  const MCAsmInfo &asmInfo = context.getAsmInfo();
1349  if (IsEH) {
1350    const MCExpr *offset = MakeStartMinusEndExpr(streamer, cieStart, *fdeStart,
1351                                                 0);
1352    if (verboseAsm) streamer.AddComment("FDE CIE Offset");
1353    streamer.EmitAbsValue(offset, 4);
1354  } else if (!asmInfo.doesDwarfUseRelocationsAcrossSections()) {
1355    const MCExpr *offset = MakeStartMinusEndExpr(streamer, *SectionStart,
1356                                                 cieStart, 0);
1357    streamer.EmitAbsValue(offset, 4);
1358  } else {
1359    streamer.EmitSymbolValue(&cieStart, 4);
1360  }
1361
1362  // PC Begin
1363  unsigned PCEncoding = IsEH ? MOFI->getFDEEncoding(UsingCFI)
1364                             : (unsigned)dwarf::DW_EH_PE_absptr;
1365  unsigned PCSize = getSizeForEncoding(streamer, PCEncoding);
1366  EmitSymbol(streamer, *frame.Begin, PCEncoding, "FDE initial location");
1367
1368  // PC Range
1369  const MCExpr *Range = MakeStartMinusEndExpr(streamer, *frame.Begin,
1370                                              *frame.End, 0);
1371  if (verboseAsm) streamer.AddComment("FDE address range");
1372  streamer.EmitAbsValue(Range, PCSize);
1373
1374  if (IsEH) {
1375    // Augmentation Data Length
1376    unsigned augmentationLength = 0;
1377
1378    if (frame.Lsda)
1379      augmentationLength += getSizeForEncoding(streamer, frame.LsdaEncoding);
1380
1381    if (verboseAsm) streamer.AddComment("Augmentation size");
1382    streamer.EmitULEB128IntValue(augmentationLength);
1383
1384    // Augmentation Data
1385    if (frame.Lsda)
1386      EmitSymbol(streamer, *frame.Lsda, frame.LsdaEncoding,
1387                 "Language Specific Data Area");
1388  }
1389
1390  // Call Frame Instructions
1391
1392  EmitCFIInstructions(streamer, frame.Instructions, frame.Begin);
1393
1394  // Padding
1395  streamer.EmitValueToAlignment(PCSize);
1396
1397  return fdeEnd;
1398}
1399
1400namespace {
1401  struct CIEKey {
1402    static const CIEKey getEmptyKey() { return CIEKey(0, 0, -1, false); }
1403    static const CIEKey getTombstoneKey() { return CIEKey(0, -1, 0, false); }
1404
1405    CIEKey(const MCSymbol* Personality_, unsigned PersonalityEncoding_,
1406           unsigned LsdaEncoding_, bool IsSignalFrame_) :
1407      Personality(Personality_), PersonalityEncoding(PersonalityEncoding_),
1408      LsdaEncoding(LsdaEncoding_), IsSignalFrame(IsSignalFrame_) {
1409    }
1410    const MCSymbol* Personality;
1411    unsigned PersonalityEncoding;
1412    unsigned LsdaEncoding;
1413    bool IsSignalFrame;
1414  };
1415}
1416
1417namespace llvm {
1418  template <>
1419  struct DenseMapInfo<CIEKey> {
1420    static CIEKey getEmptyKey() {
1421      return CIEKey::getEmptyKey();
1422    }
1423    static CIEKey getTombstoneKey() {
1424      return CIEKey::getTombstoneKey();
1425    }
1426    static unsigned getHashValue(const CIEKey &Key) {
1427      return static_cast<unsigned>(hash_combine(Key.Personality,
1428                                                Key.PersonalityEncoding,
1429                                                Key.LsdaEncoding,
1430                                                Key.IsSignalFrame));
1431    }
1432    static bool isEqual(const CIEKey &LHS,
1433                        const CIEKey &RHS) {
1434      return LHS.Personality == RHS.Personality &&
1435        LHS.PersonalityEncoding == RHS.PersonalityEncoding &&
1436        LHS.LsdaEncoding == RHS.LsdaEncoding &&
1437        LHS.IsSignalFrame == RHS.IsSignalFrame;
1438    }
1439  };
1440}
1441
1442void MCDwarfFrameEmitter::Emit(MCStreamer &Streamer,
1443                               bool UsingCFI,
1444                               bool IsEH) {
1445  MCContext &Context = Streamer.getContext();
1446  MCObjectFileInfo *MOFI =
1447    const_cast<MCObjectFileInfo*>(Context.getObjectFileInfo());
1448  FrameEmitterImpl Emitter(UsingCFI, IsEH);
1449  ArrayRef<MCDwarfFrameInfo> FrameArray = Streamer.getFrameInfos();
1450
1451  // Emit the compact unwind info if available.
1452  if (IsEH && MOFI->getCompactUnwindSection())
1453    for (unsigned i = 0, n = Streamer.getNumFrameInfos(); i < n; ++i) {
1454      const MCDwarfFrameInfo &Frame = Streamer.getFrameInfo(i);
1455      if (Frame.CompactUnwindEncoding)
1456        Emitter.EmitCompactUnwind(Streamer, Frame);
1457    }
1458
1459  const MCSection &Section = IsEH ? *MOFI->getEHFrameSection() :
1460                                    *MOFI->getDwarfFrameSection();
1461  Streamer.SwitchSection(&Section);
1462  MCSymbol *SectionStart = Context.CreateTempSymbol();
1463  Streamer.EmitLabel(SectionStart);
1464  Emitter.setSectionStart(SectionStart);
1465
1466  MCSymbol *FDEEnd = NULL;
1467  DenseMap<CIEKey, const MCSymbol*> CIEStarts;
1468
1469  const MCSymbol *DummyDebugKey = NULL;
1470  for (unsigned i = 0, n = FrameArray.size(); i < n; ++i) {
1471    const MCDwarfFrameInfo &Frame = FrameArray[i];
1472    CIEKey Key(Frame.Personality, Frame.PersonalityEncoding,
1473               Frame.LsdaEncoding, Frame.IsSignalFrame);
1474    const MCSymbol *&CIEStart = IsEH ? CIEStarts[Key] : DummyDebugKey;
1475    if (!CIEStart)
1476      CIEStart = &Emitter.EmitCIE(Streamer, Frame.Personality,
1477                                  Frame.PersonalityEncoding, Frame.Lsda,
1478                                  Frame.IsSignalFrame,
1479                                  Frame.LsdaEncoding);
1480
1481    FDEEnd = Emitter.EmitFDE(Streamer, *CIEStart, Frame);
1482
1483    if (i != n - 1)
1484      Streamer.EmitLabel(FDEEnd);
1485  }
1486
1487  Streamer.EmitValueToAlignment(Context.getAsmInfo().getPointerSize());
1488  if (FDEEnd)
1489    Streamer.EmitLabel(FDEEnd);
1490}
1491
1492void MCDwarfFrameEmitter::EmitAdvanceLoc(MCStreamer &Streamer,
1493                                         uint64_t AddrDelta) {
1494  SmallString<256> Tmp;
1495  raw_svector_ostream OS(Tmp);
1496  MCDwarfFrameEmitter::EncodeAdvanceLoc(AddrDelta, OS);
1497  Streamer.EmitBytes(OS.str(), /*AddrSpace=*/0);
1498}
1499
1500void MCDwarfFrameEmitter::EncodeAdvanceLoc(uint64_t AddrDelta,
1501                                           raw_ostream &OS) {
1502  // FIXME: Assumes the code alignment factor is 1.
1503  if (AddrDelta == 0) {
1504  } else if (isUIntN(6, AddrDelta)) {
1505    uint8_t Opcode = dwarf::DW_CFA_advance_loc | AddrDelta;
1506    OS << Opcode;
1507  } else if (isUInt<8>(AddrDelta)) {
1508    OS << uint8_t(dwarf::DW_CFA_advance_loc1);
1509    OS << uint8_t(AddrDelta);
1510  } else if (isUInt<16>(AddrDelta)) {
1511    // FIXME: check what is the correct behavior on a big endian machine.
1512    OS << uint8_t(dwarf::DW_CFA_advance_loc2);
1513    OS << uint8_t( AddrDelta       & 0xff);
1514    OS << uint8_t((AddrDelta >> 8) & 0xff);
1515  } else {
1516    // FIXME: check what is the correct behavior on a big endian machine.
1517    assert(isUInt<32>(AddrDelta));
1518    OS << uint8_t(dwarf::DW_CFA_advance_loc4);
1519    OS << uint8_t( AddrDelta        & 0xff);
1520    OS << uint8_t((AddrDelta >> 8)  & 0xff);
1521    OS << uint8_t((AddrDelta >> 16) & 0xff);
1522    OS << uint8_t((AddrDelta >> 24) & 0xff);
1523
1524  }
1525}
1526