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