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/MCInst.h"
18 #include "llvm/MC/MCInstPrinter.h"
19 #include "llvm/MC/MCObjectFileInfo.h"
20 #include "llvm/MC/MCObjectWriter.h"
21 #include "llvm/MC/MCSection.h"
22 #include "llvm/MC/MCSymbol.h"
23 #include "llvm/MC/MCWin64EH.h"
24 #include "llvm/Support/ErrorHandling.h"
25 #include "llvm/Support/LEB128.h"
26 #include "llvm/Support/raw_ostream.h"
27 #include <cstdlib>
28 using namespace llvm;
29 
30 // Pin the vtables to this file.
31 MCTargetStreamer::~MCTargetStreamer() {}
32 
33 MCTargetStreamer::MCTargetStreamer(MCStreamer &S) : Streamer(S) {
34   S.setTargetStreamer(this);
35 }
36 
37 void MCTargetStreamer::emitLabel(MCSymbol *Symbol) {}
38 
39 void MCTargetStreamer::finish() {}
40 
41 void MCTargetStreamer::emitAssignment(MCSymbol *Symbol, const MCExpr *Value) {}
42 
43 MCStreamer::MCStreamer(MCContext &Ctx)
44     : Context(Ctx), CurrentWinFrameInfo(nullptr) {
45   SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>());
46 }
47 
48 MCStreamer::~MCStreamer() {
49   for (unsigned i = 0; i < getNumWinFrameInfos(); ++i)
50     delete WinFrameInfos[i];
51 }
52 
53 void MCStreamer::reset() {
54   DwarfFrameInfos.clear();
55   for (unsigned i = 0; i < getNumWinFrameInfos(); ++i)
56     delete WinFrameInfos[i];
57   WinFrameInfos.clear();
58   CurrentWinFrameInfo = nullptr;
59   SymbolOrdering.clear();
60   SectionStack.clear();
61   SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>());
62 }
63 
64 raw_ostream &MCStreamer::GetCommentOS() {
65   // By default, discard comments.
66   return nulls();
67 }
68 
69 void MCStreamer::emitRawComment(const Twine &T, bool TabPrefix) {}
70 
71 void MCStreamer::generateCompactUnwindEncodings(MCAsmBackend *MAB) {
72   for (auto &FI : DwarfFrameInfos)
73     FI.CompactUnwindEncoding =
74         (MAB ? MAB->generateCompactUnwindEncoding(FI.Instructions) : 0);
75 }
76 
77 /// EmitIntValue - Special case of EmitValue that avoids the client having to
78 /// pass in a MCExpr for constant integers.
79 void MCStreamer::EmitIntValue(uint64_t Value, unsigned Size) {
80   assert(1 <= Size && Size <= 8 && "Invalid size");
81   assert((isUIntN(8 * Size, Value) || isIntN(8 * Size, Value)) &&
82          "Invalid size");
83   char buf[8];
84   const bool isLittleEndian = Context.getAsmInfo()->isLittleEndian();
85   for (unsigned i = 0; i != Size; ++i) {
86     unsigned index = isLittleEndian ? i : (Size - i - 1);
87     buf[i] = uint8_t(Value >> (index * 8));
88   }
89   EmitBytes(StringRef(buf, Size));
90 }
91 
92 /// EmitULEB128Value - Special case of EmitULEB128Value that avoids the
93 /// client having to pass in a MCExpr for constant integers.
94 void MCStreamer::EmitULEB128IntValue(uint64_t Value, unsigned Padding) {
95   SmallString<128> Tmp;
96   raw_svector_ostream OSE(Tmp);
97   encodeULEB128(Value, OSE, Padding);
98   EmitBytes(OSE.str());
99 }
100 
101 /// EmitSLEB128Value - Special case of EmitSLEB128Value that avoids the
102 /// client having to pass in a MCExpr for constant integers.
103 void MCStreamer::EmitSLEB128IntValue(int64_t Value) {
104   SmallString<128> Tmp;
105   raw_svector_ostream OSE(Tmp);
106   encodeSLEB128(Value, OSE);
107   EmitBytes(OSE.str());
108 }
109 
110 void MCStreamer::EmitValue(const MCExpr *Value, unsigned Size, SMLoc Loc) {
111   EmitValueImpl(Value, Size, Loc);
112 }
113 
114 void MCStreamer::EmitSymbolValue(const MCSymbol *Sym, unsigned Size,
115                                  bool IsSectionRelative) {
116   assert((!IsSectionRelative || Size == 4) &&
117          "SectionRelative value requires 4-bytes");
118 
119   if (!IsSectionRelative)
120     EmitValueImpl(MCSymbolRefExpr::create(Sym, getContext()), Size);
121   else
122     EmitCOFFSecRel32(Sym);
123 }
124 
125 void MCStreamer::EmitGPRel64Value(const MCExpr *Value) {
126   report_fatal_error("unsupported directive in streamer");
127 }
128 
129 void MCStreamer::EmitGPRel32Value(const MCExpr *Value) {
130   report_fatal_error("unsupported directive in streamer");
131 }
132 
133 /// EmitFill - Emit NumBytes bytes worth of the value specified by
134 /// FillValue.  This implements directives such as '.space'.
135 void MCStreamer::EmitFill(uint64_t NumBytes, uint8_t FillValue) {
136   const MCExpr *E = MCConstantExpr::create(FillValue, getContext());
137   for (uint64_t i = 0, e = NumBytes; i != e; ++i)
138     EmitValue(E, 1);
139 }
140 
141 /// The implementation in this class just redirects to EmitFill.
142 void MCStreamer::EmitZeros(uint64_t NumBytes) {
143   EmitFill(NumBytes, 0);
144 }
145 
146 unsigned MCStreamer::EmitDwarfFileDirective(unsigned FileNo,
147                                             StringRef Directory,
148                                             StringRef Filename, unsigned CUID) {
149   return getContext().getDwarfFile(Directory, Filename, FileNo, CUID);
150 }
151 
152 void MCStreamer::EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
153                                        unsigned Column, unsigned Flags,
154                                        unsigned Isa,
155                                        unsigned Discriminator,
156                                        StringRef FileName) {
157   getContext().setCurrentDwarfLoc(FileNo, Line, Column, Flags, Isa,
158                                   Discriminator);
159 }
160 
161 MCSymbol *MCStreamer::getDwarfLineTableSymbol(unsigned CUID) {
162   MCDwarfLineTable &Table = getContext().getMCDwarfLineTable(CUID);
163   if (!Table.getLabel()) {
164     StringRef Prefix = Context.getAsmInfo()->getPrivateGlobalPrefix();
165     Table.setLabel(
166         Context.getOrCreateSymbol(Prefix + "line_table_start" + Twine(CUID)));
167   }
168   return Table.getLabel();
169 }
170 
171 MCDwarfFrameInfo *MCStreamer::getCurrentDwarfFrameInfo() {
172   if (DwarfFrameInfos.empty())
173     return nullptr;
174   return &DwarfFrameInfos.back();
175 }
176 
177 bool MCStreamer::hasUnfinishedDwarfFrameInfo() {
178   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
179   return CurFrame && !CurFrame->End;
180 }
181 
182 void MCStreamer::EnsureValidDwarfFrame() {
183   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
184   if (!CurFrame || CurFrame->End)
185     report_fatal_error("No open frame");
186 }
187 
188 unsigned MCStreamer::EmitCVFileDirective(unsigned FileNo, StringRef Filename) {
189   return getContext().getCVFile(Filename, FileNo);
190 }
191 
192 void MCStreamer::EmitCVLocDirective(unsigned FunctionId, unsigned FileNo,
193                                     unsigned Line, unsigned Column,
194                                     bool PrologueEnd, bool IsStmt,
195                                     StringRef FileName) {
196   getContext().setCurrentCVLoc(FunctionId, FileNo, Line, Column, PrologueEnd,
197                                IsStmt);
198 }
199 
200 void MCStreamer::EmitCVLinetableDirective(unsigned FunctionId,
201                                           const MCSymbol *Begin,
202                                           const MCSymbol *End) {}
203 
204 void MCStreamer::EmitCVInlineLinetableDirective(
205     unsigned PrimaryFunctionId, unsigned SourceFileId, unsigned SourceLineNum,
206     const MCSymbol *FnStartSym, const MCSymbol *FnEndSym,
207     ArrayRef<unsigned> SecondaryFunctionIds) {}
208 
209 void MCStreamer::EmitCVDefRangeDirective(
210     ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
211     StringRef FixedSizePortion) {}
212 
213 void MCStreamer::EmitEHSymAttributes(const MCSymbol *Symbol,
214                                      MCSymbol *EHSymbol) {
215 }
216 
217 void MCStreamer::InitSections(bool NoExecStack) {
218   SwitchSection(getContext().getObjectFileInfo()->getTextSection());
219 }
220 
221 void MCStreamer::AssignFragment(MCSymbol *Symbol, MCFragment *Fragment) {
222   assert(Fragment);
223   Symbol->setFragment(Fragment);
224 
225   // As we emit symbols into a section, track the order so that they can
226   // be sorted upon later. Zero is reserved to mean 'unemitted'.
227   SymbolOrdering[Symbol] = 1 + SymbolOrdering.size();
228 }
229 
230 void MCStreamer::EmitLabel(MCSymbol *Symbol) {
231   assert(!Symbol->isVariable() && "Cannot emit a variable symbol!");
232   assert(getCurrentSection().first && "Cannot emit before setting section!");
233   assert(!Symbol->getFragment() && "Unexpected fragment on symbol data!");
234   Symbol->setFragment(&getCurrentSectionOnly()->getDummyFragment());
235 
236   MCTargetStreamer *TS = getTargetStreamer();
237   if (TS)
238     TS->emitLabel(Symbol);
239 }
240 
241 void MCStreamer::EmitCFISections(bool EH, bool Debug) {
242   assert(EH || Debug);
243 }
244 
245 void MCStreamer::EmitCFIStartProc(bool IsSimple) {
246   if (hasUnfinishedDwarfFrameInfo())
247     report_fatal_error("Starting a frame before finishing the previous one!");
248 
249   MCDwarfFrameInfo Frame;
250   Frame.IsSimple = IsSimple;
251   EmitCFIStartProcImpl(Frame);
252 
253   const MCAsmInfo* MAI = Context.getAsmInfo();
254   if (MAI) {
255     for (const MCCFIInstruction& Inst : MAI->getInitialFrameState()) {
256       if (Inst.getOperation() == MCCFIInstruction::OpDefCfa ||
257           Inst.getOperation() == MCCFIInstruction::OpDefCfaRegister) {
258         Frame.CurrentCfaRegister = Inst.getRegister();
259       }
260     }
261   }
262 
263   DwarfFrameInfos.push_back(Frame);
264 }
265 
266 void MCStreamer::EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) {
267 }
268 
269 void MCStreamer::EmitCFIEndProc() {
270   EnsureValidDwarfFrame();
271   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
272   EmitCFIEndProcImpl(*CurFrame);
273 }
274 
275 void MCStreamer::EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) {
276   // Put a dummy non-null value in Frame.End to mark that this frame has been
277   // closed.
278   Frame.End = (MCSymbol *) 1;
279 }
280 
281 MCSymbol *MCStreamer::EmitCFICommon() {
282   EnsureValidDwarfFrame();
283   MCSymbol *Label = getContext().createTempSymbol();
284   EmitLabel(Label);
285   return Label;
286 }
287 
288 void MCStreamer::EmitCFIDefCfa(int64_t Register, int64_t Offset) {
289   MCSymbol *Label = EmitCFICommon();
290   MCCFIInstruction Instruction =
291     MCCFIInstruction::createDefCfa(Label, Register, Offset);
292   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
293   CurFrame->Instructions.push_back(Instruction);
294   CurFrame->CurrentCfaRegister = static_cast<unsigned>(Register);
295 }
296 
297 void MCStreamer::EmitCFIDefCfaOffset(int64_t Offset) {
298   MCSymbol *Label = EmitCFICommon();
299   MCCFIInstruction Instruction =
300     MCCFIInstruction::createDefCfaOffset(Label, Offset);
301   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
302   CurFrame->Instructions.push_back(Instruction);
303 }
304 
305 void MCStreamer::EmitCFIAdjustCfaOffset(int64_t Adjustment) {
306   MCSymbol *Label = EmitCFICommon();
307   MCCFIInstruction Instruction =
308     MCCFIInstruction::createAdjustCfaOffset(Label, Adjustment);
309   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
310   CurFrame->Instructions.push_back(Instruction);
311 }
312 
313 void MCStreamer::EmitCFIDefCfaRegister(int64_t Register) {
314   MCSymbol *Label = EmitCFICommon();
315   MCCFIInstruction Instruction =
316     MCCFIInstruction::createDefCfaRegister(Label, Register);
317   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
318   CurFrame->Instructions.push_back(Instruction);
319   CurFrame->CurrentCfaRegister = static_cast<unsigned>(Register);
320 }
321 
322 void MCStreamer::EmitCFIOffset(int64_t Register, int64_t Offset) {
323   MCSymbol *Label = EmitCFICommon();
324   MCCFIInstruction Instruction =
325     MCCFIInstruction::createOffset(Label, Register, Offset);
326   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
327   CurFrame->Instructions.push_back(Instruction);
328 }
329 
330 void MCStreamer::EmitCFIRelOffset(int64_t Register, int64_t Offset) {
331   MCSymbol *Label = EmitCFICommon();
332   MCCFIInstruction Instruction =
333     MCCFIInstruction::createRelOffset(Label, Register, Offset);
334   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
335   CurFrame->Instructions.push_back(Instruction);
336 }
337 
338 void MCStreamer::EmitCFIPersonality(const MCSymbol *Sym,
339                                     unsigned Encoding) {
340   EnsureValidDwarfFrame();
341   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
342   CurFrame->Personality = Sym;
343   CurFrame->PersonalityEncoding = Encoding;
344 }
345 
346 void MCStreamer::EmitCFILsda(const MCSymbol *Sym, unsigned Encoding) {
347   EnsureValidDwarfFrame();
348   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
349   CurFrame->Lsda = Sym;
350   CurFrame->LsdaEncoding = Encoding;
351 }
352 
353 void MCStreamer::EmitCFIRememberState() {
354   MCSymbol *Label = EmitCFICommon();
355   MCCFIInstruction Instruction = MCCFIInstruction::createRememberState(Label);
356   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
357   CurFrame->Instructions.push_back(Instruction);
358 }
359 
360 void MCStreamer::EmitCFIRestoreState() {
361   // FIXME: Error if there is no matching cfi_remember_state.
362   MCSymbol *Label = EmitCFICommon();
363   MCCFIInstruction Instruction = MCCFIInstruction::createRestoreState(Label);
364   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
365   CurFrame->Instructions.push_back(Instruction);
366 }
367 
368 void MCStreamer::EmitCFISameValue(int64_t Register) {
369   MCSymbol *Label = EmitCFICommon();
370   MCCFIInstruction Instruction =
371     MCCFIInstruction::createSameValue(Label, Register);
372   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
373   CurFrame->Instructions.push_back(Instruction);
374 }
375 
376 void MCStreamer::EmitCFIRestore(int64_t Register) {
377   MCSymbol *Label = EmitCFICommon();
378   MCCFIInstruction Instruction =
379     MCCFIInstruction::createRestore(Label, Register);
380   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
381   CurFrame->Instructions.push_back(Instruction);
382 }
383 
384 void MCStreamer::EmitCFIEscape(StringRef Values) {
385   MCSymbol *Label = EmitCFICommon();
386   MCCFIInstruction Instruction = MCCFIInstruction::createEscape(Label, Values);
387   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
388   CurFrame->Instructions.push_back(Instruction);
389 }
390 
391 void MCStreamer::EmitCFIGnuArgsSize(int64_t Size) {
392   MCSymbol *Label = EmitCFICommon();
393   MCCFIInstruction Instruction =
394     MCCFIInstruction::createGnuArgsSize(Label, Size);
395   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
396   CurFrame->Instructions.push_back(Instruction);
397 }
398 
399 void MCStreamer::EmitCFISignalFrame() {
400   EnsureValidDwarfFrame();
401   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
402   CurFrame->IsSignalFrame = true;
403 }
404 
405 void MCStreamer::EmitCFIUndefined(int64_t Register) {
406   MCSymbol *Label = EmitCFICommon();
407   MCCFIInstruction Instruction =
408     MCCFIInstruction::createUndefined(Label, Register);
409   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
410   CurFrame->Instructions.push_back(Instruction);
411 }
412 
413 void MCStreamer::EmitCFIRegister(int64_t Register1, int64_t Register2) {
414   MCSymbol *Label = EmitCFICommon();
415   MCCFIInstruction Instruction =
416     MCCFIInstruction::createRegister(Label, Register1, Register2);
417   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
418   CurFrame->Instructions.push_back(Instruction);
419 }
420 
421 void MCStreamer::EmitCFIWindowSave() {
422   MCSymbol *Label = EmitCFICommon();
423   MCCFIInstruction Instruction =
424     MCCFIInstruction::createWindowSave(Label);
425   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
426   CurFrame->Instructions.push_back(Instruction);
427 }
428 
429 void MCStreamer::EnsureValidWinFrameInfo() {
430   const MCAsmInfo *MAI = Context.getAsmInfo();
431   if (!MAI->usesWindowsCFI())
432     report_fatal_error(".seh_* directives are not supported on this target");
433   if (!CurrentWinFrameInfo || CurrentWinFrameInfo->End)
434     report_fatal_error("No open Win64 EH frame function!");
435 }
436 
437 void MCStreamer::EmitWinCFIStartProc(const MCSymbol *Symbol) {
438   const MCAsmInfo *MAI = Context.getAsmInfo();
439   if (!MAI->usesWindowsCFI())
440     report_fatal_error(".seh_* directives are not supported on this target");
441   if (CurrentWinFrameInfo && !CurrentWinFrameInfo->End)
442     report_fatal_error("Starting a function before ending the previous one!");
443 
444   MCSymbol *StartProc = getContext().createTempSymbol();
445   EmitLabel(StartProc);
446 
447   WinFrameInfos.push_back(new WinEH::FrameInfo(Symbol, StartProc));
448   CurrentWinFrameInfo = WinFrameInfos.back();
449 }
450 
451 void MCStreamer::EmitWinCFIEndProc() {
452   EnsureValidWinFrameInfo();
453   if (CurrentWinFrameInfo->ChainedParent)
454     report_fatal_error("Not all chained regions terminated!");
455 
456   MCSymbol *Label = getContext().createTempSymbol();
457   EmitLabel(Label);
458   CurrentWinFrameInfo->End = Label;
459 }
460 
461 void MCStreamer::EmitWinCFIStartChained() {
462   EnsureValidWinFrameInfo();
463 
464   MCSymbol *StartProc = getContext().createTempSymbol();
465   EmitLabel(StartProc);
466 
467   WinFrameInfos.push_back(new WinEH::FrameInfo(CurrentWinFrameInfo->Function,
468                                                StartProc, CurrentWinFrameInfo));
469   CurrentWinFrameInfo = WinFrameInfos.back();
470 }
471 
472 void MCStreamer::EmitWinCFIEndChained() {
473   EnsureValidWinFrameInfo();
474   if (!CurrentWinFrameInfo->ChainedParent)
475     report_fatal_error("End of a chained region outside a chained region!");
476 
477   MCSymbol *Label = getContext().createTempSymbol();
478   EmitLabel(Label);
479 
480   CurrentWinFrameInfo->End = Label;
481   CurrentWinFrameInfo =
482       const_cast<WinEH::FrameInfo *>(CurrentWinFrameInfo->ChainedParent);
483 }
484 
485 void MCStreamer::EmitWinEHHandler(const MCSymbol *Sym, bool Unwind,
486                                   bool Except) {
487   EnsureValidWinFrameInfo();
488   if (CurrentWinFrameInfo->ChainedParent)
489     report_fatal_error("Chained unwind areas can't have handlers!");
490   CurrentWinFrameInfo->ExceptionHandler = Sym;
491   if (!Except && !Unwind)
492     report_fatal_error("Don't know what kind of handler this is!");
493   if (Unwind)
494     CurrentWinFrameInfo->HandlesUnwind = true;
495   if (Except)
496     CurrentWinFrameInfo->HandlesExceptions = true;
497 }
498 
499 void MCStreamer::EmitWinEHHandlerData() {
500   EnsureValidWinFrameInfo();
501   if (CurrentWinFrameInfo->ChainedParent)
502     report_fatal_error("Chained unwind areas can't have handlers!");
503 }
504 
505 void MCStreamer::EmitSyntaxDirective() {}
506 
507 void MCStreamer::EmitWinCFIPushReg(unsigned Register) {
508   EnsureValidWinFrameInfo();
509 
510   MCSymbol *Label = getContext().createTempSymbol();
511   EmitLabel(Label);
512 
513   WinEH::Instruction Inst = Win64EH::Instruction::PushNonVol(Label, Register);
514   CurrentWinFrameInfo->Instructions.push_back(Inst);
515 }
516 
517 void MCStreamer::EmitWinCFISetFrame(unsigned Register, unsigned Offset) {
518   EnsureValidWinFrameInfo();
519   if (CurrentWinFrameInfo->LastFrameInst >= 0)
520     report_fatal_error("Frame register and offset already specified!");
521   if (Offset & 0x0F)
522     report_fatal_error("Misaligned frame pointer offset!");
523   if (Offset > 240)
524     report_fatal_error("Frame offset must be less than or equal to 240!");
525 
526   MCSymbol *Label = getContext().createTempSymbol();
527   EmitLabel(Label);
528 
529   WinEH::Instruction Inst =
530       Win64EH::Instruction::SetFPReg(Label, Register, Offset);
531   CurrentWinFrameInfo->LastFrameInst = CurrentWinFrameInfo->Instructions.size();
532   CurrentWinFrameInfo->Instructions.push_back(Inst);
533 }
534 
535 void MCStreamer::EmitWinCFIAllocStack(unsigned Size) {
536   EnsureValidWinFrameInfo();
537   if (Size == 0)
538     report_fatal_error("Allocation size must be non-zero!");
539   if (Size & 7)
540     report_fatal_error("Misaligned stack allocation!");
541 
542   MCSymbol *Label = getContext().createTempSymbol();
543   EmitLabel(Label);
544 
545   WinEH::Instruction Inst = Win64EH::Instruction::Alloc(Label, Size);
546   CurrentWinFrameInfo->Instructions.push_back(Inst);
547 }
548 
549 void MCStreamer::EmitWinCFISaveReg(unsigned Register, unsigned Offset) {
550   EnsureValidWinFrameInfo();
551   if (Offset & 7)
552     report_fatal_error("Misaligned saved register offset!");
553 
554   MCSymbol *Label = getContext().createTempSymbol();
555   EmitLabel(Label);
556 
557   WinEH::Instruction Inst =
558       Win64EH::Instruction::SaveNonVol(Label, Register, Offset);
559   CurrentWinFrameInfo->Instructions.push_back(Inst);
560 }
561 
562 void MCStreamer::EmitWinCFISaveXMM(unsigned Register, unsigned Offset) {
563   EnsureValidWinFrameInfo();
564   if (Offset & 0x0F)
565     report_fatal_error("Misaligned saved vector register offset!");
566 
567   MCSymbol *Label = getContext().createTempSymbol();
568   EmitLabel(Label);
569 
570   WinEH::Instruction Inst =
571       Win64EH::Instruction::SaveXMM(Label, Register, Offset);
572   CurrentWinFrameInfo->Instructions.push_back(Inst);
573 }
574 
575 void MCStreamer::EmitWinCFIPushFrame(bool Code) {
576   EnsureValidWinFrameInfo();
577   if (CurrentWinFrameInfo->Instructions.size() > 0)
578     report_fatal_error("If present, PushMachFrame must be the first UOP");
579 
580   MCSymbol *Label = getContext().createTempSymbol();
581   EmitLabel(Label);
582 
583   WinEH::Instruction Inst = Win64EH::Instruction::PushMachFrame(Label, Code);
584   CurrentWinFrameInfo->Instructions.push_back(Inst);
585 }
586 
587 void MCStreamer::EmitWinCFIEndProlog() {
588   EnsureValidWinFrameInfo();
589 
590   MCSymbol *Label = getContext().createTempSymbol();
591   EmitLabel(Label);
592 
593   CurrentWinFrameInfo->PrologEnd = Label;
594 }
595 
596 void MCStreamer::EmitCOFFSafeSEH(MCSymbol const *Symbol) {
597 }
598 
599 void MCStreamer::EmitCOFFSectionIndex(MCSymbol const *Symbol) {
600 }
601 
602 void MCStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol) {
603 }
604 
605 /// EmitRawText - If this file is backed by an assembly streamer, this dumps
606 /// the specified string in the output .s file.  This capability is
607 /// indicated by the hasRawTextSupport() predicate.
608 void MCStreamer::EmitRawTextImpl(StringRef String) {
609   errs() << "EmitRawText called on an MCStreamer that doesn't support it, "
610   " something must not be fully mc'ized\n";
611   abort();
612 }
613 
614 void MCStreamer::EmitRawText(const Twine &T) {
615   SmallString<128> Str;
616   EmitRawTextImpl(T.toStringRef(Str));
617 }
618 
619 void MCStreamer::EmitWindowsUnwindTables() {
620 }
621 
622 void MCStreamer::Finish() {
623   if (!DwarfFrameInfos.empty() && !DwarfFrameInfos.back().End)
624     report_fatal_error("Unfinished frame!");
625 
626   MCTargetStreamer *TS = getTargetStreamer();
627   if (TS)
628     TS->finish();
629 
630   FinishImpl();
631 }
632 
633 void MCStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
634   visitUsedExpr(*Value);
635   Symbol->setVariableValue(Value);
636 
637   MCTargetStreamer *TS = getTargetStreamer();
638   if (TS)
639     TS->emitAssignment(Symbol, Value);
640 }
641 
642 void MCTargetStreamer::prettyPrintAsm(MCInstPrinter &InstPrinter, raw_ostream &OS,
643                               const MCInst &Inst, const MCSubtargetInfo &STI) {
644   InstPrinter.printInst(&Inst, OS, "", STI);
645 }
646 
647 void MCStreamer::visitUsedSymbol(const MCSymbol &Sym) {
648 }
649 
650 void MCStreamer::visitUsedExpr(const MCExpr &Expr) {
651   switch (Expr.getKind()) {
652   case MCExpr::Target:
653     cast<MCTargetExpr>(Expr).visitUsedExpr(*this);
654     break;
655 
656   case MCExpr::Constant:
657     break;
658 
659   case MCExpr::Binary: {
660     const MCBinaryExpr &BE = cast<MCBinaryExpr>(Expr);
661     visitUsedExpr(*BE.getLHS());
662     visitUsedExpr(*BE.getRHS());
663     break;
664   }
665 
666   case MCExpr::SymbolRef:
667     visitUsedSymbol(cast<MCSymbolRefExpr>(Expr).getSymbol());
668     break;
669 
670   case MCExpr::Unary:
671     visitUsedExpr(*cast<MCUnaryExpr>(Expr).getSubExpr());
672     break;
673   }
674 }
675 
676 void MCStreamer::EmitInstruction(const MCInst &Inst,
677                                  const MCSubtargetInfo &STI) {
678   // Scan for values.
679   for (unsigned i = Inst.getNumOperands(); i--;)
680     if (Inst.getOperand(i).isExpr())
681       visitUsedExpr(*Inst.getOperand(i).getExpr());
682 }
683 
684 void MCStreamer::emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo,
685                                         unsigned Size) {
686   // Get the Hi-Lo expression.
687   const MCExpr *Diff =
688       MCBinaryExpr::createSub(MCSymbolRefExpr::create(Hi, Context),
689                               MCSymbolRefExpr::create(Lo, Context), Context);
690 
691   const MCAsmInfo *MAI = Context.getAsmInfo();
692   if (!MAI->doesSetDirectiveSuppressesReloc()) {
693     EmitValue(Diff, Size);
694     return;
695   }
696 
697   // Otherwise, emit with .set (aka assignment).
698   MCSymbol *SetLabel = Context.createTempSymbol("set", true);
699   EmitAssignment(SetLabel, Diff);
700   EmitSymbolValue(SetLabel, Size);
701 }
702 
703 void MCStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) {}
704 void MCStreamer::EmitThumbFunc(MCSymbol *Func) {}
705 void MCStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {}
706 void MCStreamer::BeginCOFFSymbolDef(const MCSymbol *Symbol) {}
707 void MCStreamer::EndCOFFSymbolDef() {}
708 void MCStreamer::EmitFileDirective(StringRef Filename) {}
709 void MCStreamer::EmitCOFFSymbolStorageClass(int StorageClass) {}
710 void MCStreamer::EmitCOFFSymbolType(int Type) {}
711 void MCStreamer::emitELFSize(MCSymbolELF *Symbol, const MCExpr *Value) {}
712 void MCStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
713                                        unsigned ByteAlignment) {}
714 void MCStreamer::EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
715                                 uint64_t Size, unsigned ByteAlignment) {}
716 void MCStreamer::ChangeSection(MCSection *, const MCExpr *) {}
717 void MCStreamer::EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {}
718 void MCStreamer::EmitBytes(StringRef Data) {}
719 void MCStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) {
720   visitUsedExpr(*Value);
721 }
722 void MCStreamer::EmitULEB128Value(const MCExpr *Value) {}
723 void MCStreamer::EmitSLEB128Value(const MCExpr *Value) {}
724 void MCStreamer::EmitValueToAlignment(unsigned ByteAlignment, int64_t Value,
725                                       unsigned ValueSize,
726                                       unsigned MaxBytesToEmit) {}
727 void MCStreamer::EmitCodeAlignment(unsigned ByteAlignment,
728                                    unsigned MaxBytesToEmit) {}
729 void MCStreamer::emitValueToOffset(const MCExpr *Offset, unsigned char Value) {}
730 void MCStreamer::EmitBundleAlignMode(unsigned AlignPow2) {}
731 void MCStreamer::EmitBundleLock(bool AlignToEnd) {}
732 void MCStreamer::FinishImpl() {}
733 void MCStreamer::EmitBundleUnlock() {}
734 
735 void MCStreamer::SwitchSection(MCSection *Section, const MCExpr *Subsection) {
736   assert(Section && "Cannot switch to a null section!");
737   MCSectionSubPair curSection = SectionStack.back().first;
738   SectionStack.back().second = curSection;
739   if (MCSectionSubPair(Section, Subsection) != curSection) {
740     ChangeSection(Section, Subsection);
741     SectionStack.back().first = MCSectionSubPair(Section, Subsection);
742     assert(!Section->hasEnded() && "Section already ended");
743     MCSymbol *Sym = Section->getBeginSymbol();
744     if (Sym && !Sym->isInSection())
745       EmitLabel(Sym);
746   }
747 }
748 
749 MCSymbol *MCStreamer::endSection(MCSection *Section) {
750   // TODO: keep track of the last subsection so that this symbol appears in the
751   // correct place.
752   MCSymbol *Sym = Section->getEndSymbol(Context);
753   if (Sym->isInSection())
754     return Sym;
755 
756   SwitchSection(Section);
757   EmitLabel(Sym);
758   return Sym;
759 }
760