blob: 996be956e9011056d6cdde9ab69c76e6786e3938 [file] [log] [blame]
Daniel Dunbar9faf2732009-06-24 01:03:06 +00001//===- lib/MC/MCStreamer.cpp - Streaming Machine Code Output --------------===//
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
Chandler Carruthed0881b2012-12-03 16:50:05 +000010#include "llvm/MC/MCStreamer.h"
11#include "llvm/ADT/SmallString.h"
12#include "llvm/ADT/Twine.h"
Bill Wendling58e2d3d2013-09-09 02:37:14 +000013#include "llvm/MC/MCAsmBackend.h"
Rafael Espindola44bbe362010-12-06 17:27:56 +000014#include "llvm/MC/MCAsmInfo.h"
Rafael Espindolac653a892010-11-16 21:20:32 +000015#include "llvm/MC/MCContext.h"
Chris Lattner0c65fd42010-01-19 18:45:47 +000016#include "llvm/MC/MCExpr.h"
Rafael Espindola61adb272014-01-24 02:42:26 +000017#include "llvm/MC/MCObjectFileInfo.h"
Kevin Enderbye46564a2010-09-30 16:52:03 +000018#include "llvm/MC/MCObjectWriter.h"
Rafael Espindola27c0c9b2011-04-27 15:21:19 +000019#include "llvm/MC/MCSymbol.h"
Rafael Espindola16145972010-11-01 14:28:48 +000020#include "llvm/Support/ErrorHandling.h"
Jim Grosbachbf387df2012-08-08 23:56:06 +000021#include "llvm/Support/LEB128.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000022#include "llvm/Support/raw_ostream.h"
Chris Lattner6ec72d22010-04-03 21:48:59 +000023#include <cstdlib>
Daniel Dunbar9faf2732009-06-24 01:03:06 +000024using namespace llvm;
25
Juergen Ributzkad12ccbd2013-11-19 00:57:56 +000026// Pin the vtables to this file.
Rafael Espindolaa17151a2013-10-08 13:08:17 +000027MCTargetStreamer::~MCTargetStreamer() {}
Rafael Espindola24ea09e2014-01-26 06:06:37 +000028
29MCTargetStreamer::MCTargetStreamer(MCStreamer &S) : Streamer(S) {
30 S.setTargetStreamer(this);
31}
32
Rafael Espindola6d5f7ce2014-01-14 04:25:13 +000033void MCTargetStreamer::emitLabel(MCSymbol *Symbol) {}
Rafael Espindolaa17151a2013-10-08 13:08:17 +000034
Rafael Espindola24ea09e2014-01-26 06:06:37 +000035MCStreamer::MCStreamer(MCContext &Ctx)
36 : Context(Ctx), EmitEHFrame(true), EmitDebugFrame(false),
37 CurrentW64UnwindInfo(0), LastSymbol(0) {
Peter Collingbourne2f495b92013-04-17 21:18:16 +000038 SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>());
Daniel Dunbar9faf2732009-06-24 01:03:06 +000039}
40
41MCStreamer::~MCStreamer() {
Charles Davisa60cd572011-05-27 02:01:08 +000042 for (unsigned i = 0; i < getNumW64UnwindInfos(); ++i)
43 delete W64UnwindInfos[i];
Daniel Dunbar9faf2732009-06-24 01:03:06 +000044}
Chris Lattner0c65fd42010-01-19 18:45:47 +000045
Pedro Artigas7212ee42012-12-12 22:59:46 +000046void MCStreamer::reset() {
47 for (unsigned i = 0; i < getNumW64UnwindInfos(); ++i)
48 delete W64UnwindInfos[i];
Charles Davis17a0dcb2013-05-07 21:14:15 +000049 W64UnwindInfos.clear();
Pedro Artigas7212ee42012-12-12 22:59:46 +000050 EmitEHFrame = true;
51 EmitDebugFrame = false;
52 CurrentW64UnwindInfo = 0;
53 LastSymbol = 0;
Pedro Artigas7212ee42012-12-12 22:59:46 +000054 SectionStack.clear();
Peter Collingbourne2f495b92013-04-17 21:18:16 +000055 SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>());
Pedro Artigas7212ee42012-12-12 22:59:46 +000056}
57
Rafael Espindola1d1eced2011-04-30 03:21:04 +000058const MCExpr *MCStreamer::BuildSymbolDiff(MCContext &Context,
59 const MCSymbol *A,
60 const MCSymbol *B) {
61 MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None;
62 const MCExpr *ARef =
63 MCSymbolRefExpr::Create(A, Variant, Context);
64 const MCExpr *BRef =
65 MCSymbolRefExpr::Create(B, Variant, Context);
66 const MCExpr *AddrDelta =
67 MCBinaryExpr::Create(MCBinaryExpr::Sub, ARef, BRef, Context);
68 return AddrDelta;
69}
70
Rafael Espindola8e129292011-05-19 21:40:34 +000071const MCExpr *MCStreamer::ForceExpAbs(const MCExpr* Expr) {
Bill Wendlingbc07a892013-06-18 07:20:20 +000072 if (Context.getAsmInfo()->hasAggressiveSymbolFolding() ||
Rafael Espindola1edfb172011-05-19 22:05:56 +000073 isa<MCSymbolRefExpr>(Expr))
Rafael Espindola8e129292011-05-19 21:40:34 +000074 return Expr;
Rafael Espindola1d1eced2011-04-30 03:21:04 +000075
Rafael Espindola8e129292011-05-19 21:40:34 +000076 MCSymbol *ABS = Context.CreateTempSymbol();
77 EmitAssignment(ABS, Expr);
78 return MCSymbolRefExpr::Create(ABS, Context);
Rafael Espindola1d1eced2011-04-30 03:21:04 +000079}
80
Chris Lattner8fa0e352010-01-22 19:17:48 +000081raw_ostream &MCStreamer::GetCommentOS() {
82 // By default, discard comments.
83 return nulls();
84}
85
Rafael Espindola0b694812014-01-16 16:28:37 +000086void MCStreamer::emitRawComment(const Twine &T, bool TabPrefix) {}
87
Bill Wendling550c76d2013-09-09 19:48:37 +000088void MCStreamer::generateCompactUnwindEncodings(MCAsmBackend *MAB) {
Bill Wendling58e2d3d2013-09-09 02:37:14 +000089 for (std::vector<MCDwarfFrameInfo>::iterator I = FrameInfos.begin(),
90 E = FrameInfos.end(); I != E; ++I)
Bill Wendling550c76d2013-09-09 19:48:37 +000091 I->CompactUnwindEncoding =
Bill Wendling544d1612013-09-09 21:22:44 +000092 (MAB ? MAB->generateCompactUnwindEncoding(I->Instructions) : 0);
Bill Wendling58e2d3d2013-09-09 02:37:14 +000093}
94
Rafael Espindola57ab7082010-12-03 00:55:40 +000095void MCStreamer::EmitDwarfSetLineAddr(int64_t LineDelta,
96 const MCSymbol *Label, int PointerSize) {
97 // emit the sequence to set the address
98 EmitIntValue(dwarf::DW_LNS_extended_op, 1);
99 EmitULEB128IntValue(PointerSize + 1);
100 EmitIntValue(dwarf::DW_LNE_set_address, 1);
101 EmitSymbolValue(Label, PointerSize);
102
103 // emit the sequence for the LineDelta (from 1) and a zero address delta.
104 MCDwarfLineAddr::Emit(this, LineDelta, 0);
105}
Chris Lattner8fa0e352010-01-22 19:17:48 +0000106
Chris Lattnerdc50e5d2010-01-19 22:03:38 +0000107/// EmitIntValue - Special case of EmitValue that avoids the client having to
108/// pass in a MCExpr for constant integers.
Rafael Espindola64e1af82013-07-02 15:49:13 +0000109void MCStreamer::EmitIntValue(uint64_t Value, unsigned Size) {
Devang Patel3ebe3de2010-12-09 19:26:21 +0000110 assert(Size <= 8 && "Invalid size");
Matt Beaumont-Gayf991d4f2010-12-15 23:14:45 +0000111 assert((isUIntN(8 * Size, Value) || isIntN(8 * Size, Value)) &&
112 "Invalid size");
Rafael Espindola4c70eea2010-12-03 02:54:21 +0000113 char buf[8];
Bill Wendlingbc07a892013-06-18 07:20:20 +0000114 const bool isLittleEndian = Context.getAsmInfo()->isLittleEndian();
Roman Divacky384ffa92011-06-07 17:31:02 +0000115 for (unsigned i = 0; i != Size; ++i) {
116 unsigned index = isLittleEndian ? i : (Size - i - 1);
117 buf[i] = uint8_t(Value >> (index * 8));
118 }
Rafael Espindola64e1af82013-07-02 15:49:13 +0000119 EmitBytes(StringRef(buf, Size));
Chris Lattnerdc50e5d2010-01-19 22:03:38 +0000120}
121
Rafael Espindola5e874982010-11-02 17:22:24 +0000122/// EmitULEB128Value - Special case of EmitULEB128Value that avoids the
123/// client having to pass in a MCExpr for constant integers.
Rafael Espindola64e1af82013-07-02 15:49:13 +0000124void MCStreamer::EmitULEB128IntValue(uint64_t Value, unsigned Padding) {
Benjamin Kramer00b679c2012-02-23 21:15:21 +0000125 SmallString<128> Tmp;
Rafael Espindola675fbb22010-12-03 01:19:49 +0000126 raw_svector_ostream OSE(Tmp);
Jim Grosbachbf387df2012-08-08 23:56:06 +0000127 encodeULEB128(Value, OSE, Padding);
Rafael Espindola64e1af82013-07-02 15:49:13 +0000128 EmitBytes(OSE.str());
Kevin Enderbye46564a2010-09-30 16:52:03 +0000129}
130
Rafael Espindola5e874982010-11-02 17:22:24 +0000131/// EmitSLEB128Value - Special case of EmitSLEB128Value that avoids the
132/// client having to pass in a MCExpr for constant integers.
Rafael Espindola64e1af82013-07-02 15:49:13 +0000133void MCStreamer::EmitSLEB128IntValue(int64_t Value) {
Benjamin Kramer00b679c2012-02-23 21:15:21 +0000134 SmallString<128> Tmp;
Rafael Espindola675fbb22010-12-03 01:19:49 +0000135 raw_svector_ostream OSE(Tmp);
Jim Grosbachbf387df2012-08-08 23:56:06 +0000136 encodeSLEB128(Value, OSE);
Rafael Espindola64e1af82013-07-02 15:49:13 +0000137 EmitBytes(OSE.str());
Kevin Enderbye46564a2010-09-30 16:52:03 +0000138}
139
Rafael Espindola64e1af82013-07-02 15:49:13 +0000140void MCStreamer::EmitAbsValue(const MCExpr *Value, unsigned Size) {
Rafael Espindola8e129292011-05-19 21:40:34 +0000141 const MCExpr *ABS = ForceExpAbs(Value);
Rafael Espindola64e1af82013-07-02 15:49:13 +0000142 EmitValue(ABS, Size);
Rafael Espindola44bbe362010-12-06 17:27:56 +0000143}
144
Rafael Espindola0a017a62010-12-10 07:39:47 +0000145
Rafael Espindola64e1af82013-07-02 15:49:13 +0000146void MCStreamer::EmitValue(const MCExpr *Value, unsigned Size) {
147 EmitValueImpl(Value, Size);
Rafael Espindola0a017a62010-12-10 07:39:47 +0000148}
149
Rafael Espindola64e1af82013-07-02 15:49:13 +0000150void MCStreamer::EmitSymbolValue(const MCSymbol *Sym, unsigned Size) {
151 EmitValueImpl(MCSymbolRefExpr::Create(Sym, getContext()), Size);
Rafael Espindola0a017a62010-12-10 07:39:47 +0000152}
153
Akira Hatanakaf0b08442012-02-03 04:33:00 +0000154void MCStreamer::EmitGPRel64Value(const MCExpr *Value) {
155 report_fatal_error("unsupported directive in streamer");
156}
157
Rafael Espindolab7465312010-11-28 15:09:24 +0000158void MCStreamer::EmitGPRel32Value(const MCExpr *Value) {
159 report_fatal_error("unsupported directive in streamer");
160}
161
Chris Lattner0c65fd42010-01-19 18:45:47 +0000162/// EmitFill - Emit NumBytes bytes worth of the value specified by
163/// FillValue. This implements directives such as '.space'.
Rafael Espindola64e1af82013-07-02 15:49:13 +0000164void MCStreamer::EmitFill(uint64_t NumBytes, uint8_t FillValue) {
Chris Lattner0c65fd42010-01-19 18:45:47 +0000165 const MCExpr *E = MCConstantExpr::Create(FillValue, getContext());
166 for (uint64_t i = 0, e = NumBytes; i != e; ++i)
Rafael Espindola64e1af82013-07-02 15:49:13 +0000167 EmitValue(E, 1);
Chris Lattner0c65fd42010-01-19 18:45:47 +0000168}
Chris Lattner8a87fb72010-04-03 21:35:55 +0000169
Rafael Espindola64e1af82013-07-02 15:49:13 +0000170/// The implementation in this class just redirects to EmitFill.
171void MCStreamer::EmitZeros(uint64_t NumBytes) {
172 EmitFill(NumBytes, 0);
Serge Pavlov24a3ebb2013-06-27 14:35:03 +0000173}
174
Rafael Espindolac653a892010-11-16 21:20:32 +0000175bool MCStreamer::EmitDwarfFileDirective(unsigned FileNo,
Nick Lewycky40f8f2f2011-10-17 23:05:28 +0000176 StringRef Directory,
Manman Ren1e427202013-03-07 01:42:00 +0000177 StringRef Filename, unsigned CUID) {
178 return getContext().GetDwarfFile(Directory, Filename, FileNo, CUID) == 0;
Rafael Espindolac653a892010-11-16 21:20:32 +0000179}
180
181void MCStreamer::EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
182 unsigned Column, unsigned Flags,
183 unsigned Isa,
Devang Patel17740e72011-04-18 20:26:49 +0000184 unsigned Discriminator,
185 StringRef FileName) {
Rafael Espindolac653a892010-11-16 21:20:32 +0000186 getContext().setCurrentDwarfLoc(FileNo, Line, Column, Flags, Isa,
187 Discriminator);
188}
189
Rafael Espindola0a017a62010-12-10 07:39:47 +0000190MCDwarfFrameInfo *MCStreamer::getCurrentFrameInfo() {
191 if (FrameInfos.empty())
Jakub Staszaka0f36942013-03-18 23:08:01 +0000192 return 0;
Rafael Espindola0a017a62010-12-10 07:39:47 +0000193 return &FrameInfos.back();
194}
195
196void MCStreamer::EnsureValidFrame() {
197 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
198 if (!CurFrame || CurFrame->End)
199 report_fatal_error("No open frame");
200}
201
Rafael Espindola349c3292011-04-28 12:50:37 +0000202void MCStreamer::EmitEHSymAttributes(const MCSymbol *Symbol,
203 MCSymbol *EHSymbol) {
204}
205
Rafael Espindola0e2ccb22014-01-24 03:54:40 +0000206void MCStreamer::InitSections(bool Force) {
Rafael Espindola61adb272014-01-24 02:42:26 +0000207 SwitchSection(getContext().getObjectFileInfo()->getTextSection());
208}
209
Richard Mitton21101b32013-09-19 23:21:01 +0000210void MCStreamer::AssignSection(MCSymbol *Symbol, const MCSection *Section) {
211 if (Section)
212 Symbol->setSection(*Section);
213 else
214 Symbol->setUndefined();
215
216 // As we emit symbols into a section, track the order so that they can
217 // be sorted upon later. Zero is reserved to mean 'unemitted'.
218 SymbolOrdering[Symbol] = 1 + SymbolOrdering.size();
219}
220
Rafael Espindola27c0c9b2011-04-27 15:21:19 +0000221void MCStreamer::EmitLabel(MCSymbol *Symbol) {
222 assert(!Symbol->isVariable() && "Cannot emit a variable symbol!");
Peter Collingbourne2f495b92013-04-17 21:18:16 +0000223 assert(getCurrentSection().first && "Cannot emit before setting section!");
Richard Mitton21101b32013-09-19 23:21:01 +0000224 AssignSection(Symbol, getCurrentSection().first);
Rafael Espindolac48e10c2011-08-02 20:24:22 +0000225 LastSymbol = Symbol;
Rafael Espindola6d5f7ce2014-01-14 04:25:13 +0000226
227 MCTargetStreamer *TS = getTargetStreamer();
228 if (TS)
229 TS->emitLabel(Symbol);
Rafael Espindola27c0c9b2011-04-27 15:21:19 +0000230}
231
Reed Kotleraee4d5d12012-12-16 04:00:45 +0000232void MCStreamer::EmitDebugLabel(MCSymbol *Symbol) {
233 assert(!Symbol->isVariable() && "Cannot emit a variable symbol!");
Peter Collingbourne2f495b92013-04-17 21:18:16 +0000234 assert(getCurrentSection().first && "Cannot emit before setting section!");
Richard Mitton21101b32013-09-19 23:21:01 +0000235 AssignSection(Symbol, getCurrentSection().first);
Reed Kotleraee4d5d12012-12-16 04:00:45 +0000236 LastSymbol = Symbol;
237}
238
Bill Wendlingc438d782011-07-19 00:01:42 +0000239void MCStreamer::EmitCompactUnwindEncoding(uint32_t CompactUnwindEncoding) {
240 EnsureValidFrame();
241 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
242 CurFrame->CompactUnwindEncoding = CompactUnwindEncoding;
243}
244
Rafael Espindola74b101f2011-05-10 01:10:18 +0000245void MCStreamer::EmitCFISections(bool EH, bool Debug) {
Rafael Espindolaec53aa92011-05-10 13:39:48 +0000246 assert(EH || Debug);
Rafael Espindola74b101f2011-05-10 01:10:18 +0000247 EmitEHFrame = EH;
248 EmitDebugFrame = Debug;
249}
250
David Majnemere035cf92014-01-27 17:20:25 +0000251void MCStreamer::EmitCFIStartProc(bool IsSimple) {
Rafael Espindola0a017a62010-12-10 07:39:47 +0000252 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
Rafael Espindola539d96f2011-04-12 23:59:07 +0000253 if (CurFrame && !CurFrame->End)
Rafael Espindola0a017a62010-12-10 07:39:47 +0000254 report_fatal_error("Starting a frame before finishing the previous one!");
Rafael Espindolac48e10c2011-08-02 20:24:22 +0000255
Evan Chengeee86452011-08-24 22:31:37 +0000256 MCDwarfFrameInfo Frame;
David Majnemere035cf92014-01-27 17:20:25 +0000257 Frame.IsSimple = IsSimple;
Rafael Espindola38241202012-01-07 22:42:19 +0000258 EmitCFIStartProcImpl(Frame);
Rafael Espindolac48e10c2011-08-02 20:24:22 +0000259
Rafael Espindola38241202012-01-07 22:42:19 +0000260 FrameInfos.push_back(Frame);
Rafael Espindola38241202012-01-07 22:42:19 +0000261}
262
263void MCStreamer::EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) {
264}
265
266void MCStreamer::RecordProcStart(MCDwarfFrameInfo &Frame) {
267 Frame.Function = LastSymbol;
Rafael Espindolac48e10c2011-08-02 20:24:22 +0000268 // If the function is externally visible, we need to create a local
269 // symbol to avoid relocations.
Bill Wendlingbc07a892013-06-18 07:20:20 +0000270 StringRef Prefix = getContext().getAsmInfo()->getPrivateGlobalPrefix();
Evan Chengeee86452011-08-24 22:31:37 +0000271 if (LastSymbol && LastSymbol->getName().startswith(Prefix)) {
Rafael Espindolac48e10c2011-08-02 20:24:22 +0000272 Frame.Begin = LastSymbol;
273 } else {
274 Frame.Begin = getContext().CreateTempSymbol();
275 EmitLabel(Frame.Begin);
276 }
Rafael Espindola3c227b02010-11-22 14:27:24 +0000277}
278
Rafael Espindola539d96f2011-04-12 23:59:07 +0000279void MCStreamer::EmitCFIEndProc() {
Rafael Espindola0a017a62010-12-10 07:39:47 +0000280 EnsureValidFrame();
281 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
Rafael Espindolaf28213c2012-01-09 00:17:29 +0000282 EmitCFIEndProcImpl(*CurFrame);
283}
284
285void MCStreamer::EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) {
286}
287
288void MCStreamer::RecordProcEnd(MCDwarfFrameInfo &Frame) {
289 Frame.End = getContext().CreateTempSymbol();
290 EmitLabel(Frame.End);
Rafael Espindola3c227b02010-11-22 14:27:24 +0000291}
292
Rafael Espindola7a6e4412012-11-24 02:18:49 +0000293MCSymbol *MCStreamer::EmitCFICommon() {
Rafael Espindola290d7162010-12-29 01:42:56 +0000294 EnsureValidFrame();
Rafael Espindola290d7162010-12-29 01:42:56 +0000295 MCSymbol *Label = getContext().CreateTempSymbol();
296 EmitLabel(Label);
Rafael Espindola7a6e4412012-11-24 02:18:49 +0000297 return Label;
298}
299
300void MCStreamer::EmitCFIDefCfa(int64_t Register, int64_t Offset) {
301 MCSymbol *Label = EmitCFICommon();
Rafael Espindola1c3086c2012-11-24 02:01:08 +0000302 MCCFIInstruction Instruction =
303 MCCFIInstruction::createDefCfa(Label, Register, Offset);
Rafael Espindola7a6e4412012-11-24 02:18:49 +0000304 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
Rafael Espindola290d7162010-12-29 01:42:56 +0000305 CurFrame->Instructions.push_back(Instruction);
Rafael Espindola290d7162010-12-29 01:42:56 +0000306}
307
Rafael Espindola539d96f2011-04-12 23:59:07 +0000308void MCStreamer::EmitCFIDefCfaOffset(int64_t Offset) {
Rafael Espindola7a6e4412012-11-24 02:18:49 +0000309 MCSymbol *Label = EmitCFICommon();
Rafael Espindola1c3086c2012-11-24 02:01:08 +0000310 MCCFIInstruction Instruction =
311 MCCFIInstruction::createDefCfaOffset(Label, Offset);
Rafael Espindola7a6e4412012-11-24 02:18:49 +0000312 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
Rafael Espindola85d91982010-12-28 18:36:23 +0000313 CurFrame->Instructions.push_back(Instruction);
Rafael Espindola3c227b02010-11-22 14:27:24 +0000314}
315
Rafael Espindolafd794af2011-04-12 18:53:30 +0000316void MCStreamer::EmitCFIAdjustCfaOffset(int64_t Adjustment) {
Rafael Espindola7a6e4412012-11-24 02:18:49 +0000317 MCSymbol *Label = EmitCFICommon();
Rafael Espindola1c3086c2012-11-24 02:01:08 +0000318 MCCFIInstruction Instruction =
319 MCCFIInstruction::createAdjustCfaOffset(Label, Adjustment);
Rafael Espindola7a6e4412012-11-24 02:18:49 +0000320 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
Rafael Espindolafd794af2011-04-12 18:53:30 +0000321 CurFrame->Instructions.push_back(Instruction);
322}
323
Rafael Espindola539d96f2011-04-12 23:59:07 +0000324void MCStreamer::EmitCFIDefCfaRegister(int64_t Register) {
Rafael Espindola7a6e4412012-11-24 02:18:49 +0000325 MCSymbol *Label = EmitCFICommon();
Rafael Espindola1c3086c2012-11-24 02:01:08 +0000326 MCCFIInstruction Instruction =
327 MCCFIInstruction::createDefCfaRegister(Label, Register);
Rafael Espindola7a6e4412012-11-24 02:18:49 +0000328 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
Rafael Espindola426e68f2010-12-29 00:26:06 +0000329 CurFrame->Instructions.push_back(Instruction);
Rafael Espindola3c227b02010-11-22 14:27:24 +0000330}
331
Rafael Espindola539d96f2011-04-12 23:59:07 +0000332void MCStreamer::EmitCFIOffset(int64_t Register, int64_t Offset) {
Rafael Espindola7a6e4412012-11-24 02:18:49 +0000333 MCSymbol *Label = EmitCFICommon();
Rafael Espindola1c3086c2012-11-24 02:01:08 +0000334 MCCFIInstruction Instruction =
Rafael Espindola5dce65b2012-11-24 03:10:54 +0000335 MCCFIInstruction::createOffset(Label, Register, Offset);
Rafael Espindola7a6e4412012-11-24 02:18:49 +0000336 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
Rafael Espindola86d347d2010-12-29 00:09:59 +0000337 CurFrame->Instructions.push_back(Instruction);
Rafael Espindola3c227b02010-11-22 14:27:24 +0000338}
339
Rafael Espindola1ec0f462011-04-12 16:12:03 +0000340void MCStreamer::EmitCFIRelOffset(int64_t Register, int64_t Offset) {
Rafael Espindola7a6e4412012-11-24 02:18:49 +0000341 MCSymbol *Label = EmitCFICommon();
Rafael Espindola1c3086c2012-11-24 02:01:08 +0000342 MCCFIInstruction Instruction =
343 MCCFIInstruction::createRelOffset(Label, Register, Offset);
Rafael Espindola7a6e4412012-11-24 02:18:49 +0000344 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
Rafael Espindola1ec0f462011-04-12 16:12:03 +0000345 CurFrame->Instructions.push_back(Instruction);
346}
347
Rafael Espindola539d96f2011-04-12 23:59:07 +0000348void MCStreamer::EmitCFIPersonality(const MCSymbol *Sym,
Rafael Espindola2ac83552010-12-27 00:36:05 +0000349 unsigned Encoding) {
Rafael Espindola0a017a62010-12-10 07:39:47 +0000350 EnsureValidFrame();
351 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
352 CurFrame->Personality = Sym;
Rafael Espindola2ac83552010-12-27 00:36:05 +0000353 CurFrame->PersonalityEncoding = Encoding;
Rafael Espindola3c227b02010-11-22 14:27:24 +0000354}
355
Rafael Espindola539d96f2011-04-12 23:59:07 +0000356void MCStreamer::EmitCFILsda(const MCSymbol *Sym, unsigned Encoding) {
Rafael Espindola0a017a62010-12-10 07:39:47 +0000357 EnsureValidFrame();
358 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
359 CurFrame->Lsda = Sym;
Rafael Espindola1de2dd02010-12-27 15:56:22 +0000360 CurFrame->LsdaEncoding = Encoding;
Rafael Espindola3c227b02010-11-22 14:27:24 +0000361}
362
Rafael Espindola539d96f2011-04-12 23:59:07 +0000363void MCStreamer::EmitCFIRememberState() {
Rafael Espindola7a6e4412012-11-24 02:18:49 +0000364 MCSymbol *Label = EmitCFICommon();
Rafael Espindola1c3086c2012-11-24 02:01:08 +0000365 MCCFIInstruction Instruction = MCCFIInstruction::createRememberState(Label);
Rafael Espindola7a6e4412012-11-24 02:18:49 +0000366 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
Rafael Espindola85d91982010-12-28 18:36:23 +0000367 CurFrame->Instructions.push_back(Instruction);
Rafael Espindola85d91982010-12-28 18:36:23 +0000368}
369
Rafael Espindola539d96f2011-04-12 23:59:07 +0000370void MCStreamer::EmitCFIRestoreState() {
Rafael Espindola85d91982010-12-28 18:36:23 +0000371 // FIXME: Error if there is no matching cfi_remember_state.
Rafael Espindola7a6e4412012-11-24 02:18:49 +0000372 MCSymbol *Label = EmitCFICommon();
Rafael Espindola1c3086c2012-11-24 02:01:08 +0000373 MCCFIInstruction Instruction = MCCFIInstruction::createRestoreState(Label);
Rafael Espindola7a6e4412012-11-24 02:18:49 +0000374 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
Rafael Espindola85d91982010-12-28 18:36:23 +0000375 CurFrame->Instructions.push_back(Instruction);
Rafael Espindola85d91982010-12-28 18:36:23 +0000376}
377
Rafael Espindola2e1c9d22011-04-12 15:31:05 +0000378void MCStreamer::EmitCFISameValue(int64_t Register) {
Rafael Espindola7a6e4412012-11-24 02:18:49 +0000379 MCSymbol *Label = EmitCFICommon();
Rafael Espindola1c3086c2012-11-24 02:01:08 +0000380 MCCFIInstruction Instruction =
381 MCCFIInstruction::createSameValue(Label, Register);
Rafael Espindola7a6e4412012-11-24 02:18:49 +0000382 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
Rafael Espindola2e1c9d22011-04-12 15:31:05 +0000383 CurFrame->Instructions.push_back(Instruction);
384}
385
Rafael Espindola4ea99812011-12-29 21:43:03 +0000386void MCStreamer::EmitCFIRestore(int64_t Register) {
Rafael Espindola7a6e4412012-11-24 02:18:49 +0000387 MCSymbol *Label = EmitCFICommon();
Rafael Espindola1c3086c2012-11-24 02:01:08 +0000388 MCCFIInstruction Instruction =
389 MCCFIInstruction::createRestore(Label, Register);
Rafael Espindola7a6e4412012-11-24 02:18:49 +0000390 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
Rafael Espindola4ea99812011-12-29 21:43:03 +0000391 CurFrame->Instructions.push_back(Instruction);
392}
393
Rafael Espindolaef4aa352011-12-29 20:24:47 +0000394void MCStreamer::EmitCFIEscape(StringRef Values) {
Rafael Espindola7a6e4412012-11-24 02:18:49 +0000395 MCSymbol *Label = EmitCFICommon();
Rafael Espindola1c3086c2012-11-24 02:01:08 +0000396 MCCFIInstruction Instruction = MCCFIInstruction::createEscape(Label, Values);
Rafael Espindola7a6e4412012-11-24 02:18:49 +0000397 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
Rafael Espindolaef4aa352011-12-29 20:24:47 +0000398 CurFrame->Instructions.push_back(Instruction);
399}
400
Rafael Espindola3c47e372012-01-23 21:51:52 +0000401void MCStreamer::EmitCFISignalFrame() {
402 EnsureValidFrame();
403 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
404 CurFrame->IsSignalFrame = true;
405}
406
Rafael Espindola9bb24782012-11-23 16:59:41 +0000407void MCStreamer::EmitCFIUndefined(int64_t Register) {
Rafael Espindola7a6e4412012-11-24 02:18:49 +0000408 MCSymbol *Label = EmitCFICommon();
Rafael Espindola1c3086c2012-11-24 02:01:08 +0000409 MCCFIInstruction Instruction =
410 MCCFIInstruction::createUndefined(Label, Register);
Rafael Espindola7a6e4412012-11-24 02:18:49 +0000411 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
Rafael Espindola9bb24782012-11-23 16:59:41 +0000412 CurFrame->Instructions.push_back(Instruction);
413}
414
Rafael Espindolacdb9a532012-11-25 15:14:49 +0000415void MCStreamer::EmitCFIRegister(int64_t Register1, int64_t Register2) {
416 MCSymbol *Label = EmitCFICommon();
417 MCCFIInstruction Instruction =
418 MCCFIInstruction::createRegister(Label, Register1, Register2);
419 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
420 CurFrame->Instructions.push_back(Instruction);
421}
422
Venkatraman Govindaraju3816d432013-09-26 14:49:40 +0000423void MCStreamer::EmitCFIWindowSave() {
424 MCSymbol *Label = EmitCFICommon();
425 MCCFIInstruction Instruction =
426 MCCFIInstruction::createWindowSave(Label);
427 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
428 CurFrame->Instructions.push_back(Instruction);
429}
430
Charles Davisb4222582011-05-19 04:04:13 +0000431void MCStreamer::setCurrentW64UnwindInfo(MCWin64EHUnwindInfo *Frame) {
Charles Davis006e1c32011-05-26 02:45:47 +0000432 W64UnwindInfos.push_back(Frame);
433 CurrentW64UnwindInfo = W64UnwindInfos.back();
Charles Davis384041d2011-05-18 04:47:22 +0000434}
435
Charles Davisd991ec42011-05-19 02:49:00 +0000436void MCStreamer::EnsureValidW64UnwindInfo() {
Charles Davisb4222582011-05-19 04:04:13 +0000437 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
Charles Davisd991ec42011-05-19 02:49:00 +0000438 if (!CurFrame || CurFrame->End)
439 report_fatal_error("No open Win64 EH frame function!");
440}
441
Charles Davisc7250fa2011-05-22 21:12:15 +0000442void MCStreamer::EmitWin64EHStartProc(const MCSymbol *Symbol) {
Charles Davisb4222582011-05-19 04:04:13 +0000443 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
Charles Davisd991ec42011-05-19 02:49:00 +0000444 if (CurFrame && !CurFrame->End)
445 report_fatal_error("Starting a function before ending the previous one!");
Charles Davisa60cd572011-05-27 02:01:08 +0000446 MCWin64EHUnwindInfo *Frame = new MCWin64EHUnwindInfo;
Charles Davis006e1c32011-05-26 02:45:47 +0000447 Frame->Begin = getContext().CreateTempSymbol();
448 Frame->Function = Symbol;
449 EmitLabel(Frame->Begin);
450 setCurrentW64UnwindInfo(Frame);
Charles Davisd991ec42011-05-19 02:49:00 +0000451}
452
453void MCStreamer::EmitWin64EHEndProc() {
454 EnsureValidW64UnwindInfo();
Charles Davisb4222582011-05-19 04:04:13 +0000455 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
456 if (CurFrame->ChainedParent)
Charles Davisd991ec42011-05-19 02:49:00 +0000457 report_fatal_error("Not all chained regions terminated!");
458 CurFrame->End = getContext().CreateTempSymbol();
459 EmitLabel(CurFrame->End);
Charles Davisaf18d072011-05-15 17:20:01 +0000460}
461
Charles Davis4cd88562011-05-19 17:46:39 +0000462void MCStreamer::EmitWin64EHStartChained() {
Charles Davisb4222582011-05-19 04:04:13 +0000463 EnsureValidW64UnwindInfo();
Charles Davisa60cd572011-05-27 02:01:08 +0000464 MCWin64EHUnwindInfo *Frame = new MCWin64EHUnwindInfo;
Charles Davisb4222582011-05-19 04:04:13 +0000465 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
Charles Davis006e1c32011-05-26 02:45:47 +0000466 Frame->Begin = getContext().CreateTempSymbol();
467 Frame->Function = CurFrame->Function;
468 Frame->ChainedParent = CurFrame;
469 EmitLabel(Frame->Begin);
470 setCurrentW64UnwindInfo(Frame);
Charles Davis77e06102011-05-18 20:54:10 +0000471}
472
Charles Davis4cd88562011-05-19 17:46:39 +0000473void MCStreamer::EmitWin64EHEndChained() {
Charles Davisb4222582011-05-19 04:04:13 +0000474 EnsureValidW64UnwindInfo();
475 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
476 if (!CurFrame->ChainedParent)
477 report_fatal_error("End of a chained region outside a chained region!");
478 CurFrame->End = getContext().CreateTempSymbol();
479 EmitLabel(CurFrame->End);
480 CurrentW64UnwindInfo = CurFrame->ChainedParent;
Charles Davis77e06102011-05-18 20:54:10 +0000481}
482
Charles Davis4cd88562011-05-19 17:46:39 +0000483void MCStreamer::EmitWin64EHHandler(const MCSymbol *Sym, bool Unwind,
484 bool Except) {
485 EnsureValidW64UnwindInfo();
486 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
Charles Davis68796342011-05-21 17:36:25 +0000487 if (CurFrame->ChainedParent)
488 report_fatal_error("Chained unwind areas can't have handlers!");
Charles Davis4cd88562011-05-19 17:46:39 +0000489 CurFrame->ExceptionHandler = Sym;
Charles Davis8e8f59b2011-05-21 15:57:49 +0000490 if (!Except && !Unwind)
Charles Davis4cd88562011-05-19 17:46:39 +0000491 report_fatal_error("Don't know what kind of handler this is!");
Charles Davis8e8f59b2011-05-21 15:57:49 +0000492 if (Unwind)
493 CurFrame->HandlesUnwind = true;
494 if (Except)
495 CurFrame->HandlesExceptions = true;
Charles Davis4cd88562011-05-19 17:46:39 +0000496}
497
498void MCStreamer::EmitWin64EHHandlerData() {
Charles Davis24b31b62011-05-20 16:06:22 +0000499 EnsureValidW64UnwindInfo();
Charles Davis68796342011-05-21 17:36:25 +0000500 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
501 if (CurFrame->ChainedParent)
502 report_fatal_error("Chained unwind areas can't have handlers!");
Charles Davis77e06102011-05-18 20:54:10 +0000503}
504
Charles Davis7e6e8952011-05-19 19:35:55 +0000505void MCStreamer::EmitWin64EHPushReg(unsigned Register) {
506 EnsureValidW64UnwindInfo();
507 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
Charles Davis6d1c4c72011-05-27 03:25:01 +0000508 MCSymbol *Label = getContext().CreateTempSymbol();
509 MCWin64EHInstruction Inst(Win64EH::UOP_PushNonVol, Label, Register);
510 EmitLabel(Label);
Charles Davis7e6e8952011-05-19 19:35:55 +0000511 CurFrame->Instructions.push_back(Inst);
Charles Davis77e06102011-05-18 20:54:10 +0000512}
513
Charles Davis7e6e8952011-05-19 19:35:55 +0000514void MCStreamer::EmitWin64EHSetFrame(unsigned Register, unsigned Offset) {
515 EnsureValidW64UnwindInfo();
Charles Davis9dcee312011-05-27 01:42:17 +0000516 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
517 if (CurFrame->LastFrameInst >= 0)
518 report_fatal_error("Frame register and offset already specified!");
Charles Davise6360222011-05-22 00:56:20 +0000519 if (Offset & 0x0F)
520 report_fatal_error("Misaligned frame pointer offset!");
Kai Nacke1b7e4862013-08-27 04:16:16 +0000521 MCSymbol *Label = getContext().CreateTempSymbol();
522 MCWin64EHInstruction Inst(Win64EH::UOP_SetFPReg, Label, Register, Offset);
523 EmitLabel(Label);
Charles Davis54254002011-05-21 00:09:04 +0000524 CurFrame->LastFrameInst = CurFrame->Instructions.size();
Charles Davis7e6e8952011-05-19 19:35:55 +0000525 CurFrame->Instructions.push_back(Inst);
Charles Davisaf18d072011-05-15 17:20:01 +0000526}
527
Charles Davis7e6e8952011-05-19 19:35:55 +0000528void MCStreamer::EmitWin64EHAllocStack(unsigned Size) {
529 EnsureValidW64UnwindInfo();
Charles Davise6360222011-05-22 00:56:20 +0000530 if (Size & 7)
531 report_fatal_error("Misaligned stack allocation!");
Charles Davis7e6e8952011-05-19 19:35:55 +0000532 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
Charles Davis6d1c4c72011-05-27 03:25:01 +0000533 MCSymbol *Label = getContext().CreateTempSymbol();
534 MCWin64EHInstruction Inst(Label, Size);
535 EmitLabel(Label);
Charles Davis7e6e8952011-05-19 19:35:55 +0000536 CurFrame->Instructions.push_back(Inst);
Charles Davisaf18d072011-05-15 17:20:01 +0000537}
538
Charles Davis7e6e8952011-05-19 19:35:55 +0000539void MCStreamer::EmitWin64EHSaveReg(unsigned Register, unsigned Offset) {
540 EnsureValidW64UnwindInfo();
Charles Davise6360222011-05-22 00:56:20 +0000541 if (Offset & 7)
542 report_fatal_error("Misaligned saved register offset!");
Charles Davis7e6e8952011-05-19 19:35:55 +0000543 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
Charles Davis6d1c4c72011-05-27 03:25:01 +0000544 MCSymbol *Label = getContext().CreateTempSymbol();
Charles Davis7e6e8952011-05-19 19:35:55 +0000545 MCWin64EHInstruction Inst(
Charles Davis9dcee312011-05-27 01:42:17 +0000546 Offset > 512*1024-8 ? Win64EH::UOP_SaveNonVolBig : Win64EH::UOP_SaveNonVol,
Charles Davis6d1c4c72011-05-27 03:25:01 +0000547 Label, Register, Offset);
548 EmitLabel(Label);
Charles Davis7e6e8952011-05-19 19:35:55 +0000549 CurFrame->Instructions.push_back(Inst);
Charles Davisaf18d072011-05-15 17:20:01 +0000550}
551
Charles Davis7e6e8952011-05-19 19:35:55 +0000552void MCStreamer::EmitWin64EHSaveXMM(unsigned Register, unsigned Offset) {
553 EnsureValidW64UnwindInfo();
Charles Davise6360222011-05-22 00:56:20 +0000554 if (Offset & 0x0F)
555 report_fatal_error("Misaligned saved vector register offset!");
Charles Davis7e6e8952011-05-19 19:35:55 +0000556 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
Charles Davis6d1c4c72011-05-27 03:25:01 +0000557 MCSymbol *Label = getContext().CreateTempSymbol();
Charles Davis7e6e8952011-05-19 19:35:55 +0000558 MCWin64EHInstruction Inst(
Charles Davis9dcee312011-05-27 01:42:17 +0000559 Offset > 512*1024-16 ? Win64EH::UOP_SaveXMM128Big : Win64EH::UOP_SaveXMM128,
Charles Davis6d1c4c72011-05-27 03:25:01 +0000560 Label, Register, Offset);
561 EmitLabel(Label);
Charles Davis7e6e8952011-05-19 19:35:55 +0000562 CurFrame->Instructions.push_back(Inst);
Charles Davisaf18d072011-05-15 17:20:01 +0000563}
564
Charles Davis4cd88562011-05-19 17:46:39 +0000565void MCStreamer::EmitWin64EHPushFrame(bool Code) {
Charles Davis7e6e8952011-05-19 19:35:55 +0000566 EnsureValidW64UnwindInfo();
567 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
Charles Davis9dcee312011-05-27 01:42:17 +0000568 if (CurFrame->Instructions.size() > 0)
569 report_fatal_error("If present, PushMachFrame must be the first UOP");
Charles Davis6d1c4c72011-05-27 03:25:01 +0000570 MCSymbol *Label = getContext().CreateTempSymbol();
571 MCWin64EHInstruction Inst(Win64EH::UOP_PushMachFrame, Label, Code);
572 EmitLabel(Label);
Charles Davis7e6e8952011-05-19 19:35:55 +0000573 CurFrame->Instructions.push_back(Inst);
Charles Davisaf18d072011-05-15 17:20:01 +0000574}
575
Charles Davis4cd88562011-05-19 17:46:39 +0000576void MCStreamer::EmitWin64EHEndProlog() {
Charles Davisde745ba2011-05-19 21:24:54 +0000577 EnsureValidW64UnwindInfo();
578 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
579 CurFrame->PrologEnd = getContext().CreateTempSymbol();
580 EmitLabel(CurFrame->PrologEnd);
Charles Davis27018152011-05-16 21:13:58 +0000581}
582
Timur Iskhodzhanovc1fb2d62013-12-20 18:15:00 +0000583void MCStreamer::EmitCOFFSectionIndex(MCSymbol const *Symbol) {
584 llvm_unreachable("This file format doesn't support this directive");
585}
586
Rafael Espindolad3df3d32011-12-17 01:14:52 +0000587void MCStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol) {
Craig Toppera2886c22012-02-07 05:05:23 +0000588 llvm_unreachable("This file format doesn't support this directive");
Rafael Espindolad3df3d32011-12-17 01:14:52 +0000589}
590
Matt Fleming141791c2010-05-20 19:45:09 +0000591/// EmitRawText - If this file is backed by an assembly streamer, this dumps
Chris Lattner8a87fb72010-04-03 21:35:55 +0000592/// the specified string in the output .s file. This capability is
593/// indicated by the hasRawTextSupport() predicate.
David Blaikied8c5b4e2013-10-24 22:43:10 +0000594void MCStreamer::EmitRawTextImpl(StringRef String) {
Chris Lattner8a87fb72010-04-03 21:35:55 +0000595 errs() << "EmitRawText called on an MCStreamer that doesn't support it, "
596 " something must not be fully mc'ized\n";
597 abort();
598}
Chris Lattner17167212010-04-03 22:12:35 +0000599
600void MCStreamer::EmitRawText(const Twine &T) {
601 SmallString<128> Str;
David Blaikied8c5b4e2013-10-24 22:43:10 +0000602 EmitRawTextImpl(T.toStringRef(Str));
Chris Lattner17167212010-04-03 22:12:35 +0000603}
Rafael Espindolab6089d62011-05-10 03:14:15 +0000604
Bill Wendling550c76d2013-09-09 19:48:37 +0000605void MCStreamer::EmitFrames(MCAsmBackend *MAB, bool usingCFI) {
Rafael Espindolab6089d62011-05-10 03:14:15 +0000606 if (!getNumFrameInfos())
607 return;
608
609 if (EmitEHFrame)
Bill Wendling550c76d2013-09-09 19:48:37 +0000610 MCDwarfFrameEmitter::Emit(*this, MAB, usingCFI, true);
Rafael Espindola1ecb12f2011-05-10 03:54:12 +0000611
612 if (EmitDebugFrame)
Bill Wendling550c76d2013-09-09 19:48:37 +0000613 MCDwarfFrameEmitter::Emit(*this, MAB, usingCFI, false);
Rafael Espindolab6089d62011-05-10 03:14:15 +0000614}
Charles Davisbc2daa02011-05-22 04:15:07 +0000615
616void MCStreamer::EmitW64Tables() {
617 if (!getNumW64UnwindInfos())
618 return;
619
620 MCWin64EHUnwindEmitter::Emit(*this);
621}
Rafael Espindola07082092012-01-07 03:13:18 +0000622
623void MCStreamer::Finish() {
624 if (!FrameInfos.empty() && !FrameInfos.back().End)
625 report_fatal_error("Unfinished frame!");
626
627 FinishImpl();
628}
Jack Carter2f8d9d92013-02-19 21:57:35 +0000629
630MCSymbolData &MCStreamer::getOrCreateSymbolData(MCSymbol *Symbol) {
631 report_fatal_error("Not supported!");
Jakub Staszaka0f36942013-03-18 23:08:01 +0000632 return *(static_cast<MCSymbolData*>(0));
Jack Carter2f8d9d92013-02-19 21:57:35 +0000633}