blob: a7e83f617088cfa0d989ba35af97372eea5d61c6 [file] [log] [blame]
Kevin Enderbye5930f12010-07-28 20:55:35 +00001//===- 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"
Chandler Carruthed0881b2012-12-03 16:50:05 +000011#include "llvm/ADT/Hashing.h"
Benjamin Kramer502b9e12014-04-12 16:15:53 +000012#include "llvm/ADT/STLExtras.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000013#include "llvm/ADT/SmallString.h"
14#include "llvm/ADT/Twine.h"
15#include "llvm/Config/config.h"
Evan Cheng76792992011-07-20 05:58:47 +000016#include "llvm/MC/MCAsmInfo.h"
17#include "llvm/MC/MCContext.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000018#include "llvm/MC/MCExpr.h"
Evan Cheng76792992011-07-20 05:58:47 +000019#include "llvm/MC/MCObjectFileInfo.h"
Rafael Espindola4066e8d2014-05-12 14:28:48 +000020#include "llvm/MC/MCObjectStreamer.h"
Evan Cheng76792992011-07-20 05:58:47 +000021#include "llvm/MC/MCRegisterInfo.h"
Oliver Stannard8b273082014-06-19 15:52:37 +000022#include "llvm/MC/MCSection.h"
Kevin Enderbye46564a2010-09-30 16:52:03 +000023#include "llvm/MC/MCSymbol.h"
Kevin Enderbye5930f12010-07-28 20:55:35 +000024#include "llvm/Support/Debug.h"
Rafael Espindola85d91982010-12-28 18:36:23 +000025#include "llvm/Support/ErrorHandling.h"
Jim Grosbachbf387df2012-08-08 23:56:06 +000026#include "llvm/Support/LEB128.h"
Kevin Enderbye7739d42011-12-09 18:09:40 +000027#include "llvm/Support/Path.h"
28#include "llvm/Support/SourceMgr.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000029#include "llvm/Support/raw_ostream.h"
Kevin Enderbye5930f12010-07-28 20:55:35 +000030using namespace llvm;
31
Kevin Enderbye46564a2010-09-30 16:52:03 +000032// Given a special op, return the address skip amount (in units of
33// DWARF2_LINE_MIN_INSN_LENGTH.
34#define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
35
36// The maximum address skip amount that can be encoded with a special op.
Bill Wendlingc737ac12011-06-30 23:59:38 +000037#define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255)
Kevin Enderbye46564a2010-09-30 16:52:03 +000038
39// First special line opcode - leave room for the standard opcodes.
40// Note: If you want to change this, you'll have to update the
Jim Grosbachdc1e36e2012-05-11 01:41:30 +000041// "standard_opcode_lengths" table that is emitted in DwarfFileTable::Emit().
Bill Wendlingc737ac12011-06-30 23:59:38 +000042#define DWARF2_LINE_OPCODE_BASE 13
Kevin Enderbye46564a2010-09-30 16:52:03 +000043
44// Minimum line offset in a special line info. opcode. This value
45// was chosen to give a reasonable range of values.
Bill Wendlingc737ac12011-06-30 23:59:38 +000046#define DWARF2_LINE_BASE -5
Kevin Enderbye46564a2010-09-30 16:52:03 +000047
48// Range of line offsets in a special line info. opcode.
Bill Wendlingc737ac12011-06-30 23:59:38 +000049#define DWARF2_LINE_RANGE 14
Kevin Enderbye46564a2010-09-30 16:52:03 +000050
Ulrich Weigand32d725b2013-06-12 14:46:54 +000051static inline uint64_t ScaleAddrDelta(MCContext &Context, uint64_t AddrDelta) {
Bill Wendlingbc07a892013-06-18 07:20:20 +000052 unsigned MinInsnLength = Context.getAsmInfo()->getMinInstAlignment();
Ulrich Weigand32d725b2013-06-12 14:46:54 +000053 if (MinInsnLength == 1)
Kevin Enderbye46564a2010-09-30 16:52:03 +000054 return AddrDelta;
Ulrich Weigand32d725b2013-06-12 14:46:54 +000055 if (AddrDelta % MinInsnLength != 0) {
Kevin Enderbye46564a2010-09-30 16:52:03 +000056 // TODO: report this error, but really only once.
57 ;
58 }
Ulrich Weigand32d725b2013-06-12 14:46:54 +000059 return AddrDelta / MinInsnLength;
Kevin Enderbye46564a2010-09-30 16:52:03 +000060}
61
62//
63// This is called when an instruction is assembled into the specified section
64// and if there is information from the last .loc directive that has yet to have
65// a line entry made for it is made.
66//
Rafael Espindola0709a7b2015-05-21 19:20:38 +000067void MCLineEntry::Make(MCObjectStreamer *MCOS, MCSection *Section) {
Kevin Enderbye46564a2010-09-30 16:52:03 +000068 if (!MCOS->getContext().getDwarfLocSeen())
69 return;
70
71 // Create a symbol at in the current section for use in the line entry.
Jim Grosbach6f482002015-05-18 18:43:14 +000072 MCSymbol *LineSym = MCOS->getContext().createTempSymbol();
Kevin Enderbye46564a2010-09-30 16:52:03 +000073 // Set the value of the symbol to use for the MCLineEntry.
74 MCOS->EmitLabel(LineSym);
75
76 // Get the current .loc info saved in the context.
77 const MCDwarfLoc &DwarfLoc = MCOS->getContext().getCurrentDwarfLoc();
78
79 // Create a (local) line entry with the symbol and the current .loc info.
80 MCLineEntry LineEntry(LineSym, DwarfLoc);
81
82 // clear DwarfLocSeen saying the current .loc info is now used.
Jim Grosbach6f482002015-05-18 18:43:14 +000083 MCOS->getContext().clearDwarfLocSeen();
Kevin Enderbye46564a2010-09-30 16:52:03 +000084
Kevin Enderbye46564a2010-09-30 16:52:03 +000085 // Add the line entry to this section's entries.
David Blaikiea55e64f2014-03-12 22:28:56 +000086 MCOS->getContext()
David Blaikied9012ba2014-03-13 21:59:51 +000087 .getMCDwarfLineTable(MCOS->getContext().getDwarfCompileUnitID())
David Blaikie11765bc2014-03-13 17:55:28 +000088 .getMCLineSections()
David Blaikiea55e64f2014-03-12 22:28:56 +000089 .addLineEntry(LineEntry, Section);
Kevin Enderbye46564a2010-09-30 16:52:03 +000090}
91
92//
93// This helper routine returns an expression of End - Start + IntVal .
Jim Grosbachdc1e36e2012-05-11 01:41:30 +000094//
Rafael Espindolad66e65d2010-12-09 23:08:35 +000095static inline const MCExpr *MakeStartMinusEndExpr(const MCStreamer &MCOS,
96 const MCSymbol &Start,
97 const MCSymbol &End,
98 int IntVal) {
Kevin Enderbye46564a2010-09-30 16:52:03 +000099 MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None;
100 const MCExpr *Res =
Rafael Espindolad66e65d2010-12-09 23:08:35 +0000101 MCSymbolRefExpr::Create(&End, Variant, MCOS.getContext());
Kevin Enderbye46564a2010-09-30 16:52:03 +0000102 const MCExpr *RHS =
Rafael Espindolad66e65d2010-12-09 23:08:35 +0000103 MCSymbolRefExpr::Create(&Start, Variant, MCOS.getContext());
Kevin Enderbye46564a2010-09-30 16:52:03 +0000104 const MCExpr *Res1 =
Rafael Espindolad66e65d2010-12-09 23:08:35 +0000105 MCBinaryExpr::Create(MCBinaryExpr::Sub, Res, RHS, MCOS.getContext());
Kevin Enderbye46564a2010-09-30 16:52:03 +0000106 const MCExpr *Res2 =
Rafael Espindolad66e65d2010-12-09 23:08:35 +0000107 MCConstantExpr::Create(IntVal, MCOS.getContext());
Kevin Enderbye46564a2010-09-30 16:52:03 +0000108 const MCExpr *Res3 =
Rafael Espindolad66e65d2010-12-09 23:08:35 +0000109 MCBinaryExpr::Create(MCBinaryExpr::Sub, Res1, Res2, MCOS.getContext());
Kevin Enderbye46564a2010-09-30 16:52:03 +0000110 return Res3;
111}
112
Kevin Enderbye46564a2010-09-30 16:52:03 +0000113//
114// This emits the Dwarf line table for the specified section from the entries
115// in the LineSection.
116//
David Blaikief4ad6982014-03-12 22:35:23 +0000117static inline void
Rafael Espindola0709a7b2015-05-21 19:20:38 +0000118EmitDwarfLineTable(MCObjectStreamer *MCOS, MCSection *Section,
David Blaikief4ad6982014-03-12 22:35:23 +0000119 const MCLineSection::MCLineEntryCollection &LineEntries) {
Kevin Enderbye46564a2010-09-30 16:52:03 +0000120 unsigned FileNum = 1;
121 unsigned LastLine = 1;
122 unsigned Column = 0;
123 unsigned Flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0;
124 unsigned Isa = 0;
Diego Novillo5b5cf502014-02-14 19:27:53 +0000125 unsigned Discriminator = 0;
Craig Topperbb694de2014-04-13 04:57:38 +0000126 MCSymbol *LastLabel = nullptr;
Kevin Enderbye46564a2010-09-30 16:52:03 +0000127
128 // Loop through each MCLineEntry and encode the dwarf line number table.
David Blaikiea55e64f2014-03-12 22:28:56 +0000129 for (auto it = LineEntries.begin(),
130 ie = LineEntries.end();
131 it != ie; ++it) {
Kevin Enderbye46564a2010-09-30 16:52:03 +0000132
133 if (FileNum != it->getFileNum()) {
134 FileNum = it->getFileNum();
135 MCOS->EmitIntValue(dwarf::DW_LNS_set_file, 1);
Rafael Espindola5e874982010-11-02 17:22:24 +0000136 MCOS->EmitULEB128IntValue(FileNum);
Kevin Enderbye46564a2010-09-30 16:52:03 +0000137 }
138 if (Column != it->getColumn()) {
139 Column = it->getColumn();
140 MCOS->EmitIntValue(dwarf::DW_LNS_set_column, 1);
Rafael Espindola5e874982010-11-02 17:22:24 +0000141 MCOS->EmitULEB128IntValue(Column);
Kevin Enderbye46564a2010-09-30 16:52:03 +0000142 }
Diego Novillo5b5cf502014-02-14 19:27:53 +0000143 if (Discriminator != it->getDiscriminator()) {
144 Discriminator = it->getDiscriminator();
Logan Chien5b776b72014-02-22 14:00:39 +0000145 unsigned Size = getULEB128Size(Discriminator);
Diego Novillo5b5cf502014-02-14 19:27:53 +0000146 MCOS->EmitIntValue(dwarf::DW_LNS_extended_op, 1);
147 MCOS->EmitULEB128IntValue(Size + 1);
148 MCOS->EmitIntValue(dwarf::DW_LNE_set_discriminator, 1);
149 MCOS->EmitULEB128IntValue(Discriminator);
150 }
Kevin Enderbye46564a2010-09-30 16:52:03 +0000151 if (Isa != it->getIsa()) {
152 Isa = it->getIsa();
153 MCOS->EmitIntValue(dwarf::DW_LNS_set_isa, 1);
Rafael Espindola5e874982010-11-02 17:22:24 +0000154 MCOS->EmitULEB128IntValue(Isa);
Kevin Enderbye46564a2010-09-30 16:52:03 +0000155 }
156 if ((it->getFlags() ^ Flags) & DWARF2_FLAG_IS_STMT) {
157 Flags = it->getFlags();
158 MCOS->EmitIntValue(dwarf::DW_LNS_negate_stmt, 1);
159 }
160 if (it->getFlags() & DWARF2_FLAG_BASIC_BLOCK)
161 MCOS->EmitIntValue(dwarf::DW_LNS_set_basic_block, 1);
162 if (it->getFlags() & DWARF2_FLAG_PROLOGUE_END)
163 MCOS->EmitIntValue(dwarf::DW_LNS_set_prologue_end, 1);
164 if (it->getFlags() & DWARF2_FLAG_EPILOGUE_BEGIN)
165 MCOS->EmitIntValue(dwarf::DW_LNS_set_epilogue_begin, 1);
166
Rafael Espindola1d37f352010-11-13 01:06:27 +0000167 int64_t LineDelta = static_cast<int64_t>(it->getLine()) - LastLine;
Kevin Enderbye46564a2010-09-30 16:52:03 +0000168 MCSymbol *Label = it->getLabel();
169
170 // At this point we want to emit/create the sequence to encode the delta in
171 // line numbers and the increment of the address from the previous Label
172 // and the current Label.
Bill Wendlingbc07a892013-06-18 07:20:20 +0000173 const MCAsmInfo *asmInfo = MCOS->getContext().getAsmInfo();
Evan Chengc7ac6902011-07-14 05:43:07 +0000174 MCOS->EmitDwarfAdvanceLineAddr(LineDelta, LastLabel, Label,
Bill Wendlingbc07a892013-06-18 07:20:20 +0000175 asmInfo->getPointerSize());
Kevin Enderbye46564a2010-09-30 16:52:03 +0000176
177 LastLine = it->getLine();
178 LastLabel = Label;
Kevin Enderbye46564a2010-09-30 16:52:03 +0000179 }
180
181 // Emit a DW_LNE_end_sequence for the end of the section.
Rafael Espindolaf2b408c2015-03-23 21:22:04 +0000182 // Use the section end label to compute the address delta and use INT64_MAX
183 // as the line delta which is the signal that this is actually a
184 // DW_LNE_end_sequence.
185 MCSymbol *SectionEnd = MCOS->endSection(Section);
Kevin Enderbye46564a2010-09-30 16:52:03 +0000186
Rafael Espindolaf2b408c2015-03-23 21:22:04 +0000187 // Switch back the dwarf line section, in case endSection had to switch the
188 // section.
Rafael Espindolaae3d78a2015-03-23 20:25:31 +0000189 MCContext &Ctx = MCOS->getContext();
Rafael Espindolaae3d78a2015-03-23 20:25:31 +0000190 MCOS->SwitchSection(Ctx.getObjectFileInfo()->getDwarfLineSection());
Rafael Espindolab58867cc2010-11-19 02:26:16 +0000191
Rafael Espindolaae3d78a2015-03-23 20:25:31 +0000192 const MCAsmInfo *AsmInfo = Ctx.getAsmInfo();
Evan Chengc7ac6902011-07-14 05:43:07 +0000193 MCOS->EmitDwarfAdvanceLineAddr(INT64_MAX, LastLabel, SectionEnd,
Rafael Espindolaae3d78a2015-03-23 20:25:31 +0000194 AsmInfo->getPointerSize());
Kevin Enderbye46564a2010-09-30 16:52:03 +0000195}
196
197//
198// This emits the Dwarf file and the line tables.
199//
Rafael Espindola4066e8d2014-05-12 14:28:48 +0000200void MCDwarfLineTable::Emit(MCObjectStreamer *MCOS) {
Rafael Espindola0a017a62010-12-10 07:39:47 +0000201 MCContext &context = MCOS->getContext();
Kevin Enderbye46564a2010-09-30 16:52:03 +0000202
David Blaikie8bf66c42014-04-01 07:35:52 +0000203 auto &LineTables = context.getMCDwarfLineTables();
204
205 // Bail out early so we don't switch to the debug_line section needlessly and
206 // in doing so create an unnecessary (if empty) section.
207 if (LineTables.empty())
208 return;
David Blaikie11765bc2014-03-13 17:55:28 +0000209
210 // Switch to the section where the table will be emitted into.
211 MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfLineSection());
212
Manman Ren4e042a62013-02-05 21:52:47 +0000213 // Handle the rest of the Compile Units.
David Blaikie8bf66c42014-04-01 07:35:52 +0000214 for (const auto &CUIDTablePair : LineTables)
215 CUIDTablePair.second.EmitCU(MCOS);
Manman Ren4e042a62013-02-05 21:52:47 +0000216}
217
David Blaikie8287aff2014-03-18 02:13:23 +0000218void MCDwarfDwoLineTable::Emit(MCStreamer &MCOS) const {
219 MCOS.EmitLabel(Header.Emit(&MCOS, None).second);
220}
221
David Blaikie5cff0e62014-03-13 21:47:12 +0000222std::pair<MCSymbol *, MCSymbol *> MCDwarfLineTableHeader::Emit(MCStreamer *MCOS) const {
David Blaikie8287aff2014-03-18 02:13:23 +0000223 static const char StandardOpcodeLengths[] = {
224 0, // length of DW_LNS_copy
225 1, // length of DW_LNS_advance_pc
226 1, // length of DW_LNS_advance_line
227 1, // length of DW_LNS_set_file
228 1, // length of DW_LNS_set_column
229 0, // length of DW_LNS_negate_stmt
230 0, // length of DW_LNS_set_basic_block
231 0, // length of DW_LNS_const_add_pc
232 1, // length of DW_LNS_fixed_advance_pc
233 0, // length of DW_LNS_set_prologue_end
234 0, // length of DW_LNS_set_epilogue_begin
235 1 // DW_LNS_set_isa
236 };
Gabor Horvathc759e542015-03-16 10:19:53 +0000237 assert(array_lengthof(StandardOpcodeLengths) ==
238 (DWARF2_LINE_OPCODE_BASE - 1));
David Blaikie8287aff2014-03-18 02:13:23 +0000239 return Emit(MCOS, StandardOpcodeLengths);
240}
241
Rafael Espindolac23174b2014-08-15 15:12:13 +0000242static const MCExpr *forceExpAbs(MCStreamer &OS, const MCExpr* Expr) {
243 MCContext &Context = OS.getContext();
244 assert(!isa<MCSymbolRefExpr>(Expr));
245 if (Context.getAsmInfo()->hasAggressiveSymbolFolding())
246 return Expr;
247
Jim Grosbach6f482002015-05-18 18:43:14 +0000248 MCSymbol *ABS = Context.createTempSymbol();
Rafael Espindolac23174b2014-08-15 15:12:13 +0000249 OS.EmitAssignment(ABS, Expr);
250 return MCSymbolRefExpr::Create(ABS, Context);
251}
252
253static void emitAbsValue(MCStreamer &OS, const MCExpr *Value, unsigned Size) {
254 const MCExpr *ABS = forceExpAbs(OS, Value);
255 OS.EmitValue(ABS, Size);
256}
257
David Blaikie8287aff2014-03-18 02:13:23 +0000258std::pair<MCSymbol *, MCSymbol *>
259MCDwarfLineTableHeader::Emit(MCStreamer *MCOS,
260 ArrayRef<char> StandardOpcodeLengths) const {
261
Manman Ren4e042a62013-02-05 21:52:47 +0000262 MCContext &context = MCOS->getContext();
263
264 // Create a symbol at the beginning of the line table.
David Blaikie11765bc2014-03-13 17:55:28 +0000265 MCSymbol *LineStartSym = Label;
Manman Ren4e042a62013-02-05 21:52:47 +0000266 if (!LineStartSym)
Jim Grosbach6f482002015-05-18 18:43:14 +0000267 LineStartSym = context.createTempSymbol();
Manman Ren4e042a62013-02-05 21:52:47 +0000268 // Set the value of the symbol, as we are at the start of the line table.
Kevin Enderbye46564a2010-09-30 16:52:03 +0000269 MCOS->EmitLabel(LineStartSym);
270
271 // Create a symbol for the end of the section (to be set when we get there).
Jim Grosbach6f482002015-05-18 18:43:14 +0000272 MCSymbol *LineEndSym = context.createTempSymbol();
Kevin Enderbye46564a2010-09-30 16:52:03 +0000273
274 // The first 4 bytes is the total length of the information for this
275 // compilation unit (not including these 4 bytes for the length).
Rafael Espindolac23174b2014-08-15 15:12:13 +0000276 emitAbsValue(*MCOS,
277 MakeStartMinusEndExpr(*MCOS, *LineStartSym, *LineEndSym, 4), 4);
Kevin Enderbye46564a2010-09-30 16:52:03 +0000278
279 // Next 2 bytes is the Version, which is Dwarf 2.
280 MCOS->EmitIntValue(2, 2);
281
282 // Create a symbol for the end of the prologue (to be set when we get there).
Jim Grosbach6f482002015-05-18 18:43:14 +0000283 MCSymbol *ProEndSym = context.createTempSymbol(); // Lprologue_end
Kevin Enderbye46564a2010-09-30 16:52:03 +0000284
285 // Length of the prologue, is the next 4 bytes. Which is the start of the
286 // section to the end of the prologue. Not including the 4 bytes for the
287 // total length, the 2 bytes for the version, and these 4 bytes for the
288 // length of the prologue.
Rafael Espindolac23174b2014-08-15 15:12:13 +0000289 emitAbsValue(
290 *MCOS,
291 MakeStartMinusEndExpr(*MCOS, *LineStartSym, *ProEndSym, (4 + 2 + 4)), 4);
Kevin Enderbye46564a2010-09-30 16:52:03 +0000292
293 // Parameters of the state machine, are next.
Bill Wendlingbc07a892013-06-18 07:20:20 +0000294 MCOS->EmitIntValue(context.getAsmInfo()->getMinInstAlignment(), 1);
Kevin Enderbye46564a2010-09-30 16:52:03 +0000295 MCOS->EmitIntValue(DWARF2_LINE_DEFAULT_IS_STMT, 1);
296 MCOS->EmitIntValue(DWARF2_LINE_BASE, 1);
297 MCOS->EmitIntValue(DWARF2_LINE_RANGE, 1);
David Blaikie8287aff2014-03-18 02:13:23 +0000298 MCOS->EmitIntValue(StandardOpcodeLengths.size() + 1, 1);
Kevin Enderbye46564a2010-09-30 16:52:03 +0000299
300 // Standard opcode lengths
David Blaikie8287aff2014-03-18 02:13:23 +0000301 for (char Length : StandardOpcodeLengths)
302 MCOS->EmitIntValue(Length, 1);
Kevin Enderbye46564a2010-09-30 16:52:03 +0000303
304 // Put out the directory and file tables.
305
306 // First the directory table.
Kevin Enderbye46564a2010-09-30 16:52:03 +0000307 for (unsigned i = 0; i < MCDwarfDirs.size(); i++) {
Eric Christophere3ab3d02013-01-09 01:57:54 +0000308 MCOS->EmitBytes(MCDwarfDirs[i]); // the DirectoryName
309 MCOS->EmitBytes(StringRef("\0", 1)); // the null term. of the string
Kevin Enderbye46564a2010-09-30 16:52:03 +0000310 }
311 MCOS->EmitIntValue(0, 1); // Terminate the directory list
312
313 // Second the file table.
Kevin Enderbye46564a2010-09-30 16:52:03 +0000314 for (unsigned i = 1; i < MCDwarfFiles.size(); i++) {
David Blaikiec2df16b2014-03-17 18:13:58 +0000315 assert(!MCDwarfFiles[i].Name.empty());
David Blaikiea55ddad2014-03-13 18:55:04 +0000316 MCOS->EmitBytes(MCDwarfFiles[i].Name); // FileName
Eric Christophere3ab3d02013-01-09 01:57:54 +0000317 MCOS->EmitBytes(StringRef("\0", 1)); // the null term. of the string
Rafael Espindola5e874982010-11-02 17:22:24 +0000318 // the Directory num
David Blaikiea55ddad2014-03-13 18:55:04 +0000319 MCOS->EmitULEB128IntValue(MCDwarfFiles[i].DirIndex);
Kevin Enderbye46564a2010-09-30 16:52:03 +0000320 MCOS->EmitIntValue(0, 1); // last modification timestamp (always 0)
321 MCOS->EmitIntValue(0, 1); // filesize (always 0)
322 }
323 MCOS->EmitIntValue(0, 1); // Terminate the file list
324
325 // This is the end of the prologue, so set the value of the symbol at the
326 // end of the prologue (that was used in a previous expression).
327 MCOS->EmitLabel(ProEndSym);
328
David Blaikie5cff0e62014-03-13 21:47:12 +0000329 return std::make_pair(LineStartSym, LineEndSym);
330}
331
Rafael Espindola4066e8d2014-05-12 14:28:48 +0000332void MCDwarfLineTable::EmitCU(MCObjectStreamer *MCOS) const {
David Blaikie8bf66c42014-04-01 07:35:52 +0000333 MCSymbol *LineEndSym = Header.Emit(MCOS).second;
David Blaikie5cff0e62014-03-13 21:47:12 +0000334
Kevin Enderbye46564a2010-09-30 16:52:03 +0000335 // Put out the line tables.
David Blaikie11765bc2014-03-13 17:55:28 +0000336 for (const auto &LineSec : MCLineSections.getMCLineEntries())
337 EmitDwarfLineTable(MCOS, LineSec.first, LineSec.second);
Kevin Enderbye46564a2010-09-30 16:52:03 +0000338
Kevin Enderbye46564a2010-09-30 16:52:03 +0000339 // This is the end of the section, so set the value of the symbol at the end
340 // of this section (that was used in a previous expression).
341 MCOS->EmitLabel(LineEndSym);
Kevin Enderbye46564a2010-09-30 16:52:03 +0000342}
343
David Blaikiec2df16b2014-03-17 18:13:58 +0000344unsigned MCDwarfLineTable::getFile(StringRef &Directory, StringRef &FileName,
David Blaikied9012ba2014-03-13 21:59:51 +0000345 unsigned FileNumber) {
David Blaikie5cff0e62014-03-13 21:47:12 +0000346 return Header.getFile(Directory, FileName, FileNumber);
347}
348
David Blaikiec2df16b2014-03-17 18:13:58 +0000349unsigned MCDwarfLineTableHeader::getFile(StringRef &Directory,
350 StringRef &FileName,
David Blaikiec714ef42014-03-17 01:52:11 +0000351 unsigned FileNumber) {
David Blaikiec7f29dc2014-03-17 23:29:40 +0000352 if (Directory == CompilationDir)
353 Directory = "";
David Blaikiec2df16b2014-03-17 18:13:58 +0000354 if (FileName.empty()) {
355 FileName = "<stdin>";
356 Directory = "";
357 }
358 assert(!FileName.empty());
David Blaikiec714ef42014-03-17 01:52:11 +0000359 if (FileNumber == 0) {
360 FileNumber = SourceIdMap.size() + 1;
361 assert((MCDwarfFiles.empty() || FileNumber == MCDwarfFiles.size()) &&
362 "Don't mix autonumbered and explicit numbered line table usage");
Pete Cooperb7800812015-05-20 19:12:14 +0000363 SmallString<256> Buffer;
David Blaikie5106ce72014-11-19 05:49:42 +0000364 auto IterBool = SourceIdMap.insert(
Pete Cooperb7800812015-05-20 19:12:14 +0000365 std::make_pair((Directory + Twine('\0') + FileName).toStringRef(Buffer),
366 FileNumber));
David Blaikie5106ce72014-11-19 05:49:42 +0000367 if (!IterBool.second)
368 return IterBool.first->second;
David Blaikiec714ef42014-03-17 01:52:11 +0000369 }
David Blaikie498589c2014-03-13 19:15:04 +0000370 // Make space for this FileNumber in the MCDwarfFiles vector if needed.
371 MCDwarfFiles.resize(FileNumber + 1);
372
373 // Get the new MCDwarfFile slot for this FileNumber.
374 MCDwarfFile &File = MCDwarfFiles[FileNumber];
375
376 // It is an error to use see the same number more than once.
377 if (!File.Name.empty())
378 return 0;
379
380 if (Directory.empty()) {
381 // Separate the directory part from the basename of the FileName.
382 StringRef tFileName = sys::path::filename(FileName);
383 if (!tFileName.empty()) {
384 Directory = sys::path::parent_path(FileName);
385 if (!Directory.empty())
386 FileName = tFileName;
387 }
388 }
389
390 // Find or make an entry in the MCDwarfDirs vector for this Directory.
391 // Capture directory name.
392 unsigned DirIndex;
393 if (Directory.empty()) {
394 // For FileNames with no directories a DirIndex of 0 is used.
395 DirIndex = 0;
396 } else {
397 DirIndex = 0;
398 for (unsigned End = MCDwarfDirs.size(); DirIndex < End; DirIndex++) {
399 if (Directory == MCDwarfDirs[DirIndex])
400 break;
401 }
402 if (DirIndex >= MCDwarfDirs.size())
403 MCDwarfDirs.push_back(Directory);
404 // The DirIndex is one based, as DirIndex of 0 is used for FileNames with
405 // no directories. MCDwarfDirs[] is unlike MCDwarfFiles[] in that the
406 // directory names are stored at MCDwarfDirs[DirIndex-1] where FileNames
407 // are stored at MCDwarfFiles[FileNumber].Name .
408 DirIndex++;
409 }
410
411 File.Name = FileName;
412 File.DirIndex = DirIndex;
413
414 // return the allocated FileNumber.
415 return FileNumber;
416}
417
Kevin Enderbye46564a2010-09-30 16:52:03 +0000418/// Utility function to emit the encoding to a streamer.
Rafael Espindolab58867cc2010-11-19 02:26:16 +0000419void MCDwarfLineAddr::Emit(MCStreamer *MCOS, int64_t LineDelta,
Kevin Enderbye46564a2010-09-30 16:52:03 +0000420 uint64_t AddrDelta) {
Ulrich Weigand32d725b2013-06-12 14:46:54 +0000421 MCContext &Context = MCOS->getContext();
Alp Tokere69170a2014-06-26 22:52:05 +0000422 SmallString<256> Tmp;
423 raw_svector_ostream OS(Tmp);
Ulrich Weigand32d725b2013-06-12 14:46:54 +0000424 MCDwarfLineAddr::Encode(Context, LineDelta, AddrDelta, OS);
Eric Christophere3ab3d02013-01-09 01:57:54 +0000425 MCOS->EmitBytes(OS.str());
Kevin Enderbye46564a2010-09-30 16:52:03 +0000426}
427
428/// Utility function to encode a Dwarf pair of LineDelta and AddrDeltas.
Ulrich Weigand32d725b2013-06-12 14:46:54 +0000429void MCDwarfLineAddr::Encode(MCContext &Context, int64_t LineDelta,
430 uint64_t AddrDelta, raw_ostream &OS) {
Kevin Enderbye46564a2010-09-30 16:52:03 +0000431 uint64_t Temp, Opcode;
432 bool NeedCopy = false;
433
434 // Scale the address delta by the minimum instruction length.
Ulrich Weigand32d725b2013-06-12 14:46:54 +0000435 AddrDelta = ScaleAddrDelta(Context, AddrDelta);
Kevin Enderbye46564a2010-09-30 16:52:03 +0000436
437 // A LineDelta of INT64_MAX is a signal that this is actually a
Jim Grosbachdc1e36e2012-05-11 01:41:30 +0000438 // DW_LNE_end_sequence. We cannot use special opcodes here, since we want the
Kevin Enderbye46564a2010-09-30 16:52:03 +0000439 // end_sequence to emit the matrix entry.
440 if (LineDelta == INT64_MAX) {
441 if (AddrDelta == MAX_SPECIAL_ADDR_DELTA)
442 OS << char(dwarf::DW_LNS_const_add_pc);
Frederic Rissceb18362015-03-15 20:45:39 +0000443 else if (AddrDelta) {
Kevin Enderbye46564a2010-09-30 16:52:03 +0000444 OS << char(dwarf::DW_LNS_advance_pc);
Jim Grosbachbf387df2012-08-08 23:56:06 +0000445 encodeULEB128(AddrDelta, OS);
Kevin Enderbye46564a2010-09-30 16:52:03 +0000446 }
447 OS << char(dwarf::DW_LNS_extended_op);
448 OS << char(1);
449 OS << char(dwarf::DW_LNE_end_sequence);
450 return;
451 }
452
453 // Bias the line delta by the base.
454 Temp = LineDelta - DWARF2_LINE_BASE;
455
456 // If the line increment is out of range of a special opcode, we must encode
457 // it with DW_LNS_advance_line.
458 if (Temp >= DWARF2_LINE_RANGE) {
459 OS << char(dwarf::DW_LNS_advance_line);
Jim Grosbachbf387df2012-08-08 23:56:06 +0000460 encodeSLEB128(LineDelta, OS);
Kevin Enderbye46564a2010-09-30 16:52:03 +0000461
462 LineDelta = 0;
463 Temp = 0 - DWARF2_LINE_BASE;
464 NeedCopy = true;
465 }
466
467 // Use DW_LNS_copy instead of a "line +0, addr +0" special opcode.
468 if (LineDelta == 0 && AddrDelta == 0) {
469 OS << char(dwarf::DW_LNS_copy);
470 return;
471 }
472
473 // Bias the opcode by the special opcode base.
474 Temp += DWARF2_LINE_OPCODE_BASE;
475
476 // Avoid overflow when addr_delta is large.
477 if (AddrDelta < 256 + MAX_SPECIAL_ADDR_DELTA) {
478 // Try using a special opcode.
479 Opcode = Temp + AddrDelta * DWARF2_LINE_RANGE;
480 if (Opcode <= 255) {
481 OS << char(Opcode);
482 return;
483 }
484
485 // Try using DW_LNS_const_add_pc followed by special op.
486 Opcode = Temp + (AddrDelta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
487 if (Opcode <= 255) {
488 OS << char(dwarf::DW_LNS_const_add_pc);
489 OS << char(Opcode);
490 return;
491 }
492 }
493
494 // Otherwise use DW_LNS_advance_pc.
495 OS << char(dwarf::DW_LNS_advance_pc);
Jim Grosbachbf387df2012-08-08 23:56:06 +0000496 encodeULEB128(AddrDelta, OS);
Kevin Enderbye46564a2010-09-30 16:52:03 +0000497
498 if (NeedCopy)
499 OS << char(dwarf::DW_LNS_copy);
500 else
501 OS << char(Temp);
502}
503
Kevin Enderbye7739d42011-12-09 18:09:40 +0000504// Utility function to write a tuple for .debug_abbrev.
505static void EmitAbbrev(MCStreamer *MCOS, uint64_t Name, uint64_t Form) {
506 MCOS->EmitULEB128IntValue(Name);
507 MCOS->EmitULEB128IntValue(Form);
508}
509
510// When generating dwarf for assembly source files this emits
511// the data for .debug_abbrev section which contains three DIEs.
512static void EmitGenDwarfAbbrev(MCStreamer *MCOS) {
513 MCContext &context = MCOS->getContext();
514 MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfAbbrevSection());
515
516 // DW_TAG_compile_unit DIE abbrev (1).
517 MCOS->EmitULEB128IntValue(1);
518 MCOS->EmitULEB128IntValue(dwarf::DW_TAG_compile_unit);
519 MCOS->EmitIntValue(dwarf::DW_CHILDREN_yes, 1);
520 EmitAbbrev(MCOS, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4);
Oliver Stannard14f97d02014-09-22 10:45:16 +0000521 if (MCOS->getContext().getGenDwarfSectionSyms().size() > 1 &&
522 MCOS->getContext().getDwarfVersion() >= 3) {
Oliver Stannard8b273082014-06-19 15:52:37 +0000523 EmitAbbrev(MCOS, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4);
524 } else {
525 EmitAbbrev(MCOS, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr);
526 EmitAbbrev(MCOS, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr);
527 }
Kevin Enderbye7739d42011-12-09 18:09:40 +0000528 EmitAbbrev(MCOS, dwarf::DW_AT_name, dwarf::DW_FORM_string);
Andrew Trick32591d32013-12-10 04:39:09 +0000529 if (!context.getCompilationDir().empty())
530 EmitAbbrev(MCOS, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string);
Kevin Enderbye7739d42011-12-09 18:09:40 +0000531 StringRef DwarfDebugFlags = context.getDwarfDebugFlags();
532 if (!DwarfDebugFlags.empty())
533 EmitAbbrev(MCOS, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string);
534 EmitAbbrev(MCOS, dwarf::DW_AT_producer, dwarf::DW_FORM_string);
535 EmitAbbrev(MCOS, dwarf::DW_AT_language, dwarf::DW_FORM_data2);
536 EmitAbbrev(MCOS, 0, 0);
537
Kevin Enderby8d4a2202012-01-10 17:52:29 +0000538 // DW_TAG_label DIE abbrev (2).
Kevin Enderbye7739d42011-12-09 18:09:40 +0000539 MCOS->EmitULEB128IntValue(2);
Kevin Enderby8d4a2202012-01-10 17:52:29 +0000540 MCOS->EmitULEB128IntValue(dwarf::DW_TAG_label);
Kevin Enderbye7739d42011-12-09 18:09:40 +0000541 MCOS->EmitIntValue(dwarf::DW_CHILDREN_yes, 1);
542 EmitAbbrev(MCOS, dwarf::DW_AT_name, dwarf::DW_FORM_string);
543 EmitAbbrev(MCOS, dwarf::DW_AT_decl_file, dwarf::DW_FORM_data4);
544 EmitAbbrev(MCOS, dwarf::DW_AT_decl_line, dwarf::DW_FORM_data4);
545 EmitAbbrev(MCOS, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr);
Kevin Enderbye7739d42011-12-09 18:09:40 +0000546 EmitAbbrev(MCOS, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag);
547 EmitAbbrev(MCOS, 0, 0);
548
549 // DW_TAG_unspecified_parameters DIE abbrev (3).
550 MCOS->EmitULEB128IntValue(3);
551 MCOS->EmitULEB128IntValue(dwarf::DW_TAG_unspecified_parameters);
552 MCOS->EmitIntValue(dwarf::DW_CHILDREN_no, 1);
553 EmitAbbrev(MCOS, 0, 0);
554
555 // Terminate the abbreviations for this compilation unit.
556 MCOS->EmitIntValue(0, 1);
557}
558
559// When generating dwarf for assembly source files this emits the data for
Oliver Stannard8b273082014-06-19 15:52:37 +0000560// .debug_aranges section. This section contains a header and a table of pairs
561// of PointerSize'ed values for the address and size of section(s) with line
562// table entries.
Alexey Samsonov00fd5252012-11-14 09:55:38 +0000563static void EmitGenDwarfAranges(MCStreamer *MCOS,
564 const MCSymbol *InfoSectionSymbol) {
Kevin Enderbye7739d42011-12-09 18:09:40 +0000565 MCContext &context = MCOS->getContext();
566
Oliver Stannard8b273082014-06-19 15:52:37 +0000567 auto &Sections = context.getGenDwarfSectionSyms();
Kevin Enderbye7739d42011-12-09 18:09:40 +0000568
569 MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfARangesSection());
570
571 // This will be the length of the .debug_aranges section, first account for
572 // the size of each item in the header (see below where we emit these items).
573 int Length = 4 + 2 + 4 + 1 + 1;
574
575 // Figure the padding after the header before the table of address and size
576 // pairs who's values are PointerSize'ed.
Bill Wendlingbc07a892013-06-18 07:20:20 +0000577 const MCAsmInfo *asmInfo = context.getAsmInfo();
578 int AddrSize = asmInfo->getPointerSize();
Kevin Enderbye7739d42011-12-09 18:09:40 +0000579 int Pad = 2 * AddrSize - (Length & (2 * AddrSize - 1));
580 if (Pad == 2 * AddrSize)
581 Pad = 0;
582 Length += Pad;
583
584 // Add the size of the pair of PointerSize'ed values for the address and size
Oliver Stannard8b273082014-06-19 15:52:37 +0000585 // of each section we have in the table.
586 Length += 2 * AddrSize * Sections.size();
Kevin Enderbye7739d42011-12-09 18:09:40 +0000587 // And the pair of terminating zeros.
588 Length += 2 * AddrSize;
589
590
591 // Emit the header for this section.
592 // The 4 byte length not including the 4 byte value for the length.
593 MCOS->EmitIntValue(Length - 4, 4);
594 // The 2 byte version, which is 2.
595 MCOS->EmitIntValue(2, 2);
596 // The 4 byte offset to the compile unit in the .debug_info from the start
Alexey Samsonov00fd5252012-11-14 09:55:38 +0000597 // of the .debug_info.
598 if (InfoSectionSymbol)
Saleem Abdulrasoolfcefa212014-09-06 19:57:48 +0000599 MCOS->EmitSymbolValue(InfoSectionSymbol, 4,
600 asmInfo->needsDwarfSectionOffsetDirective());
Alexey Samsonov00fd5252012-11-14 09:55:38 +0000601 else
602 MCOS->EmitIntValue(0, 4);
Kevin Enderbye7739d42011-12-09 18:09:40 +0000603 // The 1 byte size of an address.
604 MCOS->EmitIntValue(AddrSize, 1);
605 // The 1 byte size of a segment descriptor, we use a value of zero.
606 MCOS->EmitIntValue(0, 1);
607 // Align the header with the padding if needed, before we put out the table.
608 for(int i = 0; i < Pad; i++)
609 MCOS->EmitIntValue(0, 1);
610
Oliver Stannard8b273082014-06-19 15:52:37 +0000611 // Now emit the table of pairs of PointerSize'ed values for the section
612 // addresses and sizes.
Rafael Espindola0709a7b2015-05-21 19:20:38 +0000613 for (MCSection *Sec : Sections) {
614 const MCSymbol *StartSymbol = Sec->getBeginSymbol();
Rafael Espindolae0746792015-05-21 16:52:32 +0000615 MCSymbol *EndSymbol = Sec->getEndSymbol(context);
Oliver Stannard8b273082014-06-19 15:52:37 +0000616 assert(StartSymbol && "StartSymbol must not be NULL");
617 assert(EndSymbol && "EndSymbol must not be NULL");
618
619 const MCExpr *Addr = MCSymbolRefExpr::Create(
620 StartSymbol, MCSymbolRefExpr::VK_None, context);
621 const MCExpr *Size = MakeStartMinusEndExpr(*MCOS,
622 *StartSymbol, *EndSymbol, 0);
623 MCOS->EmitValue(Addr, AddrSize);
Rafael Espindolac23174b2014-08-15 15:12:13 +0000624 emitAbsValue(*MCOS, Size, AddrSize);
Oliver Stannard8b273082014-06-19 15:52:37 +0000625 }
Kevin Enderbye7739d42011-12-09 18:09:40 +0000626
627 // And finally the pair of terminating zeros.
628 MCOS->EmitIntValue(0, AddrSize);
629 MCOS->EmitIntValue(0, AddrSize);
630}
631
632// When generating dwarf for assembly source files this emits the data for
633// .debug_info section which contains three parts. The header, the compile_unit
Kevin Enderby8d4a2202012-01-10 17:52:29 +0000634// DIE and a list of label DIEs.
Rafael Espindolac22c85c2012-02-28 21:13:05 +0000635static void EmitGenDwarfInfo(MCStreamer *MCOS,
636 const MCSymbol *AbbrevSectionSymbol,
Oliver Stannard8b273082014-06-19 15:52:37 +0000637 const MCSymbol *LineSectionSymbol,
638 const MCSymbol *RangesSectionSymbol) {
Kevin Enderbye7739d42011-12-09 18:09:40 +0000639 MCContext &context = MCOS->getContext();
640
Jim Grosbachdc1e36e2012-05-11 01:41:30 +0000641 MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfInfoSection());
Kevin Enderbye7739d42011-12-09 18:09:40 +0000642
643 // Create a symbol at the start and end of this section used in here for the
644 // expression to calculate the length in the header.
Jim Grosbach6f482002015-05-18 18:43:14 +0000645 MCSymbol *InfoStart = context.createTempSymbol();
Kevin Enderbye7739d42011-12-09 18:09:40 +0000646 MCOS->EmitLabel(InfoStart);
Jim Grosbach6f482002015-05-18 18:43:14 +0000647 MCSymbol *InfoEnd = context.createTempSymbol();
Kevin Enderbye7739d42011-12-09 18:09:40 +0000648
649 // First part: the header.
650
651 // The 4 byte total length of the information for this compilation unit, not
652 // including these 4 bytes.
653 const MCExpr *Length = MakeStartMinusEndExpr(*MCOS, *InfoStart, *InfoEnd, 4);
Rafael Espindolac23174b2014-08-15 15:12:13 +0000654 emitAbsValue(*MCOS, Length, 4);
Kevin Enderbye7739d42011-12-09 18:09:40 +0000655
Oliver Stannard7eacbd52014-05-01 08:46:02 +0000656 // The 2 byte DWARF version.
657 MCOS->EmitIntValue(context.getDwarfVersion(), 2);
Kevin Enderbye7739d42011-12-09 18:09:40 +0000658
Saleem Abdulrasool00426d92014-07-19 21:01:58 +0000659 const MCAsmInfo &AsmInfo = *context.getAsmInfo();
Kevin Enderbye7739d42011-12-09 18:09:40 +0000660 // The 4 byte offset to the debug abbrevs from the start of the .debug_abbrev,
661 // it is at the start of that section so this is zero.
Saleem Abdulrasool7d095302014-07-17 16:27:44 +0000662 if (AbbrevSectionSymbol == nullptr)
Rafael Espindolac22c85c2012-02-28 21:13:05 +0000663 MCOS->EmitIntValue(0, 4);
Saleem Abdulrasool7d095302014-07-17 16:27:44 +0000664 else
Saleem Abdulrasool00426d92014-07-19 21:01:58 +0000665 MCOS->EmitSymbolValue(AbbrevSectionSymbol, 4,
666 AsmInfo.needsDwarfSectionOffsetDirective());
Kevin Enderbye7739d42011-12-09 18:09:40 +0000667
Bill Wendlingbc07a892013-06-18 07:20:20 +0000668 const MCAsmInfo *asmInfo = context.getAsmInfo();
669 int AddrSize = asmInfo->getPointerSize();
Kevin Enderbye7739d42011-12-09 18:09:40 +0000670 // The 1 byte size of an address.
671 MCOS->EmitIntValue(AddrSize, 1);
672
673 // Second part: the compile_unit DIE.
674
675 // The DW_TAG_compile_unit DIE abbrev (1).
676 MCOS->EmitULEB128IntValue(1);
677
678 // DW_AT_stmt_list, a 4 byte offset from the start of the .debug_line section,
679 // which is at the start of that section so this is zero.
Saleem Abdulrasool5c70de12014-09-05 04:15:00 +0000680 if (LineSectionSymbol)
681 MCOS->EmitSymbolValue(LineSectionSymbol, 4,
682 AsmInfo.needsDwarfSectionOffsetDirective());
683 else
Rafael Espindolac22c85c2012-02-28 21:13:05 +0000684 MCOS->EmitIntValue(0, 4);
Kevin Enderbye7739d42011-12-09 18:09:40 +0000685
Oliver Stannard8b273082014-06-19 15:52:37 +0000686 if (RangesSectionSymbol) {
687 // There are multiple sections containing code, so we must use the
688 // .debug_ranges sections.
Kevin Enderbye7739d42011-12-09 18:09:40 +0000689
Oliver Stannard8b273082014-06-19 15:52:37 +0000690 // AT_ranges, the 4 byte offset from the start of the .debug_ranges section
691 // to the address range list for this compilation unit.
692 MCOS->EmitSymbolValue(RangesSectionSymbol, 4);
693 } else {
694 // If we only have one non-empty code section, we can use the simpler
695 // AT_low_pc and AT_high_pc attributes.
696
697 // Find the first (and only) non-empty text section
698 auto &Sections = context.getGenDwarfSectionSyms();
699 const auto TextSection = Sections.begin();
700 assert(TextSection != Sections.end() && "No text section found");
701
Rafael Espindolae0746792015-05-21 16:52:32 +0000702 MCSymbol *StartSymbol = (*TextSection)->getBeginSymbol();
703 MCSymbol *EndSymbol = (*TextSection)->getEndSymbol(context);
Oliver Stannard8b273082014-06-19 15:52:37 +0000704 assert(StartSymbol && "StartSymbol must not be NULL");
705 assert(EndSymbol && "EndSymbol must not be NULL");
706
707 // AT_low_pc, the first address of the default .text section.
708 const MCExpr *Start = MCSymbolRefExpr::Create(
709 StartSymbol, MCSymbolRefExpr::VK_None, context);
710 MCOS->EmitValue(Start, AddrSize);
711
712 // AT_high_pc, the last address of the default .text section.
713 const MCExpr *End = MCSymbolRefExpr::Create(
714 EndSymbol, MCSymbolRefExpr::VK_None, context);
715 MCOS->EmitValue(End, AddrSize);
716 }
Kevin Enderbye7739d42011-12-09 18:09:40 +0000717
718 // AT_name, the name of the source file. Reconstruct from the first directory
719 // and file table entries.
David Blaikie533490de2014-03-13 19:05:33 +0000720 const SmallVectorImpl<std::string> &MCDwarfDirs = context.getMCDwarfDirs();
Kevin Enderbye7739d42011-12-09 18:09:40 +0000721 if (MCDwarfDirs.size() > 0) {
Eric Christophere3ab3d02013-01-09 01:57:54 +0000722 MCOS->EmitBytes(MCDwarfDirs[0]);
Yaron Keren15217202014-05-16 13:16:30 +0000723 MCOS->EmitBytes(sys::path::get_separator());
Kevin Enderbye7739d42011-12-09 18:09:40 +0000724 }
David Blaikiea55ddad2014-03-13 18:55:04 +0000725 const SmallVectorImpl<MCDwarfFile> &MCDwarfFiles =
Kevin Enderbye7739d42011-12-09 18:09:40 +0000726 MCOS->getContext().getMCDwarfFiles();
David Blaikiea55ddad2014-03-13 18:55:04 +0000727 MCOS->EmitBytes(MCDwarfFiles[1].Name);
Kevin Enderbye7739d42011-12-09 18:09:40 +0000728 MCOS->EmitIntValue(0, 1); // NULL byte to terminate the string.
729
730 // AT_comp_dir, the working directory the assembly was done in.
Andrew Trick32591d32013-12-10 04:39:09 +0000731 if (!context.getCompilationDir().empty()) {
732 MCOS->EmitBytes(context.getCompilationDir());
733 MCOS->EmitIntValue(0, 1); // NULL byte to terminate the string.
734 }
Kevin Enderbye7739d42011-12-09 18:09:40 +0000735
736 // AT_APPLE_flags, the command line arguments of the assembler tool.
737 StringRef DwarfDebugFlags = context.getDwarfDebugFlags();
738 if (!DwarfDebugFlags.empty()){
Eric Christophere3ab3d02013-01-09 01:57:54 +0000739 MCOS->EmitBytes(DwarfDebugFlags);
Kevin Enderbye7739d42011-12-09 18:09:40 +0000740 MCOS->EmitIntValue(0, 1); // NULL byte to terminate the string.
741 }
742
743 // AT_producer, the version of the assembler tool.
Kevin Enderbye82ada62013-01-16 17:46:23 +0000744 StringRef DwarfDebugProducer = context.getDwarfDebugProducer();
Saleem Abdulrasool19f8bc62014-07-17 16:27:35 +0000745 if (!DwarfDebugProducer.empty())
Kevin Enderbye82ada62013-01-16 17:46:23 +0000746 MCOS->EmitBytes(DwarfDebugProducer);
Saleem Abdulrasool19f8bc62014-07-17 16:27:35 +0000747 else
748 MCOS->EmitBytes(StringRef("llvm-mc (based on LLVM " PACKAGE_VERSION ")"));
Kevin Enderbye7739d42011-12-09 18:09:40 +0000749 MCOS->EmitIntValue(0, 1); // NULL byte to terminate the string.
750
751 // AT_language, a 4 byte value. We use DW_LANG_Mips_Assembler as the dwarf2
752 // draft has no standard code for assembler.
753 MCOS->EmitIntValue(dwarf::DW_LANG_Mips_Assembler, 2);
754
Kevin Enderby8d4a2202012-01-10 17:52:29 +0000755 // Third part: the list of label DIEs.
Kevin Enderbye7739d42011-12-09 18:09:40 +0000756
Kevin Enderbyf7d77062012-01-10 21:12:34 +0000757 // Loop on saved info for dwarf labels and create the DIEs for them.
David Blaikie1e0fc8f2014-04-11 00:43:52 +0000758 const std::vector<MCGenDwarfLabelEntry> &Entries =
759 MCOS->getContext().getMCGenDwarfLabelEntries();
760 for (const auto &Entry : Entries) {
Kevin Enderby8d4a2202012-01-10 17:52:29 +0000761 // The DW_TAG_label DIE abbrev (2).
Kevin Enderbye7739d42011-12-09 18:09:40 +0000762 MCOS->EmitULEB128IntValue(2);
763
764 // AT_name, of the label without any leading underbar.
David Blaikie1e0fc8f2014-04-11 00:43:52 +0000765 MCOS->EmitBytes(Entry.getName());
Kevin Enderbye7739d42011-12-09 18:09:40 +0000766 MCOS->EmitIntValue(0, 1); // NULL byte to terminate the string.
767
768 // AT_decl_file, index into the file table.
David Blaikie1e0fc8f2014-04-11 00:43:52 +0000769 MCOS->EmitIntValue(Entry.getFileNumber(), 4);
Kevin Enderbye7739d42011-12-09 18:09:40 +0000770
771 // AT_decl_line, source line number.
David Blaikie1e0fc8f2014-04-11 00:43:52 +0000772 MCOS->EmitIntValue(Entry.getLineNumber(), 4);
Kevin Enderbye7739d42011-12-09 18:09:40 +0000773
774 // AT_low_pc, start address of the label.
David Blaikie1e0fc8f2014-04-11 00:43:52 +0000775 const MCExpr *AT_low_pc = MCSymbolRefExpr::Create(Entry.getLabel(),
Kevin Enderbye7739d42011-12-09 18:09:40 +0000776 MCSymbolRefExpr::VK_None, context);
Rafael Espindola98629c42014-03-20 21:26:38 +0000777 MCOS->EmitValue(AT_low_pc, AddrSize);
Kevin Enderbye7739d42011-12-09 18:09:40 +0000778
Kevin Enderbye7739d42011-12-09 18:09:40 +0000779 // DW_AT_prototyped, a one byte flag value of 0 saying we have no prototype.
780 MCOS->EmitIntValue(0, 1);
781
782 // The DW_TAG_unspecified_parameters DIE abbrev (3).
783 MCOS->EmitULEB128IntValue(3);
784
785 // Add the NULL DIE terminating the DW_TAG_unspecified_parameters DIE's.
786 MCOS->EmitIntValue(0, 1);
787 }
Kevin Enderbye7739d42011-12-09 18:09:40 +0000788
789 // Add the NULL DIE terminating the Compile Unit DIE's.
790 MCOS->EmitIntValue(0, 1);
791
792 // Now set the value of the symbol at the end of the info section.
793 MCOS->EmitLabel(InfoEnd);
794}
795
Oliver Stannard8b273082014-06-19 15:52:37 +0000796// When generating dwarf for assembly source files this emits the data for
797// .debug_ranges section. We only emit one range list, which spans all of the
798// executable sections of this file.
799static void EmitGenDwarfRanges(MCStreamer *MCOS) {
800 MCContext &context = MCOS->getContext();
801 auto &Sections = context.getGenDwarfSectionSyms();
802
803 const MCAsmInfo *AsmInfo = context.getAsmInfo();
804 int AddrSize = AsmInfo->getPointerSize();
805
806 MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfRangesSection());
807
Rafael Espindola0709a7b2015-05-21 19:20:38 +0000808 for (MCSection *Sec : Sections) {
809 const MCSymbol *StartSymbol = Sec->getBeginSymbol();
Rafael Espindolae0746792015-05-21 16:52:32 +0000810 MCSymbol *EndSymbol = Sec->getEndSymbol(context);
Oliver Stannard8b273082014-06-19 15:52:37 +0000811 assert(StartSymbol && "StartSymbol must not be NULL");
812 assert(EndSymbol && "EndSymbol must not be NULL");
813
814 // Emit a base address selection entry for the start of this section
815 const MCExpr *SectionStartAddr = MCSymbolRefExpr::Create(
816 StartSymbol, MCSymbolRefExpr::VK_None, context);
817 MCOS->EmitFill(AddrSize, 0xFF);
818 MCOS->EmitValue(SectionStartAddr, AddrSize);
819
820 // Emit a range list entry spanning this section
821 const MCExpr *SectionSize = MakeStartMinusEndExpr(*MCOS,
822 *StartSymbol, *EndSymbol, 0);
823 MCOS->EmitIntValue(0, AddrSize);
Rafael Espindolac23174b2014-08-15 15:12:13 +0000824 emitAbsValue(*MCOS, SectionSize, AddrSize);
Oliver Stannard8b273082014-06-19 15:52:37 +0000825 }
826
827 // Emit end of list entry
828 MCOS->EmitIntValue(0, AddrSize);
829 MCOS->EmitIntValue(0, AddrSize);
830}
831
Kevin Enderbye7739d42011-12-09 18:09:40 +0000832//
833// When generating dwarf for assembly source files this emits the Dwarf
834// sections.
835//
David Blaikie8bf66c42014-04-01 07:35:52 +0000836void MCGenDwarfInfo::Emit(MCStreamer *MCOS) {
Kevin Enderbye7739d42011-12-09 18:09:40 +0000837 MCContext &context = MCOS->getContext();
Oliver Stannard8b273082014-06-19 15:52:37 +0000838
839 // Create the dwarf sections in this order (.debug_line already created).
Bill Wendlingbc07a892013-06-18 07:20:20 +0000840 const MCAsmInfo *AsmInfo = context.getAsmInfo();
Alexey Samsonov00fd5252012-11-14 09:55:38 +0000841 bool CreateDwarfSectionSymbols =
Bill Wendlingbc07a892013-06-18 07:20:20 +0000842 AsmInfo->doesDwarfUseRelocationsAcrossSections();
David Blaikie8bf66c42014-04-01 07:35:52 +0000843 MCSymbol *LineSectionSymbol = nullptr;
David Blaikie34641612014-04-01 08:07:52 +0000844 if (CreateDwarfSectionSymbols)
845 LineSectionSymbol = MCOS->getDwarfLineTableSymbol(0);
Craig Topperbb694de2014-04-13 04:57:38 +0000846 MCSymbol *AbbrevSectionSymbol = nullptr;
847 MCSymbol *InfoSectionSymbol = nullptr;
Oliver Stannard8b273082014-06-19 15:52:37 +0000848 MCSymbol *RangesSectionSymbol = NULL;
849
850 // Create end symbols for each section, and remove empty sections
851 MCOS->getContext().finalizeDwarfSections(*MCOS);
852
853 // If there are no sections to generate debug info for, we don't need
854 // to do anything
855 if (MCOS->getContext().getGenDwarfSectionSyms().empty())
856 return;
857
Oliver Stannard14f97d02014-09-22 10:45:16 +0000858 // We only use the .debug_ranges section if we have multiple code sections,
859 // and we are emitting a DWARF version which supports it.
Oliver Stannard8b273082014-06-19 15:52:37 +0000860 const bool UseRangesSection =
Oliver Stannard14f97d02014-09-22 10:45:16 +0000861 MCOS->getContext().getGenDwarfSectionSyms().size() > 1 &&
862 MCOS->getContext().getDwarfVersion() >= 3;
Oliver Stannard8b273082014-06-19 15:52:37 +0000863 CreateDwarfSectionSymbols |= UseRangesSection;
864
Kevin Enderbye7739d42011-12-09 18:09:40 +0000865 MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfInfoSection());
Alexey Samsonov00fd5252012-11-14 09:55:38 +0000866 if (CreateDwarfSectionSymbols) {
Jim Grosbach6f482002015-05-18 18:43:14 +0000867 InfoSectionSymbol = context.createTempSymbol();
Alexey Samsonov00fd5252012-11-14 09:55:38 +0000868 MCOS->EmitLabel(InfoSectionSymbol);
869 }
Kevin Enderbye7739d42011-12-09 18:09:40 +0000870 MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfAbbrevSection());
Alexey Samsonov00fd5252012-11-14 09:55:38 +0000871 if (CreateDwarfSectionSymbols) {
Jim Grosbach6f482002015-05-18 18:43:14 +0000872 AbbrevSectionSymbol = context.createTempSymbol();
Rafael Espindolac22c85c2012-02-28 21:13:05 +0000873 MCOS->EmitLabel(AbbrevSectionSymbol);
Rafael Espindolac22c85c2012-02-28 21:13:05 +0000874 }
Oliver Stannard8b273082014-06-19 15:52:37 +0000875 if (UseRangesSection) {
876 MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfRangesSection());
877 if (CreateDwarfSectionSymbols) {
Jim Grosbach6f482002015-05-18 18:43:14 +0000878 RangesSectionSymbol = context.createTempSymbol();
Oliver Stannard8b273082014-06-19 15:52:37 +0000879 MCOS->EmitLabel(RangesSectionSymbol);
880 }
881 }
Kevin Enderbye7739d42011-12-09 18:09:40 +0000882
Oliver Stannard8b273082014-06-19 15:52:37 +0000883 assert((RangesSectionSymbol != NULL) || !UseRangesSection);
884
885 MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfARangesSection());
Kevin Enderbye7739d42011-12-09 18:09:40 +0000886
887 // Output the data for .debug_aranges section.
Alexey Samsonov00fd5252012-11-14 09:55:38 +0000888 EmitGenDwarfAranges(MCOS, InfoSectionSymbol);
Kevin Enderbye7739d42011-12-09 18:09:40 +0000889
Oliver Stannard8b273082014-06-19 15:52:37 +0000890 if (UseRangesSection)
891 EmitGenDwarfRanges(MCOS);
892
Kevin Enderbye7739d42011-12-09 18:09:40 +0000893 // Output the data for .debug_abbrev section.
894 EmitGenDwarfAbbrev(MCOS);
895
896 // Output the data for .debug_info section.
Oliver Stannard8b273082014-06-19 15:52:37 +0000897 EmitGenDwarfInfo(MCOS, AbbrevSectionSymbol, LineSectionSymbol,
898 RangesSectionSymbol);
Kevin Enderbye7739d42011-12-09 18:09:40 +0000899}
900
901//
902// When generating dwarf for assembly source files this is called when symbol
903// for a label is created. If this symbol is not a temporary and is in the
904// section that dwarf is being generated for, save the needed info to create
Kevin Enderbyf7d77062012-01-10 21:12:34 +0000905// a dwarf label.
Kevin Enderbye7739d42011-12-09 18:09:40 +0000906//
Kevin Enderbyf7d77062012-01-10 21:12:34 +0000907void MCGenDwarfLabelEntry::Make(MCSymbol *Symbol, MCStreamer *MCOS,
Kevin Enderbye7739d42011-12-09 18:09:40 +0000908 SourceMgr &SrcMgr, SMLoc &Loc) {
Oliver Stannard8b273082014-06-19 15:52:37 +0000909 // We won't create dwarf labels for temporary symbols.
Kevin Enderbye7739d42011-12-09 18:09:40 +0000910 if (Symbol->isTemporary())
911 return;
912 MCContext &context = MCOS->getContext();
Oliver Stannard8b273082014-06-19 15:52:37 +0000913 // We won't create dwarf labels for symbols in sections that we are not
914 // generating debug info for.
915 if (!context.getGenDwarfSectionSyms().count(MCOS->getCurrentSection().first))
Kevin Enderbye7739d42011-12-09 18:09:40 +0000916 return;
917
Kevin Enderbyf7d77062012-01-10 21:12:34 +0000918 // The dwarf label's name does not have the symbol name's leading
Kevin Enderbye7739d42011-12-09 18:09:40 +0000919 // underbar if any.
920 StringRef Name = Symbol->getName();
921 if (Name.startswith("_"))
922 Name = Name.substr(1, Name.size()-1);
923
Kevin Enderbyf7d77062012-01-10 21:12:34 +0000924 // Get the dwarf file number to be used for the dwarf label.
Kevin Enderbye7739d42011-12-09 18:09:40 +0000925 unsigned FileNumber = context.getGenDwarfFileNumber();
926
927 // Finding the line number is the expensive part which is why we just don't
Kevin Enderbyf7d77062012-01-10 21:12:34 +0000928 // pass it in as for some symbols we won't create a dwarf label.
Alp Tokera55b95b2014-07-06 10:33:31 +0000929 unsigned CurBuffer = SrcMgr.FindBufferContainingLoc(Loc);
Kevin Enderbye7739d42011-12-09 18:09:40 +0000930 unsigned LineNumber = SrcMgr.FindLineNumber(Loc, CurBuffer);
931
932 // We create a temporary symbol for use for the AT_high_pc and AT_low_pc
933 // values so that they don't have things like an ARM thumb bit from the
934 // original symbol. So when used they won't get a low bit set after
935 // relocation.
Jim Grosbach6f482002015-05-18 18:43:14 +0000936 MCSymbol *Label = context.createTempSymbol();
Kevin Enderbye7739d42011-12-09 18:09:40 +0000937 MCOS->EmitLabel(Label);
938
939 // Create and entry for the info and add it to the other entries.
David Blaikie1e0fc8f2014-04-11 00:43:52 +0000940 MCOS->getContext().addMCGenDwarfLabelEntry(
941 MCGenDwarfLabelEntry(Name, FileNumber, LineNumber, Label));
Kevin Enderbye7739d42011-12-09 18:09:40 +0000942}
943
Rafael Espindola0a017a62010-12-10 07:39:47 +0000944static int getDataAlignmentFactor(MCStreamer &streamer) {
945 MCContext &context = streamer.getContext();
Bill Wendlingbc07a892013-06-18 07:20:20 +0000946 const MCAsmInfo *asmInfo = context.getAsmInfo();
947 int size = asmInfo->getCalleeSaveStackSlotSize();
948 if (asmInfo->isStackGrowthDirectionUp())
Rafael Espindola0a017a62010-12-10 07:39:47 +0000949 return size;
Evan Chenga83b37a2011-07-15 02:09:41 +0000950 else
951 return -size;
Rafael Espindola0a017a62010-12-10 07:39:47 +0000952}
953
Rafael Espindola5395f442011-04-22 00:08:43 +0000954static unsigned getSizeForEncoding(MCStreamer &streamer,
955 unsigned symbolEncoding) {
Rafael Espindola1de2dd02010-12-27 15:56:22 +0000956 MCContext &context = streamer.getContext();
Rafael Espindola1de2dd02010-12-27 15:56:22 +0000957 unsigned format = symbolEncoding & 0x0f;
Rafael Espindola1de2dd02010-12-27 15:56:22 +0000958 switch (format) {
Craig Toppera2886c22012-02-07 05:05:23 +0000959 default: llvm_unreachable("Unknown Encoding");
Rafael Espindola1de2dd02010-12-27 15:56:22 +0000960 case dwarf::DW_EH_PE_absptr:
961 case dwarf::DW_EH_PE_signed:
Bill Wendlingbc07a892013-06-18 07:20:20 +0000962 return context.getAsmInfo()->getPointerSize();
Rafael Espindola1de2dd02010-12-27 15:56:22 +0000963 case dwarf::DW_EH_PE_udata2:
964 case dwarf::DW_EH_PE_sdata2:
Rafael Espindola5395f442011-04-22 00:08:43 +0000965 return 2;
Rafael Espindola1de2dd02010-12-27 15:56:22 +0000966 case dwarf::DW_EH_PE_udata4:
967 case dwarf::DW_EH_PE_sdata4:
Rafael Espindola5395f442011-04-22 00:08:43 +0000968 return 4;
Rafael Espindola1de2dd02010-12-27 15:56:22 +0000969 case dwarf::DW_EH_PE_udata8:
970 case dwarf::DW_EH_PE_sdata8:
Rafael Espindola5395f442011-04-22 00:08:43 +0000971 return 8;
Rafael Espindola1de2dd02010-12-27 15:56:22 +0000972 }
Rafael Espindola5395f442011-04-22 00:08:43 +0000973}
974
Rafael Espindolafe963b12014-08-15 03:07:13 +0000975static void emitFDESymbol(MCObjectStreamer &streamer, const MCSymbol &symbol,
976 unsigned symbolEncoding, bool isEH) {
Rafael Espindola6bd6a702011-04-28 21:04:39 +0000977 MCContext &context = streamer.getContext();
Bill Wendlingbc07a892013-06-18 07:20:20 +0000978 const MCAsmInfo *asmInfo = context.getAsmInfo();
979 const MCExpr *v = asmInfo->getExprForFDESymbol(&symbol,
980 symbolEncoding,
981 streamer);
Rafael Espindola5395f442011-04-22 00:08:43 +0000982 unsigned size = getSizeForEncoding(streamer, symbolEncoding);
Iain Sandoe618def62014-01-08 10:22:54 +0000983 if (asmInfo->doDwarfFDESymbolsUseAbsDiff() && isEH)
Rafael Espindolac23174b2014-08-15 15:12:13 +0000984 emitAbsValue(streamer, v, size);
Iain Sandoe618def62014-01-08 10:22:54 +0000985 else
986 streamer.EmitValue(v, size);
Rafael Espindola1de2dd02010-12-27 15:56:22 +0000987}
988
Rafael Espindolac5dac4d2011-04-28 16:09:09 +0000989static void EmitPersonality(MCStreamer &streamer, const MCSymbol &symbol,
990 unsigned symbolEncoding) {
991 MCContext &context = streamer.getContext();
Bill Wendlingbc07a892013-06-18 07:20:20 +0000992 const MCAsmInfo *asmInfo = context.getAsmInfo();
993 const MCExpr *v = asmInfo->getExprForPersonalitySymbol(&symbol,
994 symbolEncoding,
995 streamer);
Rafael Espindolac5dac4d2011-04-28 16:09:09 +0000996 unsigned size = getSizeForEncoding(streamer, symbolEncoding);
Rafael Espindolafd057852011-05-01 03:50:49 +0000997 streamer.EmitValue(v, size);
Rafael Espindolac5dac4d2011-04-28 16:09:09 +0000998}
999
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001000namespace {
1001 class FrameEmitterImpl {
1002 int CFAOffset;
Rafael Espindola8b4817b2015-03-24 21:47:31 +00001003 int InitialCFAOffset;
Rafael Espindola1ecb12f2011-05-10 03:54:12 +00001004 bool IsEH;
Rafael Espindola99f67352011-05-10 20:59:42 +00001005 const MCSymbol *SectionStart;
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001006 public:
Rafael Espindola01ee31b2014-05-12 13:40:49 +00001007 FrameEmitterImpl(bool isEH)
Rafael Espindola8b4817b2015-03-24 21:47:31 +00001008 : CFAOffset(0), InitialCFAOffset(0), IsEH(isEH), SectionStart(nullptr) {
1009 }
Bill Wendling4d9aa512011-07-22 21:18:59 +00001010
1011 void setSectionStart(const MCSymbol *Label) { SectionStart = Label; }
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001012
Rafael Espindolafe963b12014-08-15 03:07:13 +00001013 /// Emit the unwind information in a compact way.
1014 void EmitCompactUnwind(MCObjectStreamer &streamer,
Bill Wendlinge8fc92a2011-06-23 01:06:23 +00001015 const MCDwarfFrameInfo &frame);
1016
Rafael Espindola1bb4a3f2014-05-12 14:40:12 +00001017 const MCSymbol &EmitCIE(MCObjectStreamer &streamer,
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001018 const MCSymbol *personality,
1019 unsigned personalityEncoding,
1020 const MCSymbol *lsda,
Rafael Espindola3c47e372012-01-23 21:51:52 +00001021 bool IsSignalFrame,
David Majnemere035cf92014-01-27 17:20:25 +00001022 unsigned lsdaEncoding,
1023 bool IsSimple);
Rafael Espindola1bb4a3f2014-05-12 14:40:12 +00001024 MCSymbol *EmitFDE(MCObjectStreamer &streamer,
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001025 const MCSymbol &cieStart,
Rafael Espindola0e130d12011-05-10 03:01:39 +00001026 const MCDwarfFrameInfo &frame);
Rafael Espindola1bb4a3f2014-05-12 14:40:12 +00001027 void EmitCFIInstructions(MCObjectStreamer &streamer,
Bill Wendling10543922013-09-04 22:35:29 +00001028 ArrayRef<MCCFIInstruction> Instrs,
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001029 MCSymbol *BaseLabel);
Rafael Espindola1bb4a3f2014-05-12 14:40:12 +00001030 void EmitCFIInstruction(MCObjectStreamer &Streamer,
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001031 const MCCFIInstruction &Instr);
1032 };
Bill Wendling567a1ae2011-06-30 21:25:51 +00001033
1034} // end anonymous namespace
1035
Rafael Espindolafe963b12014-08-15 03:07:13 +00001036static void emitEncodingByte(MCObjectStreamer &Streamer, unsigned Encoding) {
Bill Wendling567a1ae2011-06-30 21:25:51 +00001037 Streamer.EmitIntValue(Encoding, 1);
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001038}
1039
Rafael Espindola1bb4a3f2014-05-12 14:40:12 +00001040void FrameEmitterImpl::EmitCFIInstruction(MCObjectStreamer &Streamer,
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001041 const MCCFIInstruction &Instr) {
1042 int dataAlignmentFactor = getDataAlignmentFactor(Streamer);
Frederic Rissadbb3f22015-02-26 19:48:07 +00001043 auto *MRI = Streamer.getContext().getRegisterInfo();
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001044
1045 switch (Instr.getOperation()) {
Rafael Espindolacdb9a532012-11-25 15:14:49 +00001046 case MCCFIInstruction::OpRegister: {
1047 unsigned Reg1 = Instr.getRegister();
1048 unsigned Reg2 = Instr.getRegister2();
Frederic Rissadbb3f22015-02-26 19:48:07 +00001049 if (!IsEH) {
1050 Reg1 = MRI->getDwarfRegNum(MRI->getLLVMRegNum(Reg1, true), false);
1051 Reg2 = MRI->getDwarfRegNum(MRI->getLLVMRegNum(Reg2, true), false);
1052 }
Rafael Espindolacdb9a532012-11-25 15:14:49 +00001053 Streamer.EmitIntValue(dwarf::DW_CFA_register, 1);
1054 Streamer.EmitULEB128IntValue(Reg1);
1055 Streamer.EmitULEB128IntValue(Reg2);
1056 return;
1057 }
Venkatraman Govindaraju3816d432013-09-26 14:49:40 +00001058 case MCCFIInstruction::OpWindowSave: {
1059 Streamer.EmitIntValue(dwarf::DW_CFA_GNU_window_save, 1);
1060 return;
1061 }
Rafael Espindola5dce65b2012-11-24 03:10:54 +00001062 case MCCFIInstruction::OpUndefined: {
Rafael Espindolacc0c74a2012-11-24 04:33:48 +00001063 unsigned Reg = Instr.getRegister();
Rafael Espindola9bb24782012-11-23 16:59:41 +00001064 Streamer.EmitIntValue(dwarf::DW_CFA_undefined, 1);
1065 Streamer.EmitULEB128IntValue(Reg);
1066 return;
1067 }
Rafael Espindola5dce65b2012-11-24 03:10:54 +00001068 case MCCFIInstruction::OpAdjustCfaOffset:
1069 case MCCFIInstruction::OpDefCfaOffset: {
Rafael Espindola5dce65b2012-11-24 03:10:54 +00001070 const bool IsRelative =
1071 Instr.getOperation() == MCCFIInstruction::OpAdjustCfaOffset;
1072
Rafael Espindola5dce65b2012-11-24 03:10:54 +00001073 Streamer.EmitIntValue(dwarf::DW_CFA_def_cfa_offset, 1);
1074
1075 if (IsRelative)
Rafael Espindolacc0c74a2012-11-24 04:33:48 +00001076 CFAOffset += Instr.getOffset();
Rafael Espindola5dce65b2012-11-24 03:10:54 +00001077 else
Rafael Espindolacc0c74a2012-11-24 04:33:48 +00001078 CFAOffset = -Instr.getOffset();
Rafael Espindola5dce65b2012-11-24 03:10:54 +00001079
Rafael Espindola5dce65b2012-11-24 03:10:54 +00001080 Streamer.EmitULEB128IntValue(CFAOffset);
1081
1082 return;
1083 }
1084 case MCCFIInstruction::OpDefCfa: {
Frederic Rissadbb3f22015-02-26 19:48:07 +00001085 unsigned Reg = Instr.getRegister();
1086 if (!IsEH)
1087 Reg = MRI->getDwarfRegNum(MRI->getLLVMRegNum(Reg, true), false);
Rafael Espindola5dce65b2012-11-24 03:10:54 +00001088 Streamer.EmitIntValue(dwarf::DW_CFA_def_cfa, 1);
Frederic Rissadbb3f22015-02-26 19:48:07 +00001089 Streamer.EmitULEB128IntValue(Reg);
Rafael Espindolacc0c74a2012-11-24 04:33:48 +00001090 CFAOffset = -Instr.getOffset();
Rafael Espindola5dce65b2012-11-24 03:10:54 +00001091 Streamer.EmitULEB128IntValue(CFAOffset);
1092
1093 return;
1094 }
1095
1096 case MCCFIInstruction::OpDefCfaRegister: {
Frederic Rissadbb3f22015-02-26 19:48:07 +00001097 unsigned Reg = Instr.getRegister();
1098 if (!IsEH)
1099 Reg = MRI->getDwarfRegNum(MRI->getLLVMRegNum(Reg, true), false);
Rafael Espindola5dce65b2012-11-24 03:10:54 +00001100 Streamer.EmitIntValue(dwarf::DW_CFA_def_cfa_register, 1);
Frederic Rissadbb3f22015-02-26 19:48:07 +00001101 Streamer.EmitULEB128IntValue(Reg);
Rafael Espindola5dce65b2012-11-24 03:10:54 +00001102
1103 return;
1104 }
1105
1106 case MCCFIInstruction::OpOffset:
1107 case MCCFIInstruction::OpRelOffset: {
Rafael Espindola5dce65b2012-11-24 03:10:54 +00001108 const bool IsRelative =
1109 Instr.getOperation() == MCCFIInstruction::OpRelOffset;
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001110
Rafael Espindolacc0c74a2012-11-24 04:33:48 +00001111 unsigned Reg = Instr.getRegister();
Frederic Rissadbb3f22015-02-26 19:48:07 +00001112 if (!IsEH)
1113 Reg = MRI->getDwarfRegNum(MRI->getLLVMRegNum(Reg, true), false);
1114
Rafael Espindolacc0c74a2012-11-24 04:33:48 +00001115 int Offset = Instr.getOffset();
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001116 if (IsRelative)
1117 Offset -= CFAOffset;
1118 Offset = Offset / dataAlignmentFactor;
1119
1120 if (Offset < 0) {
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001121 Streamer.EmitIntValue(dwarf::DW_CFA_offset_extended_sf, 1);
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001122 Streamer.EmitULEB128IntValue(Reg);
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001123 Streamer.EmitSLEB128IntValue(Offset);
1124 } else if (Reg < 64) {
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001125 Streamer.EmitIntValue(dwarf::DW_CFA_offset + Reg, 1);
Rafael Espindolaea61f222011-04-21 23:26:40 +00001126 Streamer.EmitULEB128IntValue(Offset);
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001127 } else {
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001128 Streamer.EmitIntValue(dwarf::DW_CFA_offset_extended, 1);
Rafael Espindolaea61f222011-04-21 23:26:40 +00001129 Streamer.EmitULEB128IntValue(Reg);
Rafael Espindolaea61f222011-04-21 23:26:40 +00001130 Streamer.EmitULEB128IntValue(Offset);
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001131 }
1132 return;
1133 }
Rafael Espindola5dce65b2012-11-24 03:10:54 +00001134 case MCCFIInstruction::OpRememberState:
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001135 Streamer.EmitIntValue(dwarf::DW_CFA_remember_state, 1);
1136 return;
Rafael Espindola5dce65b2012-11-24 03:10:54 +00001137 case MCCFIInstruction::OpRestoreState:
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001138 Streamer.EmitIntValue(dwarf::DW_CFA_restore_state, 1);
1139 return;
Rafael Espindola5dce65b2012-11-24 03:10:54 +00001140 case MCCFIInstruction::OpSameValue: {
Rafael Espindolacc0c74a2012-11-24 04:33:48 +00001141 unsigned Reg = Instr.getRegister();
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001142 Streamer.EmitIntValue(dwarf::DW_CFA_same_value, 1);
Rafael Espindola6aea5922011-04-21 23:39:26 +00001143 Streamer.EmitULEB128IntValue(Reg);
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001144 return;
1145 }
Rafael Espindola5dce65b2012-11-24 03:10:54 +00001146 case MCCFIInstruction::OpRestore: {
Rafael Espindolacc0c74a2012-11-24 04:33:48 +00001147 unsigned Reg = Instr.getRegister();
Frederic Rissadbb3f22015-02-26 19:48:07 +00001148 if (!IsEH)
1149 Reg = MRI->getDwarfRegNum(MRI->getLLVMRegNum(Reg, true), false);
Rafael Espindola4ea99812011-12-29 21:43:03 +00001150 Streamer.EmitIntValue(dwarf::DW_CFA_restore | Reg, 1);
1151 return;
1152 }
Rafael Espindola5dce65b2012-11-24 03:10:54 +00001153 case MCCFIInstruction::OpEscape:
Eric Christophere3ab3d02013-01-09 01:57:54 +00001154 Streamer.EmitBytes(Instr.getValues());
Rafael Espindolaef4aa352011-12-29 20:24:47 +00001155 return;
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001156 }
1157 llvm_unreachable("Unhandled case in switch");
1158}
1159
Rafael Espindolafe963b12014-08-15 03:07:13 +00001160/// Emit frame instructions to describe the layout of the frame.
Rafael Espindola1bb4a3f2014-05-12 14:40:12 +00001161void FrameEmitterImpl::EmitCFIInstructions(MCObjectStreamer &streamer,
Bill Wendling10543922013-09-04 22:35:29 +00001162 ArrayRef<MCCFIInstruction> Instrs,
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001163 MCSymbol *BaseLabel) {
1164 for (unsigned i = 0, N = Instrs.size(); i < N; ++i) {
1165 const MCCFIInstruction &Instr = Instrs[i];
1166 MCSymbol *Label = Instr.getLabel();
1167 // Throw out move if the label is invalid.
1168 if (Label && !Label->isDefined()) continue; // Not emitted, in dead code.
1169
1170 // Advance row if new location.
1171 if (BaseLabel && Label) {
1172 MCSymbol *ThisSym = Label;
1173 if (ThisSym != BaseLabel) {
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001174 streamer.EmitDwarfAdvanceFrameAddr(BaseLabel, ThisSym);
1175 BaseLabel = ThisSym;
1176 }
1177 }
1178
1179 EmitCFIInstruction(streamer, Instr);
1180 }
1181}
1182
Rafael Espindolafe963b12014-08-15 03:07:13 +00001183/// Emit the unwind information in a compact way.
1184void FrameEmitterImpl::EmitCompactUnwind(MCObjectStreamer &Streamer,
Bill Wendlinge8fc92a2011-06-23 01:06:23 +00001185 const MCDwarfFrameInfo &Frame) {
Bill Wendlinge8fc92a2011-06-23 01:06:23 +00001186 MCContext &Context = Streamer.getContext();
Evan Cheng76792992011-07-20 05:58:47 +00001187 const MCObjectFileInfo *MOFI = Context.getObjectFileInfo();
Bill Wendlinge8fc92a2011-06-23 01:06:23 +00001188
Bill Wendlinge8fc92a2011-06-23 01:06:23 +00001189 // range-start range-length compact-unwind-enc personality-func lsda
1190 // _foo LfooEnd-_foo 0x00000023 0 0
1191 // _bar LbarEnd-_bar 0x00000025 __gxx_personality except_tab1
1192 //
1193 // .section __LD,__compact_unwind,regular,debug
1194 //
1195 // # compact unwind for _foo
1196 // .quad _foo
1197 // .set L1,LfooEnd-_foo
1198 // .long L1
1199 // .long 0x01010001
1200 // .quad 0
1201 // .quad 0
1202 //
1203 // # compact unwind for _bar
1204 // .quad _bar
1205 // .set L2,LbarEnd-_bar
1206 // .long L2
1207 // .long 0x01020011
1208 // .quad __gxx_personality
1209 // .quad except_tab1
1210
Bill Wendling49bc6802011-07-19 00:06:12 +00001211 uint32_t Encoding = Frame.CompactUnwindEncoding;
Bill Wendling99bce5f2013-04-18 23:16:46 +00001212 if (!Encoding) return;
Bill Wendling2d1df6b2013-04-10 21:42:06 +00001213 bool DwarfEHFrameOnly = (Encoding == MOFI->getCompactUnwindDwarfEHFrameOnly());
Bill Wendlingb6adf462011-07-07 00:54:13 +00001214
Bill Wendlingdafd5982011-07-14 23:34:45 +00001215 // The encoding needs to know we have an LSDA.
Bill Wendling2d1df6b2013-04-10 21:42:06 +00001216 if (!DwarfEHFrameOnly && Frame.Lsda)
Bill Wendlingdafd5982011-07-14 23:34:45 +00001217 Encoding |= 0x40000000;
1218
Bill Wendlinge8fc92a2011-06-23 01:06:23 +00001219 // Range Start
Rafael Espindolaaa7851d2014-05-12 13:47:05 +00001220 unsigned FDEEncoding = MOFI->getFDEEncoding();
Bill Wendling8fa4ada2011-06-29 23:49:12 +00001221 unsigned Size = getSizeForEncoding(Streamer, FDEEncoding);
Rafael Espindola88604822014-06-23 15:34:32 +00001222 Streamer.EmitSymbolValue(Frame.Begin, Size);
Bill Wendlinge8fc92a2011-06-23 01:06:23 +00001223
1224 // Range Length
1225 const MCExpr *Range = MakeStartMinusEndExpr(Streamer, *Frame.Begin,
1226 *Frame.End, 0);
Rafael Espindolac23174b2014-08-15 15:12:13 +00001227 emitAbsValue(Streamer, Range, 4);
Bill Wendling75174662011-06-30 00:30:52 +00001228
Bill Wendling75174662011-06-30 00:30:52 +00001229 // Compact Encoding
Bill Wendling75174662011-06-30 00:30:52 +00001230 Size = getSizeForEncoding(Streamer, dwarf::DW_EH_PE_udata4);
Bill Wendling75174662011-06-30 00:30:52 +00001231 Streamer.EmitIntValue(Encoding, Size);
1232
Bill Wendling8fa4ada2011-06-29 23:49:12 +00001233 // Personality Function
Bill Wendlingdafd5982011-07-14 23:34:45 +00001234 Size = getSizeForEncoding(Streamer, dwarf::DW_EH_PE_absptr);
Bill Wendling2d1df6b2013-04-10 21:42:06 +00001235 if (!DwarfEHFrameOnly && Frame.Personality)
Bill Wendling8fa4ada2011-06-29 23:49:12 +00001236 Streamer.EmitSymbolValue(Frame.Personality, Size);
Bill Wendling4cdb2062011-06-29 23:53:16 +00001237 else
1238 Streamer.EmitIntValue(0, Size); // No personality fn
Bill Wendling8fa4ada2011-06-29 23:49:12 +00001239
1240 // LSDA
Bill Wendling4cdb2062011-06-29 23:53:16 +00001241 Size = getSizeForEncoding(Streamer, Frame.LsdaEncoding);
Bill Wendling2d1df6b2013-04-10 21:42:06 +00001242 if (!DwarfEHFrameOnly && Frame.Lsda)
Bill Wendling8fa4ada2011-06-29 23:49:12 +00001243 Streamer.EmitSymbolValue(Frame.Lsda, Size);
Bill Wendling4cdb2062011-06-29 23:53:16 +00001244 else
1245 Streamer.EmitIntValue(0, Size); // No LSDA
Bill Wendlinge8fc92a2011-06-23 01:06:23 +00001246}
1247
Rafael Espindolaeffdc7e2015-04-28 13:55:31 +00001248static unsigned getCIEVersion(bool IsEH, unsigned DwarfVersion) {
1249 if (IsEH)
1250 return 1;
1251 switch (DwarfVersion) {
1252 case 2:
1253 return 1;
1254 case 3:
1255 return 3;
1256 case 4:
1257 return 4;
1258 }
1259 llvm_unreachable("Unknown version");
1260}
1261
Rafael Espindola1bb4a3f2014-05-12 14:40:12 +00001262const MCSymbol &FrameEmitterImpl::EmitCIE(MCObjectStreamer &streamer,
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001263 const MCSymbol *personality,
1264 unsigned personalityEncoding,
1265 const MCSymbol *lsda,
Rafael Espindola3c47e372012-01-23 21:51:52 +00001266 bool IsSignalFrame,
David Majnemere035cf92014-01-27 17:20:25 +00001267 unsigned lsdaEncoding,
1268 bool IsSimple) {
Rafael Espindola0a017a62010-12-10 07:39:47 +00001269 MCContext &context = streamer.getContext();
Bill Wendlingbc07a892013-06-18 07:20:20 +00001270 const MCRegisterInfo *MRI = context.getRegisterInfo();
Evan Cheng76792992011-07-20 05:58:47 +00001271 const MCObjectFileInfo *MOFI = context.getObjectFileInfo();
Rafael Espindolabf60fb02011-04-28 03:26:11 +00001272
Jim Grosbach6f482002015-05-18 18:43:14 +00001273 MCSymbol *sectionStart = context.createTempSymbol();
Bill Wendling567a1ae2011-06-30 21:25:51 +00001274 streamer.EmitLabel(sectionStart);
Rafael Espindolabf60fb02011-04-28 03:26:11 +00001275
Jim Grosbach6f482002015-05-18 18:43:14 +00001276 MCSymbol *sectionEnd = context.createTempSymbol();
Rafael Espindola0a017a62010-12-10 07:39:47 +00001277
1278 // Length
1279 const MCExpr *Length = MakeStartMinusEndExpr(streamer, *sectionStart,
1280 *sectionEnd, 4);
Rafael Espindolac23174b2014-08-15 15:12:13 +00001281 emitAbsValue(streamer, Length, 4);
Rafael Espindola0a017a62010-12-10 07:39:47 +00001282
1283 // CIE ID
Rafael Espindola1ecb12f2011-05-10 03:54:12 +00001284 unsigned CIE_ID = IsEH ? 0 : -1;
Rafael Espindola1ecb12f2011-05-10 03:54:12 +00001285 streamer.EmitIntValue(CIE_ID, 4);
Rafael Espindola0a017a62010-12-10 07:39:47 +00001286
1287 // Version
Rafael Espindolaeffdc7e2015-04-28 13:55:31 +00001288 uint8_t CIEVersion = getCIEVersion(IsEH, context.getDwarfVersion());
Oliver Stannardf7693f42014-06-19 15:39:33 +00001289 streamer.EmitIntValue(CIEVersion, 1);
Rafael Espindola0a017a62010-12-10 07:39:47 +00001290
1291 // Augmentation String
1292 SmallString<8> Augmentation;
Rafael Espindola1ecb12f2011-05-10 03:54:12 +00001293 if (IsEH) {
Rafael Espindola1ecb12f2011-05-10 03:54:12 +00001294 Augmentation += "z";
1295 if (personality)
1296 Augmentation += "P";
1297 if (lsda)
1298 Augmentation += "L";
1299 Augmentation += "R";
Rafael Espindola3c47e372012-01-23 21:51:52 +00001300 if (IsSignalFrame)
1301 Augmentation += "S";
Yaron Keren92e1b622015-03-18 10:17:07 +00001302 streamer.EmitBytes(Augmentation);
Rafael Espindola1ecb12f2011-05-10 03:54:12 +00001303 }
Rafael Espindola0a017a62010-12-10 07:39:47 +00001304 streamer.EmitIntValue(0, 1);
1305
Keith Walkerea9483f2015-05-12 15:25:08 +00001306 if (CIEVersion >= 4) {
1307 // Address Size
1308 streamer.EmitIntValue(context.getAsmInfo()->getPointerSize(), 1);
1309
1310 // Segment Descriptor Size
1311 streamer.EmitIntValue(0, 1);
1312 }
1313
Rafael Espindola0a017a62010-12-10 07:39:47 +00001314 // Code Alignment Factor
Bill Wendlingbc07a892013-06-18 07:20:20 +00001315 streamer.EmitULEB128IntValue(context.getAsmInfo()->getMinInstAlignment());
Rafael Espindola0a017a62010-12-10 07:39:47 +00001316
1317 // Data Alignment Factor
Rafael Espindola0a017a62010-12-10 07:39:47 +00001318 streamer.EmitSLEB128IntValue(getDataAlignmentFactor(streamer));
1319
1320 // Return Address Register
Oliver Stannardf7693f42014-06-19 15:39:33 +00001321 if (CIEVersion == 1) {
1322 assert(MRI->getRARegister() <= 255 &&
1323 "DWARF 2 encodes return_address_register in one byte");
Frederic Rissadbb3f22015-02-26 19:48:07 +00001324 streamer.EmitIntValue(MRI->getDwarfRegNum(MRI->getRARegister(), IsEH), 1);
Oliver Stannardf7693f42014-06-19 15:39:33 +00001325 } else {
1326 streamer.EmitULEB128IntValue(
Frederic Rissadbb3f22015-02-26 19:48:07 +00001327 MRI->getDwarfRegNum(MRI->getRARegister(), IsEH));
Oliver Stannardf7693f42014-06-19 15:39:33 +00001328 }
Rafael Espindola0a017a62010-12-10 07:39:47 +00001329
1330 // Augmentation Data Length (optional)
Rafael Espindola6a85f9b2011-04-29 21:50:57 +00001331
1332 unsigned augmentationLength = 0;
Rafael Espindola1ecb12f2011-05-10 03:54:12 +00001333 if (IsEH) {
1334 if (personality) {
1335 // Personality Encoding
1336 augmentationLength += 1;
1337 // Personality
1338 augmentationLength += getSizeForEncoding(streamer, personalityEncoding);
1339 }
1340 if (lsda)
1341 augmentationLength += 1;
1342 // Encoding of the FDE pointers
Rafael Espindola6a85f9b2011-04-29 21:50:57 +00001343 augmentationLength += 1;
Rafael Espindola6a85f9b2011-04-29 21:50:57 +00001344
Rafael Espindola1ecb12f2011-05-10 03:54:12 +00001345 streamer.EmitULEB128IntValue(augmentationLength);
Rafael Espindola0a017a62010-12-10 07:39:47 +00001346
Rafael Espindola1ecb12f2011-05-10 03:54:12 +00001347 // Augmentation Data (optional)
1348 if (personality) {
1349 // Personality Encoding
Rafael Espindolafe963b12014-08-15 03:07:13 +00001350 emitEncodingByte(streamer, personalityEncoding);
Rafael Espindola1ecb12f2011-05-10 03:54:12 +00001351 // Personality
Rafael Espindola1ecb12f2011-05-10 03:54:12 +00001352 EmitPersonality(streamer, *personality, personalityEncoding);
1353 }
Bill Wendling567a1ae2011-06-30 21:25:51 +00001354
Rafael Espindola1ecb12f2011-05-10 03:54:12 +00001355 if (lsda)
Rafael Espindolafe963b12014-08-15 03:07:13 +00001356 emitEncodingByte(streamer, lsdaEncoding);
Bill Wendling567a1ae2011-06-30 21:25:51 +00001357
Rafael Espindola1ecb12f2011-05-10 03:54:12 +00001358 // Encoding of the FDE pointers
Rafael Espindolafe963b12014-08-15 03:07:13 +00001359 emitEncodingByte(streamer, MOFI->getFDEEncoding());
Rafael Espindola1de2dd02010-12-27 15:56:22 +00001360 }
Rafael Espindola0a017a62010-12-10 07:39:47 +00001361
1362 // Initial Instructions
1363
Bill Wendlingbc07a892013-06-18 07:20:20 +00001364 const MCAsmInfo *MAI = context.getAsmInfo();
David Majnemere035cf92014-01-27 17:20:25 +00001365 if (!IsSimple) {
1366 const std::vector<MCCFIInstruction> &Instructions =
1367 MAI->getInitialFrameState();
Craig Topperbb694de2014-04-13 04:57:38 +00001368 EmitCFIInstructions(streamer, Instructions, nullptr);
David Majnemere035cf92014-01-27 17:20:25 +00001369 }
Rafael Espindola0a017a62010-12-10 07:39:47 +00001370
Rafael Espindola8b4817b2015-03-24 21:47:31 +00001371 InitialCFAOffset = CFAOffset;
1372
Rafael Espindola0a017a62010-12-10 07:39:47 +00001373 // Padding
Bill Wendlingbc07a892013-06-18 07:20:20 +00001374 streamer.EmitValueToAlignment(IsEH ? 4 : MAI->getPointerSize());
Rafael Espindola0a017a62010-12-10 07:39:47 +00001375
1376 streamer.EmitLabel(sectionEnd);
1377 return *sectionStart;
1378}
1379
Rafael Espindola1bb4a3f2014-05-12 14:40:12 +00001380MCSymbol *FrameEmitterImpl::EmitFDE(MCObjectStreamer &streamer,
Rafael Espindola1ec0f462011-04-12 16:12:03 +00001381 const MCSymbol &cieStart,
Rafael Espindola0e130d12011-05-10 03:01:39 +00001382 const MCDwarfFrameInfo &frame) {
Rafael Espindola1de2dd02010-12-27 15:56:22 +00001383 MCContext &context = streamer.getContext();
Jim Grosbach6f482002015-05-18 18:43:14 +00001384 MCSymbol *fdeStart = context.createTempSymbol();
1385 MCSymbol *fdeEnd = context.createTempSymbol();
Evan Cheng76792992011-07-20 05:58:47 +00001386 const MCObjectFileInfo *MOFI = context.getObjectFileInfo();
Rafael Espindola0a017a62010-12-10 07:39:47 +00001387
Rafael Espindola8b4817b2015-03-24 21:47:31 +00001388 CFAOffset = InitialCFAOffset;
1389
Rafael Espindola0a017a62010-12-10 07:39:47 +00001390 // Length
1391 const MCExpr *Length = MakeStartMinusEndExpr(streamer, *fdeStart, *fdeEnd, 0);
Rafael Espindolac23174b2014-08-15 15:12:13 +00001392 emitAbsValue(streamer, Length, 4);
Rafael Espindola0a017a62010-12-10 07:39:47 +00001393
1394 streamer.EmitLabel(fdeStart);
Rafael Espindola99f67352011-05-10 20:59:42 +00001395
Rafael Espindola0a017a62010-12-10 07:39:47 +00001396 // CIE Pointer
Bill Wendlingbc07a892013-06-18 07:20:20 +00001397 const MCAsmInfo *asmInfo = context.getAsmInfo();
Rafael Espindola27390b42011-05-10 15:20:23 +00001398 if (IsEH) {
1399 const MCExpr *offset = MakeStartMinusEndExpr(streamer, cieStart, *fdeStart,
1400 0);
Rafael Espindolac23174b2014-08-15 15:12:13 +00001401 emitAbsValue(streamer, offset, 4);
Bill Wendlingbc07a892013-06-18 07:20:20 +00001402 } else if (!asmInfo->doesDwarfUseRelocationsAcrossSections()) {
Rafael Espindola99f67352011-05-10 20:59:42 +00001403 const MCExpr *offset = MakeStartMinusEndExpr(streamer, *SectionStart,
1404 cieStart, 0);
Rafael Espindolac23174b2014-08-15 15:12:13 +00001405 emitAbsValue(streamer, offset, 4);
Rafael Espindola27390b42011-05-10 15:20:23 +00001406 } else {
1407 streamer.EmitSymbolValue(&cieStart, 4);
1408 }
Bill Wendlingf166ab42011-06-30 22:02:20 +00001409
Rafael Espindola0a017a62010-12-10 07:39:47 +00001410 // PC Begin
Rafael Espindola01ee31b2014-05-12 13:40:49 +00001411 unsigned PCEncoding =
Rafael Espindolaaa7851d2014-05-12 13:47:05 +00001412 IsEH ? MOFI->getFDEEncoding() : (unsigned)dwarf::DW_EH_PE_absptr;
Nick Lewycky333449c2012-08-12 08:09:45 +00001413 unsigned PCSize = getSizeForEncoding(streamer, PCEncoding);
Rafael Espindolafe963b12014-08-15 03:07:13 +00001414 emitFDESymbol(streamer, *frame.Begin, PCEncoding, IsEH);
Rafael Espindola0a017a62010-12-10 07:39:47 +00001415
1416 // PC Range
1417 const MCExpr *Range = MakeStartMinusEndExpr(streamer, *frame.Begin,
1418 *frame.End, 0);
Rafael Espindolac23174b2014-08-15 15:12:13 +00001419 emitAbsValue(streamer, Range, PCSize);
Rafael Espindola0a017a62010-12-10 07:39:47 +00001420
Rafael Espindola1ecb12f2011-05-10 03:54:12 +00001421 if (IsEH) {
1422 // Augmentation Data Length
1423 unsigned augmentationLength = 0;
Rafael Espindola6a85f9b2011-04-29 21:50:57 +00001424
Rafael Espindola1ecb12f2011-05-10 03:54:12 +00001425 if (frame.Lsda)
1426 augmentationLength += getSizeForEncoding(streamer, frame.LsdaEncoding);
Rafael Espindola6a85f9b2011-04-29 21:50:57 +00001427
Rafael Espindola1ecb12f2011-05-10 03:54:12 +00001428 streamer.EmitULEB128IntValue(augmentationLength);
Rafael Espindola0a017a62010-12-10 07:39:47 +00001429
Rafael Espindola1ecb12f2011-05-10 03:54:12 +00001430 // Augmentation Data
1431 if (frame.Lsda)
Rafael Espindolafe963b12014-08-15 03:07:13 +00001432 emitFDESymbol(streamer, *frame.Lsda, frame.LsdaEncoding, true);
Rafael Espindola1ecb12f2011-05-10 03:54:12 +00001433 }
Rafael Espindola68067662011-04-29 03:06:29 +00001434
Rafael Espindola0a017a62010-12-10 07:39:47 +00001435 // Call Frame Instructions
Rafael Espindola290d7162010-12-29 01:42:56 +00001436 EmitCFIInstructions(streamer, frame.Instructions, frame.Begin);
Rafael Espindolaa75b87b2010-12-28 04:15:37 +00001437
Rafael Espindola0a017a62010-12-10 07:39:47 +00001438 // Padding
Nick Lewycky333449c2012-08-12 08:09:45 +00001439 streamer.EmitValueToAlignment(PCSize);
Rafael Espindola32c74ea2010-12-17 00:28:02 +00001440
1441 return fdeEnd;
Rafael Espindola0a017a62010-12-10 07:39:47 +00001442}
1443
Benjamin Kramer570dd782010-12-30 22:34:44 +00001444namespace {
1445 struct CIEKey {
Craig Topperbb694de2014-04-13 04:57:38 +00001446 static const CIEKey getEmptyKey() {
1447 return CIEKey(nullptr, 0, -1, false, false);
1448 }
1449 static const CIEKey getTombstoneKey() {
1450 return CIEKey(nullptr, -1, 0, false, false);
1451 }
Rafael Espindola1de2dd02010-12-27 15:56:22 +00001452
Eric Christopherd29430d2014-06-19 20:00:09 +00001453 CIEKey(const MCSymbol *Personality_, unsigned PersonalityEncoding_,
1454 unsigned LsdaEncoding_, bool IsSignalFrame_, bool IsSimple_)
1455 : Personality(Personality_), PersonalityEncoding(PersonalityEncoding_),
1456 LsdaEncoding(LsdaEncoding_), IsSignalFrame(IsSignalFrame_),
1457 IsSimple(IsSimple_) {}
1458 const MCSymbol *Personality;
Benjamin Kramer570dd782010-12-30 22:34:44 +00001459 unsigned PersonalityEncoding;
1460 unsigned LsdaEncoding;
Rafael Espindola3c47e372012-01-23 21:51:52 +00001461 bool IsSignalFrame;
David Majnemere035cf92014-01-27 17:20:25 +00001462 bool IsSimple;
Benjamin Kramer570dd782010-12-30 22:34:44 +00001463 };
1464}
Rafael Espindola1de2dd02010-12-27 15:56:22 +00001465
1466namespace llvm {
1467 template <>
1468 struct DenseMapInfo<CIEKey> {
1469 static CIEKey getEmptyKey() {
Benjamin Kramer570dd782010-12-30 22:34:44 +00001470 return CIEKey::getEmptyKey();
Rafael Espindola1de2dd02010-12-27 15:56:22 +00001471 }
1472 static CIEKey getTombstoneKey() {
Benjamin Kramer570dd782010-12-30 22:34:44 +00001473 return CIEKey::getTombstoneKey();
Rafael Espindola1de2dd02010-12-27 15:56:22 +00001474 }
1475 static unsigned getHashValue(const CIEKey &Key) {
Benjamin Kramer7a426b52012-04-11 14:06:39 +00001476 return static_cast<unsigned>(hash_combine(Key.Personality,
1477 Key.PersonalityEncoding,
1478 Key.LsdaEncoding,
David Majnemere035cf92014-01-27 17:20:25 +00001479 Key.IsSignalFrame,
1480 Key.IsSimple));
Rafael Espindola1de2dd02010-12-27 15:56:22 +00001481 }
1482 static bool isEqual(const CIEKey &LHS,
1483 const CIEKey &RHS) {
1484 return LHS.Personality == RHS.Personality &&
1485 LHS.PersonalityEncoding == RHS.PersonalityEncoding &&
Rafael Espindola3c47e372012-01-23 21:51:52 +00001486 LHS.LsdaEncoding == RHS.LsdaEncoding &&
David Majnemere035cf92014-01-27 17:20:25 +00001487 LHS.IsSignalFrame == RHS.IsSignalFrame &&
1488 LHS.IsSimple == RHS.IsSimple;
Rafael Espindola1de2dd02010-12-27 15:56:22 +00001489 }
1490 };
1491}
1492
Rafael Espindola4066e8d2014-05-12 14:28:48 +00001493void MCDwarfFrameEmitter::Emit(MCObjectStreamer &Streamer, MCAsmBackend *MAB,
Rafael Espindola8285b772014-05-12 13:34:25 +00001494 bool IsEH) {
Bill Wendling550c76d2013-09-09 19:48:37 +00001495 Streamer.generateCompactUnwindEncodings(MAB);
1496
Bill Wendlinga4b9d1f2011-06-23 07:44:54 +00001497 MCContext &Context = Streamer.getContext();
Bill Wendlinga800f952013-05-30 18:52:57 +00001498 const MCObjectFileInfo *MOFI = Context.getObjectFileInfo();
Rafael Espindola01ee31b2014-05-12 13:40:49 +00001499 FrameEmitterImpl Emitter(IsEH);
Saleem Abdulrasool3f3cefd2014-07-13 19:03:36 +00001500 ArrayRef<MCDwarfFrameInfo> FrameArray = Streamer.getDwarfFrameInfos();
Bill Wendling4d9aa512011-07-22 21:18:59 +00001501
Bill Wendling9803abb2011-09-06 18:37:11 +00001502 // Emit the compact unwind info if available.
Tim Northoverd1c6f512014-03-29 09:03:13 +00001503 bool NeedsEHFrameSection = !MOFI->getSupportsCompactUnwindWithoutEHFrame();
Bill Wendling4e9fc022013-04-24 03:11:14 +00001504 if (IsEH && MOFI->getCompactUnwindSection()) {
Bill Wendling4e9fc022013-04-24 03:11:14 +00001505 bool SectionEmitted = false;
Bob Wilson0e180f22013-05-07 20:56:33 +00001506 for (unsigned i = 0, n = FrameArray.size(); i < n; ++i) {
1507 const MCDwarfFrameInfo &Frame = FrameArray[i];
1508 if (Frame.CompactUnwindEncoding == 0) continue;
1509 if (!SectionEmitted) {
1510 Streamer.SwitchSection(MOFI->getCompactUnwindSection());
Bill Wendlingbc07a892013-06-18 07:20:20 +00001511 Streamer.EmitValueToAlignment(Context.getAsmInfo()->getPointerSize());
Bob Wilson0e180f22013-05-07 20:56:33 +00001512 SectionEmitted = true;
Bill Wendling4e9fc022013-04-24 03:11:14 +00001513 }
Tim Northoverd1c6f512014-03-29 09:03:13 +00001514 NeedsEHFrameSection |=
1515 Frame.CompactUnwindEncoding ==
1516 MOFI->getCompactUnwindDwarfEHFrameOnly();
Bob Wilson0e180f22013-05-07 20:56:33 +00001517 Emitter.EmitCompactUnwind(Streamer, Frame);
Bill Wendling4d9aa512011-07-22 21:18:59 +00001518 }
Bill Wendling4e9fc022013-04-24 03:11:14 +00001519 }
Bill Wendling4d9aa512011-07-22 21:18:59 +00001520
Tim Northoverd1c6f512014-03-29 09:03:13 +00001521 if (!NeedsEHFrameSection) return;
1522
Rafael Espindola0709a7b2015-05-21 19:20:38 +00001523 MCSection &Section =
1524 IsEH ? *const_cast<MCObjectFileInfo *>(MOFI)->getEHFrameSection()
1525 : *MOFI->getDwarfFrameSection();
Tim Northoverd1c6f512014-03-29 09:03:13 +00001526
Bill Wendlinga4b9d1f2011-06-23 07:44:54 +00001527 Streamer.SwitchSection(&Section);
Jim Grosbach6f482002015-05-18 18:43:14 +00001528 MCSymbol *SectionStart = Context.createTempSymbol();
Bill Wendlinga4b9d1f2011-06-23 07:44:54 +00001529 Streamer.EmitLabel(SectionStart);
Bill Wendling4d9aa512011-07-22 21:18:59 +00001530 Emitter.setSectionStart(SectionStart);
Rafael Espindola7c715152011-04-29 02:42:28 +00001531
Craig Topperbb694de2014-04-13 04:57:38 +00001532 MCSymbol *FDEEnd = nullptr;
Eric Christopherd29430d2014-06-19 20:00:09 +00001533 DenseMap<CIEKey, const MCSymbol *> CIEStarts;
Rafael Espindola9141b612010-12-26 20:20:31 +00001534
Craig Topperbb694de2014-04-13 04:57:38 +00001535 const MCSymbol *DummyDebugKey = nullptr;
Tim Northoverd1c6f512014-03-29 09:03:13 +00001536 NeedsEHFrameSection = !MOFI->getSupportsCompactUnwindWithoutEHFrame();
Bill Wendling4d9aa512011-07-22 21:18:59 +00001537 for (unsigned i = 0, n = FrameArray.size(); i < n; ++i) {
1538 const MCDwarfFrameInfo &Frame = FrameArray[i];
Tim Northoverd1c6f512014-03-29 09:03:13 +00001539
1540 // Emit the label from the previous iteration
1541 if (FDEEnd) {
1542 Streamer.EmitLabel(FDEEnd);
Craig Topperbb694de2014-04-13 04:57:38 +00001543 FDEEnd = nullptr;
Tim Northoverd1c6f512014-03-29 09:03:13 +00001544 }
1545
1546 if (!NeedsEHFrameSection && Frame.CompactUnwindEncoding !=
1547 MOFI->getCompactUnwindDwarfEHFrameOnly())
1548 // Don't generate an EH frame if we don't need one. I.e., it's taken care
1549 // of by the compact unwind encoding.
1550 continue;
1551
Bill Wendlinga4b9d1f2011-06-23 07:44:54 +00001552 CIEKey Key(Frame.Personality, Frame.PersonalityEncoding,
David Majnemere035cf92014-01-27 17:20:25 +00001553 Frame.LsdaEncoding, Frame.IsSignalFrame, Frame.IsSimple);
Bill Wendlinga4b9d1f2011-06-23 07:44:54 +00001554 const MCSymbol *&CIEStart = IsEH ? CIEStarts[Key] : DummyDebugKey;
1555 if (!CIEStart)
1556 CIEStart = &Emitter.EmitCIE(Streamer, Frame.Personality,
1557 Frame.PersonalityEncoding, Frame.Lsda,
Rafael Espindola3c47e372012-01-23 21:51:52 +00001558 Frame.IsSignalFrame,
David Majnemere035cf92014-01-27 17:20:25 +00001559 Frame.LsdaEncoding,
1560 Frame.IsSimple);
Bill Wendlinge8fc92a2011-06-23 01:06:23 +00001561
Bill Wendlinga4b9d1f2011-06-23 07:44:54 +00001562 FDEEnd = Emitter.EmitFDE(Streamer, *CIEStart, Frame);
Rafael Espindola32c74ea2010-12-17 00:28:02 +00001563 }
Rafael Espindola9141b612010-12-26 20:20:31 +00001564
Bill Wendlingbc07a892013-06-18 07:20:20 +00001565 Streamer.EmitValueToAlignment(Context.getAsmInfo()->getPointerSize());
Bill Wendlinga4b9d1f2011-06-23 07:44:54 +00001566 if (FDEEnd)
1567 Streamer.EmitLabel(FDEEnd);
Rafael Espindola0a017a62010-12-10 07:39:47 +00001568}
Rafael Espindola736a35d2010-12-28 05:39:27 +00001569
Rafael Espindola4066e8d2014-05-12 14:28:48 +00001570void MCDwarfFrameEmitter::EmitAdvanceLoc(MCObjectStreamer &Streamer,
Rafael Espindola736a35d2010-12-28 05:39:27 +00001571 uint64_t AddrDelta) {
Ulrich Weigand32d725b2013-06-12 14:46:54 +00001572 MCContext &Context = Streamer.getContext();
Alp Tokere69170a2014-06-26 22:52:05 +00001573 SmallString<256> Tmp;
1574 raw_svector_ostream OS(Tmp);
Ulrich Weigand32d725b2013-06-12 14:46:54 +00001575 MCDwarfFrameEmitter::EncodeAdvanceLoc(Context, AddrDelta, OS);
Eric Christophere3ab3d02013-01-09 01:57:54 +00001576 Streamer.EmitBytes(OS.str());
Rafael Espindola736a35d2010-12-28 05:39:27 +00001577}
1578
Ulrich Weigand32d725b2013-06-12 14:46:54 +00001579void MCDwarfFrameEmitter::EncodeAdvanceLoc(MCContext &Context,
1580 uint64_t AddrDelta,
Rafael Espindolaab39c632011-05-08 14:35:21 +00001581 raw_ostream &OS) {
Ulrich Weigand32d725b2013-06-12 14:46:54 +00001582 // Scale the address delta by the minimum instruction length.
1583 AddrDelta = ScaleAddrDelta(Context, AddrDelta);
1584
Rafael Espindola6bbfb6c2010-12-28 23:38:03 +00001585 if (AddrDelta == 0) {
Rafael Espindolaab39c632011-05-08 14:35:21 +00001586 } else if (isUIntN(6, AddrDelta)) {
Rafael Espindola736a35d2010-12-28 05:39:27 +00001587 uint8_t Opcode = dwarf::DW_CFA_advance_loc | AddrDelta;
1588 OS << Opcode;
Rafael Espindolaab39c632011-05-08 14:35:21 +00001589 } else if (isUInt<8>(AddrDelta)) {
Rafael Espindola736a35d2010-12-28 05:39:27 +00001590 OS << uint8_t(dwarf::DW_CFA_advance_loc1);
1591 OS << uint8_t(AddrDelta);
Rafael Espindolaab39c632011-05-08 14:35:21 +00001592 } else if (isUInt<16>(AddrDelta)) {
Rafael Espindola563301d2010-12-29 02:30:49 +00001593 // FIXME: check what is the correct behavior on a big endian machine.
Rafael Espindola736a35d2010-12-28 05:39:27 +00001594 OS << uint8_t(dwarf::DW_CFA_advance_loc2);
Rafael Espindola563301d2010-12-29 02:30:49 +00001595 OS << uint8_t( AddrDelta & 0xff);
1596 OS << uint8_t((AddrDelta >> 8) & 0xff);
Rafael Espindola736a35d2010-12-28 05:39:27 +00001597 } else {
Rafael Espindola563301d2010-12-29 02:30:49 +00001598 // FIXME: check what is the correct behavior on a big endian machine.
Rafael Espindola736a35d2010-12-28 05:39:27 +00001599 assert(isUInt<32>(AddrDelta));
1600 OS << uint8_t(dwarf::DW_CFA_advance_loc4);
Rafael Espindola563301d2010-12-29 02:30:49 +00001601 OS << uint8_t( AddrDelta & 0xff);
1602 OS << uint8_t((AddrDelta >> 8) & 0xff);
1603 OS << uint8_t((AddrDelta >> 16) & 0xff);
1604 OS << uint8_t((AddrDelta >> 24) & 0xff);
1605
Rafael Espindola736a35d2010-12-28 05:39:27 +00001606 }
1607}