1 //===- 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 
10 #include "llvm/MC/MCStreamer.h"
11 #include "llvm/ADT/SmallString.h"
12 #include "llvm/ADT/Twine.h"
13 #include "llvm/MC/MCAsmBackend.h"
14 #include "llvm/MC/MCAsmInfo.h"
15 #include "llvm/MC/MCContext.h"
16 #include "llvm/MC/MCExpr.h"
17 #include "llvm/MC/MCObjectFileInfo.h"
18 #include "llvm/MC/MCObjectWriter.h"
19 #include "llvm/MC/MCSymbol.h"
20 #include "llvm/Support/ErrorHandling.h"
21 #include "llvm/Support/LEB128.h"
22 #include "llvm/Support/raw_ostream.h"
23 #include <cstdlib>
24 using namespace llvm;
25 
26 // Pin the vtables to this file.
27 MCTargetStreamer::~MCTargetStreamer() {}
28 
29 MCTargetStreamer::MCTargetStreamer(MCStreamer &S) : Streamer(S) {
30   S.setTargetStreamer(this);
31 }
32 
33 void MCTargetStreamer::emitLabel(MCSymbol *Symbol) {}
34 
35 MCStreamer::MCStreamer(MCContext &Ctx)
36     : Context(Ctx), EmitEHFrame(true), EmitDebugFrame(false),
37       CurrentW64UnwindInfo(0), LastSymbol(0) {
38   SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>());
39 }
40 
41 MCStreamer::~MCStreamer() {
42   for (unsigned i = 0; i < getNumW64UnwindInfos(); ++i)
43     delete W64UnwindInfos[i];
44 }
45 
46 void MCStreamer::reset() {
47   for (unsigned i = 0; i < getNumW64UnwindInfos(); ++i)
48     delete W64UnwindInfos[i];
49   W64UnwindInfos.clear();
50   EmitEHFrame = true;
51   EmitDebugFrame = false;
52   CurrentW64UnwindInfo = 0;
53   LastSymbol = 0;
54   SectionStack.clear();
55   SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>());
56 }
57 
58 const 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 
71 const MCExpr *MCStreamer::ForceExpAbs(const MCExpr* Expr) {
72   if (Context.getAsmInfo()->hasAggressiveSymbolFolding() ||
73       isa<MCSymbolRefExpr>(Expr))
74     return Expr;
75 
76   MCSymbol *ABS = Context.CreateTempSymbol();
77   EmitAssignment(ABS, Expr);
78   return MCSymbolRefExpr::Create(ABS, Context);
79 }
80 
81 raw_ostream &MCStreamer::GetCommentOS() {
82   // By default, discard comments.
83   return nulls();
84 }
85 
86 void MCStreamer::emitRawComment(const Twine &T, bool TabPrefix) {}
87 
88 void MCStreamer::generateCompactUnwindEncodings(MCAsmBackend *MAB) {
89   for (std::vector<MCDwarfFrameInfo>::iterator I = FrameInfos.begin(),
90          E = FrameInfos.end(); I != E; ++I)
91     I->CompactUnwindEncoding =
92       (MAB ? MAB->generateCompactUnwindEncoding(I->Instructions) : 0);
93 }
94 
95 void 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 }
106 
107 /// EmitIntValue - Special case of EmitValue that avoids the client having to
108 /// pass in a MCExpr for constant integers.
109 void MCStreamer::EmitIntValue(uint64_t Value, unsigned Size) {
110   assert(Size <= 8 && "Invalid size");
111   assert((isUIntN(8 * Size, Value) || isIntN(8 * Size, Value)) &&
112          "Invalid size");
113   char buf[8];
114   const bool isLittleEndian = Context.getAsmInfo()->isLittleEndian();
115   for (unsigned i = 0; i != Size; ++i) {
116     unsigned index = isLittleEndian ? i : (Size - i - 1);
117     buf[i] = uint8_t(Value >> (index * 8));
118   }
119   EmitBytes(StringRef(buf, Size));
120 }
121 
122 /// EmitULEB128Value - Special case of EmitULEB128Value that avoids the
123 /// client having to pass in a MCExpr for constant integers.
124 void MCStreamer::EmitULEB128IntValue(uint64_t Value, unsigned Padding) {
125   SmallString<128> Tmp;
126   raw_svector_ostream OSE(Tmp);
127   encodeULEB128(Value, OSE, Padding);
128   EmitBytes(OSE.str());
129 }
130 
131 /// EmitSLEB128Value - Special case of EmitSLEB128Value that avoids the
132 /// client having to pass in a MCExpr for constant integers.
133 void MCStreamer::EmitSLEB128IntValue(int64_t Value) {
134   SmallString<128> Tmp;
135   raw_svector_ostream OSE(Tmp);
136   encodeSLEB128(Value, OSE);
137   EmitBytes(OSE.str());
138 }
139 
140 void MCStreamer::EmitAbsValue(const MCExpr *Value, unsigned Size) {
141   const MCExpr *ABS = ForceExpAbs(Value);
142   EmitValue(ABS, Size);
143 }
144 
145 
146 void MCStreamer::EmitValue(const MCExpr *Value, unsigned Size) {
147   EmitValueImpl(Value, Size);
148 }
149 
150 void MCStreamer::EmitSymbolValue(const MCSymbol *Sym, unsigned Size) {
151   EmitValueImpl(MCSymbolRefExpr::Create(Sym, getContext()), Size);
152 }
153 
154 void MCStreamer::EmitGPRel64Value(const MCExpr *Value) {
155   report_fatal_error("unsupported directive in streamer");
156 }
157 
158 void MCStreamer::EmitGPRel32Value(const MCExpr *Value) {
159   report_fatal_error("unsupported directive in streamer");
160 }
161 
162 /// EmitFill - Emit NumBytes bytes worth of the value specified by
163 /// FillValue.  This implements directives such as '.space'.
164 void MCStreamer::EmitFill(uint64_t NumBytes, uint8_t FillValue) {
165   const MCExpr *E = MCConstantExpr::Create(FillValue, getContext());
166   for (uint64_t i = 0, e = NumBytes; i != e; ++i)
167     EmitValue(E, 1);
168 }
169 
170 /// The implementation in this class just redirects to EmitFill.
171 void MCStreamer::EmitZeros(uint64_t NumBytes) {
172   EmitFill(NumBytes, 0);
173 }
174 
175 bool MCStreamer::EmitDwarfFileDirective(unsigned FileNo,
176                                         StringRef Directory,
177                                         StringRef Filename, unsigned CUID) {
178   return getContext().GetDwarfFile(Directory, Filename, FileNo, CUID) == 0;
179 }
180 
181 void MCStreamer::EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
182                                        unsigned Column, unsigned Flags,
183                                        unsigned Isa,
184                                        unsigned Discriminator,
185                                        StringRef FileName) {
186   getContext().setCurrentDwarfLoc(FileNo, Line, Column, Flags, Isa,
187                                   Discriminator);
188 }
189 
190 MCDwarfFrameInfo *MCStreamer::getCurrentFrameInfo() {
191   if (FrameInfos.empty())
192     return 0;
193   return &FrameInfos.back();
194 }
195 
196 void MCStreamer::EnsureValidFrame() {
197   MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
198   if (!CurFrame || CurFrame->End)
199     report_fatal_error("No open frame");
200 }
201 
202 void MCStreamer::EmitEHSymAttributes(const MCSymbol *Symbol,
203                                      MCSymbol *EHSymbol) {
204 }
205 
206 void MCStreamer::InitSections(bool Force) {
207   SwitchSection(getContext().getObjectFileInfo()->getTextSection());
208 }
209 
210 void 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 
221 void MCStreamer::EmitLabel(MCSymbol *Symbol) {
222   assert(!Symbol->isVariable() && "Cannot emit a variable symbol!");
223   assert(getCurrentSection().first && "Cannot emit before setting section!");
224   AssignSection(Symbol, getCurrentSection().first);
225   LastSymbol = Symbol;
226 
227   MCTargetStreamer *TS = getTargetStreamer();
228   if (TS)
229     TS->emitLabel(Symbol);
230 }
231 
232 void MCStreamer::EmitDebugLabel(MCSymbol *Symbol) {
233   assert(!Symbol->isVariable() && "Cannot emit a variable symbol!");
234   assert(getCurrentSection().first && "Cannot emit before setting section!");
235   AssignSection(Symbol, getCurrentSection().first);
236   LastSymbol = Symbol;
237 }
238 
239 void MCStreamer::EmitCompactUnwindEncoding(uint32_t CompactUnwindEncoding) {
240   EnsureValidFrame();
241   MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
242   CurFrame->CompactUnwindEncoding = CompactUnwindEncoding;
243 }
244 
245 void MCStreamer::EmitCFISections(bool EH, bool Debug) {
246   assert(EH || Debug);
247   EmitEHFrame = EH;
248   EmitDebugFrame = Debug;
249 }
250 
251 void MCStreamer::EmitCFIStartProc(bool IsSimple) {
252   MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
253   if (CurFrame && !CurFrame->End)
254     report_fatal_error("Starting a frame before finishing the previous one!");
255 
256   MCDwarfFrameInfo Frame;
257   Frame.IsSimple = IsSimple;
258   EmitCFIStartProcImpl(Frame);
259 
260   FrameInfos.push_back(Frame);
261 }
262 
263 void MCStreamer::EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) {
264 }
265 
266 void MCStreamer::RecordProcStart(MCDwarfFrameInfo &Frame) {
267   Frame.Function = LastSymbol;
268   // If the function is externally visible, we need to create a local
269   // symbol to avoid relocations.
270   StringRef Prefix = getContext().getAsmInfo()->getPrivateGlobalPrefix();
271   if (LastSymbol && LastSymbol->getName().startswith(Prefix)) {
272     Frame.Begin = LastSymbol;
273   } else {
274     Frame.Begin = getContext().CreateTempSymbol();
275     EmitLabel(Frame.Begin);
276   }
277 }
278 
279 void MCStreamer::EmitCFIEndProc() {
280   EnsureValidFrame();
281   MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
282   EmitCFIEndProcImpl(*CurFrame);
283 }
284 
285 void MCStreamer::EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) {
286 }
287 
288 void MCStreamer::RecordProcEnd(MCDwarfFrameInfo &Frame) {
289   Frame.End = getContext().CreateTempSymbol();
290   EmitLabel(Frame.End);
291 }
292 
293 MCSymbol *MCStreamer::EmitCFICommon() {
294   EnsureValidFrame();
295   MCSymbol *Label = getContext().CreateTempSymbol();
296   EmitLabel(Label);
297   return Label;
298 }
299 
300 void MCStreamer::EmitCFIDefCfa(int64_t Register, int64_t Offset) {
301   MCSymbol *Label = EmitCFICommon();
302   MCCFIInstruction Instruction =
303     MCCFIInstruction::createDefCfa(Label, Register, Offset);
304   MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
305   CurFrame->Instructions.push_back(Instruction);
306 }
307 
308 void MCStreamer::EmitCFIDefCfaOffset(int64_t Offset) {
309   MCSymbol *Label = EmitCFICommon();
310   MCCFIInstruction Instruction =
311     MCCFIInstruction::createDefCfaOffset(Label, Offset);
312   MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
313   CurFrame->Instructions.push_back(Instruction);
314 }
315 
316 void MCStreamer::EmitCFIAdjustCfaOffset(int64_t Adjustment) {
317   MCSymbol *Label = EmitCFICommon();
318   MCCFIInstruction Instruction =
319     MCCFIInstruction::createAdjustCfaOffset(Label, Adjustment);
320   MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
321   CurFrame->Instructions.push_back(Instruction);
322 }
323 
324 void MCStreamer::EmitCFIDefCfaRegister(int64_t Register) {
325   MCSymbol *Label = EmitCFICommon();
326   MCCFIInstruction Instruction =
327     MCCFIInstruction::createDefCfaRegister(Label, Register);
328   MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
329   CurFrame->Instructions.push_back(Instruction);
330 }
331 
332 void MCStreamer::EmitCFIOffset(int64_t Register, int64_t Offset) {
333   MCSymbol *Label = EmitCFICommon();
334   MCCFIInstruction Instruction =
335     MCCFIInstruction::createOffset(Label, Register, Offset);
336   MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
337   CurFrame->Instructions.push_back(Instruction);
338 }
339 
340 void MCStreamer::EmitCFIRelOffset(int64_t Register, int64_t Offset) {
341   MCSymbol *Label = EmitCFICommon();
342   MCCFIInstruction Instruction =
343     MCCFIInstruction::createRelOffset(Label, Register, Offset);
344   MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
345   CurFrame->Instructions.push_back(Instruction);
346 }
347 
348 void MCStreamer::EmitCFIPersonality(const MCSymbol *Sym,
349                                     unsigned Encoding) {
350   EnsureValidFrame();
351   MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
352   CurFrame->Personality = Sym;
353   CurFrame->PersonalityEncoding = Encoding;
354 }
355 
356 void MCStreamer::EmitCFILsda(const MCSymbol *Sym, unsigned Encoding) {
357   EnsureValidFrame();
358   MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
359   CurFrame->Lsda = Sym;
360   CurFrame->LsdaEncoding = Encoding;
361 }
362 
363 void MCStreamer::EmitCFIRememberState() {
364   MCSymbol *Label = EmitCFICommon();
365   MCCFIInstruction Instruction = MCCFIInstruction::createRememberState(Label);
366   MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
367   CurFrame->Instructions.push_back(Instruction);
368 }
369 
370 void MCStreamer::EmitCFIRestoreState() {
371   // FIXME: Error if there is no matching cfi_remember_state.
372   MCSymbol *Label = EmitCFICommon();
373   MCCFIInstruction Instruction = MCCFIInstruction::createRestoreState(Label);
374   MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
375   CurFrame->Instructions.push_back(Instruction);
376 }
377 
378 void MCStreamer::EmitCFISameValue(int64_t Register) {
379   MCSymbol *Label = EmitCFICommon();
380   MCCFIInstruction Instruction =
381     MCCFIInstruction::createSameValue(Label, Register);
382   MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
383   CurFrame->Instructions.push_back(Instruction);
384 }
385 
386 void MCStreamer::EmitCFIRestore(int64_t Register) {
387   MCSymbol *Label = EmitCFICommon();
388   MCCFIInstruction Instruction =
389     MCCFIInstruction::createRestore(Label, Register);
390   MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
391   CurFrame->Instructions.push_back(Instruction);
392 }
393 
394 void MCStreamer::EmitCFIEscape(StringRef Values) {
395   MCSymbol *Label = EmitCFICommon();
396   MCCFIInstruction Instruction = MCCFIInstruction::createEscape(Label, Values);
397   MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
398   CurFrame->Instructions.push_back(Instruction);
399 }
400 
401 void MCStreamer::EmitCFISignalFrame() {
402   EnsureValidFrame();
403   MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
404   CurFrame->IsSignalFrame = true;
405 }
406 
407 void MCStreamer::EmitCFIUndefined(int64_t Register) {
408   MCSymbol *Label = EmitCFICommon();
409   MCCFIInstruction Instruction =
410     MCCFIInstruction::createUndefined(Label, Register);
411   MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
412   CurFrame->Instructions.push_back(Instruction);
413 }
414 
415 void 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 
423 void 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 
431 void MCStreamer::setCurrentW64UnwindInfo(MCWin64EHUnwindInfo *Frame) {
432   W64UnwindInfos.push_back(Frame);
433   CurrentW64UnwindInfo = W64UnwindInfos.back();
434 }
435 
436 void MCStreamer::EnsureValidW64UnwindInfo() {
437   MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
438   if (!CurFrame || CurFrame->End)
439     report_fatal_error("No open Win64 EH frame function!");
440 }
441 
442 void MCStreamer::EmitWin64EHStartProc(const MCSymbol *Symbol) {
443   MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
444   if (CurFrame && !CurFrame->End)
445     report_fatal_error("Starting a function before ending the previous one!");
446   MCWin64EHUnwindInfo *Frame = new MCWin64EHUnwindInfo;
447   Frame->Begin = getContext().CreateTempSymbol();
448   Frame->Function = Symbol;
449   EmitLabel(Frame->Begin);
450   setCurrentW64UnwindInfo(Frame);
451 }
452 
453 void MCStreamer::EmitWin64EHEndProc() {
454   EnsureValidW64UnwindInfo();
455   MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
456   if (CurFrame->ChainedParent)
457     report_fatal_error("Not all chained regions terminated!");
458   CurFrame->End = getContext().CreateTempSymbol();
459   EmitLabel(CurFrame->End);
460 }
461 
462 void MCStreamer::EmitWin64EHStartChained() {
463   EnsureValidW64UnwindInfo();
464   MCWin64EHUnwindInfo *Frame = new MCWin64EHUnwindInfo;
465   MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
466   Frame->Begin = getContext().CreateTempSymbol();
467   Frame->Function = CurFrame->Function;
468   Frame->ChainedParent = CurFrame;
469   EmitLabel(Frame->Begin);
470   setCurrentW64UnwindInfo(Frame);
471 }
472 
473 void MCStreamer::EmitWin64EHEndChained() {
474   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;
481 }
482 
483 void MCStreamer::EmitWin64EHHandler(const MCSymbol *Sym, bool Unwind,
484                                     bool Except) {
485   EnsureValidW64UnwindInfo();
486   MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
487   if (CurFrame->ChainedParent)
488     report_fatal_error("Chained unwind areas can't have handlers!");
489   CurFrame->ExceptionHandler = Sym;
490   if (!Except && !Unwind)
491     report_fatal_error("Don't know what kind of handler this is!");
492   if (Unwind)
493     CurFrame->HandlesUnwind = true;
494   if (Except)
495     CurFrame->HandlesExceptions = true;
496 }
497 
498 void MCStreamer::EmitWin64EHHandlerData() {
499   EnsureValidW64UnwindInfo();
500   MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
501   if (CurFrame->ChainedParent)
502     report_fatal_error("Chained unwind areas can't have handlers!");
503 }
504 
505 void MCStreamer::EmitWin64EHPushReg(unsigned Register) {
506   EnsureValidW64UnwindInfo();
507   MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
508   MCSymbol *Label = getContext().CreateTempSymbol();
509   MCWin64EHInstruction Inst(Win64EH::UOP_PushNonVol, Label, Register);
510   EmitLabel(Label);
511   CurFrame->Instructions.push_back(Inst);
512 }
513 
514 void MCStreamer::EmitWin64EHSetFrame(unsigned Register, unsigned Offset) {
515   EnsureValidW64UnwindInfo();
516   MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
517   if (CurFrame->LastFrameInst >= 0)
518     report_fatal_error("Frame register and offset already specified!");
519   if (Offset & 0x0F)
520     report_fatal_error("Misaligned frame pointer offset!");
521   MCSymbol *Label = getContext().CreateTempSymbol();
522   MCWin64EHInstruction Inst(Win64EH::UOP_SetFPReg, Label, Register, Offset);
523   EmitLabel(Label);
524   CurFrame->LastFrameInst = CurFrame->Instructions.size();
525   CurFrame->Instructions.push_back(Inst);
526 }
527 
528 void MCStreamer::EmitWin64EHAllocStack(unsigned Size) {
529   EnsureValidW64UnwindInfo();
530   if (Size & 7)
531     report_fatal_error("Misaligned stack allocation!");
532   MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
533   MCSymbol *Label = getContext().CreateTempSymbol();
534   MCWin64EHInstruction Inst(Label, Size);
535   EmitLabel(Label);
536   CurFrame->Instructions.push_back(Inst);
537 }
538 
539 void MCStreamer::EmitWin64EHSaveReg(unsigned Register, unsigned Offset) {
540   EnsureValidW64UnwindInfo();
541   if (Offset & 7)
542     report_fatal_error("Misaligned saved register offset!");
543   MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
544   MCSymbol *Label = getContext().CreateTempSymbol();
545   MCWin64EHInstruction Inst(
546      Offset > 512*1024-8 ? Win64EH::UOP_SaveNonVolBig : Win64EH::UOP_SaveNonVol,
547                             Label, Register, Offset);
548   EmitLabel(Label);
549   CurFrame->Instructions.push_back(Inst);
550 }
551 
552 void MCStreamer::EmitWin64EHSaveXMM(unsigned Register, unsigned Offset) {
553   EnsureValidW64UnwindInfo();
554   if (Offset & 0x0F)
555     report_fatal_error("Misaligned saved vector register offset!");
556   MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
557   MCSymbol *Label = getContext().CreateTempSymbol();
558   MCWin64EHInstruction Inst(
559     Offset > 512*1024-16 ? Win64EH::UOP_SaveXMM128Big : Win64EH::UOP_SaveXMM128,
560                             Label, Register, Offset);
561   EmitLabel(Label);
562   CurFrame->Instructions.push_back(Inst);
563 }
564 
565 void MCStreamer::EmitWin64EHPushFrame(bool Code) {
566   EnsureValidW64UnwindInfo();
567   MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
568   if (CurFrame->Instructions.size() > 0)
569     report_fatal_error("If present, PushMachFrame must be the first UOP");
570   MCSymbol *Label = getContext().CreateTempSymbol();
571   MCWin64EHInstruction Inst(Win64EH::UOP_PushMachFrame, Label, Code);
572   EmitLabel(Label);
573   CurFrame->Instructions.push_back(Inst);
574 }
575 
576 void MCStreamer::EmitWin64EHEndProlog() {
577   EnsureValidW64UnwindInfo();
578   MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
579   CurFrame->PrologEnd = getContext().CreateTempSymbol();
580   EmitLabel(CurFrame->PrologEnd);
581 }
582 
583 void MCStreamer::EmitCOFFSectionIndex(MCSymbol const *Symbol) {
584   llvm_unreachable("This file format doesn't support this directive");
585 }
586 
587 void MCStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol) {
588   llvm_unreachable("This file format doesn't support this directive");
589 }
590 
591 /// EmitRawText - If this file is backed by an assembly streamer, this dumps
592 /// the specified string in the output .s file.  This capability is
593 /// indicated by the hasRawTextSupport() predicate.
594 void MCStreamer::EmitRawTextImpl(StringRef String) {
595   errs() << "EmitRawText called on an MCStreamer that doesn't support it, "
596   " something must not be fully mc'ized\n";
597   abort();
598 }
599 
600 void MCStreamer::EmitRawText(const Twine &T) {
601   SmallString<128> Str;
602   EmitRawTextImpl(T.toStringRef(Str));
603 }
604 
605 void MCStreamer::EmitFrames(MCAsmBackend *MAB, bool usingCFI) {
606   if (!getNumFrameInfos())
607     return;
608 
609   if (EmitEHFrame)
610     MCDwarfFrameEmitter::Emit(*this, MAB, usingCFI, true);
611 
612   if (EmitDebugFrame)
613     MCDwarfFrameEmitter::Emit(*this, MAB, usingCFI, false);
614 }
615 
616 void MCStreamer::EmitW64Tables() {
617   if (!getNumW64UnwindInfos())
618     return;
619 
620   MCWin64EHUnwindEmitter::Emit(*this);
621 }
622 
623 void MCStreamer::Finish() {
624   if (!FrameInfos.empty() && !FrameInfos.back().End)
625     report_fatal_error("Unfinished frame!");
626 
627   FinishImpl();
628 }
629 
630 MCSymbolData &MCStreamer::getOrCreateSymbolData(MCSymbol *Symbol) {
631   report_fatal_error("Not supported!");
632   return *(static_cast<MCSymbolData*>(0));
633 }
634