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