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/Optional.h"
12 #include "llvm/ADT/SmallString.h"
13 #include "llvm/ADT/StringRef.h"
14 #include "llvm/ADT/Twine.h"
15 #include "llvm/BinaryFormat/COFF.h"
16 #include "llvm/MC/MCAsmBackend.h"
17 #include "llvm/MC/MCAsmInfo.h"
18 #include "llvm/MC/MCCodeView.h"
19 #include "llvm/MC/MCContext.h"
20 #include "llvm/MC/MCDwarf.h"
21 #include "llvm/MC/MCExpr.h"
22 #include "llvm/MC/MCInst.h"
23 #include "llvm/MC/MCInstPrinter.h"
24 #include "llvm/MC/MCObjectFileInfo.h"
25 #include "llvm/MC/MCSection.h"
26 #include "llvm/MC/MCSectionCOFF.h"
27 #include "llvm/MC/MCSymbol.h"
28 #include "llvm/MC/MCWin64EH.h"
29 #include "llvm/MC/MCWinEH.h"
30 #include "llvm/Support/Casting.h"
31 #include "llvm/Support/ErrorHandling.h"
32 #include "llvm/Support/LEB128.h"
33 #include "llvm/Support/MathExtras.h"
34 #include "llvm/Support/raw_ostream.h"
35 #include <cassert>
36 #include <cstdint>
37 #include <cstdlib>
38 #include <utility>
39 
40 using namespace llvm;
41 
42 MCTargetStreamer::MCTargetStreamer(MCStreamer &S) : Streamer(S) {
43   S.setTargetStreamer(this);
44 }
45 
46 // Pin the vtables to this file.
47 MCTargetStreamer::~MCTargetStreamer() = default;
48 
49 void MCTargetStreamer::emitLabel(MCSymbol *Symbol) {}
50 
51 void MCTargetStreamer::finish() {}
52 
53 void MCTargetStreamer::changeSection(const MCSection *CurSection,
54                                      MCSection *Section,
55                                      const MCExpr *Subsection,
56                                      raw_ostream &OS) {
57   Section->PrintSwitchToSection(
58       *Streamer.getContext().getAsmInfo(),
59       Streamer.getContext().getObjectFileInfo()->getTargetTriple(), OS,
60       Subsection);
61 }
62 
63 void MCTargetStreamer::emitDwarfFileDirective(StringRef Directive) {
64   Streamer.EmitRawText(Directive);
65 }
66 
67 void MCTargetStreamer::emitValue(const MCExpr *Value) {
68   SmallString<128> Str;
69   raw_svector_ostream OS(Str);
70 
71   Value->print(OS, Streamer.getContext().getAsmInfo());
72   Streamer.EmitRawText(OS.str());
73 }
74 
75 void MCTargetStreamer::emitRawBytes(StringRef Data) {
76   const MCAsmInfo *MAI = Streamer.getContext().getAsmInfo();
77   const char *Directive = MAI->getData8bitsDirective();
78   for (const unsigned char C : Data.bytes()) {
79     SmallString<128> Str;
80     raw_svector_ostream OS(Str);
81 
82     OS << Directive << (unsigned)C;
83     Streamer.EmitRawText(OS.str());
84   }
85 }
86 
87 void MCTargetStreamer::emitAssignment(MCSymbol *Symbol, const MCExpr *Value) {}
88 
89 MCStreamer::MCStreamer(MCContext &Ctx)
90     : Context(Ctx), CurrentWinFrameInfo(nullptr),
91       UseAssemblerInfoForParsing(false) {
92   SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>());
93 }
94 
95 MCStreamer::~MCStreamer() {}
96 
97 void MCStreamer::reset() {
98   DwarfFrameInfos.clear();
99   CurrentWinFrameInfo = nullptr;
100   WinFrameInfos.clear();
101   SymbolOrdering.clear();
102   SectionStack.clear();
103   SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>());
104 }
105 
106 raw_ostream &MCStreamer::GetCommentOS() {
107   // By default, discard comments.
108   return nulls();
109 }
110 
111 void MCStreamer::emitRawComment(const Twine &T, bool TabPrefix) {}
112 
113 void MCStreamer::addExplicitComment(const Twine &T) {}
114 void MCStreamer::emitExplicitComments() {}
115 
116 void MCStreamer::generateCompactUnwindEncodings(MCAsmBackend *MAB) {
117   for (auto &FI : DwarfFrameInfos)
118     FI.CompactUnwindEncoding =
119         (MAB ? MAB->generateCompactUnwindEncoding(FI.Instructions) : 0);
120 }
121 
122 /// EmitIntValue - Special case of EmitValue that avoids the client having to
123 /// pass in a MCExpr for constant integers.
124 void MCStreamer::EmitIntValue(uint64_t Value, unsigned Size) {
125   assert(1 <= Size && Size <= 8 && "Invalid size");
126   assert((isUIntN(8 * Size, Value) || isIntN(8 * Size, Value)) &&
127          "Invalid size");
128   char buf[8];
129   const bool isLittleEndian = Context.getAsmInfo()->isLittleEndian();
130   for (unsigned i = 0; i != Size; ++i) {
131     unsigned index = isLittleEndian ? i : (Size - i - 1);
132     buf[i] = uint8_t(Value >> (index * 8));
133   }
134   EmitBytes(StringRef(buf, Size));
135 }
136 
137 /// EmitULEB128IntValue - Special case of EmitULEB128Value that avoids the
138 /// client having to pass in a MCExpr for constant integers.
139 void MCStreamer::EmitULEB128IntValue(uint64_t Value) {
140   SmallString<128> Tmp;
141   raw_svector_ostream OSE(Tmp);
142   encodeULEB128(Value, OSE);
143   EmitBytes(OSE.str());
144 }
145 
146 /// EmitSLEB128IntValue - Special case of EmitSLEB128Value that avoids the
147 /// client having to pass in a MCExpr for constant integers.
148 void MCStreamer::EmitSLEB128IntValue(int64_t Value) {
149   SmallString<128> Tmp;
150   raw_svector_ostream OSE(Tmp);
151   encodeSLEB128(Value, OSE);
152   EmitBytes(OSE.str());
153 }
154 
155 void MCStreamer::EmitValue(const MCExpr *Value, unsigned Size, SMLoc Loc) {
156   EmitValueImpl(Value, Size, Loc);
157 }
158 
159 void MCStreamer::EmitSymbolValue(const MCSymbol *Sym, unsigned Size,
160                                  bool IsSectionRelative) {
161   assert((!IsSectionRelative || Size == 4) &&
162          "SectionRelative value requires 4-bytes");
163 
164   if (!IsSectionRelative)
165     EmitValueImpl(MCSymbolRefExpr::create(Sym, getContext()), Size);
166   else
167     EmitCOFFSecRel32(Sym, /*Offset=*/0);
168 }
169 
170 void MCStreamer::EmitDTPRel64Value(const MCExpr *Value) {
171   report_fatal_error("unsupported directive in streamer");
172 }
173 
174 void MCStreamer::EmitDTPRel32Value(const MCExpr *Value) {
175   report_fatal_error("unsupported directive in streamer");
176 }
177 
178 void MCStreamer::EmitTPRel64Value(const MCExpr *Value) {
179   report_fatal_error("unsupported directive in streamer");
180 }
181 
182 void MCStreamer::EmitTPRel32Value(const MCExpr *Value) {
183   report_fatal_error("unsupported directive in streamer");
184 }
185 
186 void MCStreamer::EmitGPRel64Value(const MCExpr *Value) {
187   report_fatal_error("unsupported directive in streamer");
188 }
189 
190 void MCStreamer::EmitGPRel32Value(const MCExpr *Value) {
191   report_fatal_error("unsupported directive in streamer");
192 }
193 
194 /// Emit NumBytes bytes worth of the value specified by FillValue.
195 /// This implements directives such as '.space'.
196 void MCStreamer::emitFill(uint64_t NumBytes, uint8_t FillValue) {
197   emitFill(*MCConstantExpr::create(NumBytes, getContext()), FillValue);
198 }
199 
200 /// The implementation in this class just redirects to emitFill.
201 void MCStreamer::EmitZeros(uint64_t NumBytes) {
202   emitFill(NumBytes, 0);
203 }
204 
205 Expected<unsigned>
206 MCStreamer::tryEmitDwarfFileDirective(unsigned FileNo, StringRef Directory,
207                                       StringRef Filename,
208                                       MD5::MD5Result *Checksum,
209                                       Optional<StringRef> Source,
210                                       unsigned CUID) {
211   return getContext().getDwarfFile(Directory, Filename, FileNo, Checksum,
212                                    Source, CUID);
213 }
214 
215 void MCStreamer::emitDwarfFile0Directive(StringRef Directory,
216                                          StringRef Filename,
217                                          MD5::MD5Result *Checksum,
218                                          Optional<StringRef> Source,
219                                          unsigned CUID) {
220   getContext().setMCLineTableRootFile(CUID, Directory, Filename, Checksum,
221                                       Source);
222 }
223 
224 void MCStreamer::EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
225                                        unsigned Column, unsigned Flags,
226                                        unsigned Isa,
227                                        unsigned Discriminator,
228                                        StringRef FileName) {
229   getContext().setCurrentDwarfLoc(FileNo, Line, Column, Flags, Isa,
230                                   Discriminator);
231 }
232 
233 MCSymbol *MCStreamer::getDwarfLineTableSymbol(unsigned CUID) {
234   MCDwarfLineTable &Table = getContext().getMCDwarfLineTable(CUID);
235   if (!Table.getLabel()) {
236     StringRef Prefix = Context.getAsmInfo()->getPrivateGlobalPrefix();
237     Table.setLabel(
238         Context.getOrCreateSymbol(Prefix + "line_table_start" + Twine(CUID)));
239   }
240   return Table.getLabel();
241 }
242 
243 bool MCStreamer::hasUnfinishedDwarfFrameInfo() {
244   return !DwarfFrameInfos.empty() && !DwarfFrameInfos.back().End;
245 }
246 
247 MCDwarfFrameInfo *MCStreamer::getCurrentDwarfFrameInfo() {
248   if (!hasUnfinishedDwarfFrameInfo()) {
249     getContext().reportError(SMLoc(), "this directive must appear between "
250                                       ".cfi_startproc and .cfi_endproc "
251                                       "directives");
252     return nullptr;
253   }
254   return &DwarfFrameInfos.back();
255 }
256 
257 bool MCStreamer::EmitCVFileDirective(unsigned FileNo, StringRef Filename,
258                                      ArrayRef<uint8_t> Checksum,
259                                      unsigned ChecksumKind) {
260   return getContext().getCVContext().addFile(*this, FileNo, Filename, Checksum,
261                                              ChecksumKind);
262 }
263 
264 bool MCStreamer::EmitCVFuncIdDirective(unsigned FunctionId) {
265   return getContext().getCVContext().recordFunctionId(FunctionId);
266 }
267 
268 bool MCStreamer::EmitCVInlineSiteIdDirective(unsigned FunctionId,
269                                              unsigned IAFunc, unsigned IAFile,
270                                              unsigned IALine, unsigned IACol,
271                                              SMLoc Loc) {
272   if (getContext().getCVContext().getCVFunctionInfo(IAFunc) == nullptr) {
273     getContext().reportError(Loc, "parent function id not introduced by "
274                                   ".cv_func_id or .cv_inline_site_id");
275     return true;
276   }
277 
278   return getContext().getCVContext().recordInlinedCallSiteId(
279       FunctionId, IAFunc, IAFile, IALine, IACol);
280 }
281 
282 void MCStreamer::EmitCVLocDirective(unsigned FunctionId, unsigned FileNo,
283                                     unsigned Line, unsigned Column,
284                                     bool PrologueEnd, bool IsStmt,
285                                     StringRef FileName, SMLoc Loc) {}
286 
287 bool MCStreamer::checkCVLocSection(unsigned FuncId, unsigned FileNo,
288                                    SMLoc Loc) {
289   CodeViewContext &CVC = getContext().getCVContext();
290   MCCVFunctionInfo *FI = CVC.getCVFunctionInfo(FuncId);
291   if (!FI) {
292     getContext().reportError(
293         Loc, "function id not introduced by .cv_func_id or .cv_inline_site_id");
294     return false;
295   }
296 
297   // Track the section
298   if (FI->Section == nullptr)
299     FI->Section = getCurrentSectionOnly();
300   else if (FI->Section != getCurrentSectionOnly()) {
301     getContext().reportError(
302         Loc,
303         "all .cv_loc directives for a function must be in the same section");
304     return false;
305   }
306   return true;
307 }
308 
309 void MCStreamer::EmitCVLinetableDirective(unsigned FunctionId,
310                                           const MCSymbol *Begin,
311                                           const MCSymbol *End) {}
312 
313 void MCStreamer::EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
314                                                 unsigned SourceFileId,
315                                                 unsigned SourceLineNum,
316                                                 const MCSymbol *FnStartSym,
317                                                 const MCSymbol *FnEndSym) {}
318 
319 void MCStreamer::EmitCVDefRangeDirective(
320     ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
321     StringRef FixedSizePortion) {}
322 
323 void MCStreamer::EmitEHSymAttributes(const MCSymbol *Symbol,
324                                      MCSymbol *EHSymbol) {
325 }
326 
327 void MCStreamer::InitSections(bool NoExecStack) {
328   SwitchSection(getContext().getObjectFileInfo()->getTextSection());
329 }
330 
331 void MCStreamer::AssignFragment(MCSymbol *Symbol, MCFragment *Fragment) {
332   assert(Fragment);
333   Symbol->setFragment(Fragment);
334 
335   // As we emit symbols into a section, track the order so that they can
336   // be sorted upon later. Zero is reserved to mean 'unemitted'.
337   SymbolOrdering[Symbol] = 1 + SymbolOrdering.size();
338 }
339 
340 void MCStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) {
341   Symbol->redefineIfPossible();
342 
343   if (!Symbol->isUndefined() || Symbol->isVariable())
344     return getContext().reportError(Loc, "invalid symbol redefinition");
345 
346   assert(!Symbol->isVariable() && "Cannot emit a variable symbol!");
347   assert(getCurrentSectionOnly() && "Cannot emit before setting section!");
348   assert(!Symbol->getFragment() && "Unexpected fragment on symbol data!");
349   assert(Symbol->isUndefined() && "Cannot define a symbol twice!");
350 
351   Symbol->setFragment(&getCurrentSectionOnly()->getDummyFragment());
352 
353   MCTargetStreamer *TS = getTargetStreamer();
354   if (TS)
355     TS->emitLabel(Symbol);
356 }
357 
358 void MCStreamer::EmitCFISections(bool EH, bool Debug) {
359   assert(EH || Debug);
360 }
361 
362 void MCStreamer::EmitCFIStartProc(bool IsSimple, SMLoc Loc) {
363   if (hasUnfinishedDwarfFrameInfo())
364     return getContext().reportError(
365         Loc, "starting new .cfi frame before finishing the previous one");
366 
367   MCDwarfFrameInfo Frame;
368   Frame.IsSimple = IsSimple;
369   EmitCFIStartProcImpl(Frame);
370 
371   const MCAsmInfo* MAI = Context.getAsmInfo();
372   if (MAI) {
373     for (const MCCFIInstruction& Inst : MAI->getInitialFrameState()) {
374       if (Inst.getOperation() == MCCFIInstruction::OpDefCfa ||
375           Inst.getOperation() == MCCFIInstruction::OpDefCfaRegister) {
376         Frame.CurrentCfaRegister = Inst.getRegister();
377       }
378     }
379   }
380 
381   DwarfFrameInfos.push_back(Frame);
382 }
383 
384 void MCStreamer::EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) {
385 }
386 
387 void MCStreamer::EmitCFIEndProc() {
388   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
389   if (!CurFrame)
390     return;
391   EmitCFIEndProcImpl(*CurFrame);
392 }
393 
394 void MCStreamer::EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) {
395   // Put a dummy non-null value in Frame.End to mark that this frame has been
396   // closed.
397   Frame.End = (MCSymbol *)1;
398 }
399 
400 MCSymbol *MCStreamer::EmitCFILabel() {
401   // Return a dummy non-null value so that label fields appear filled in when
402   // generating textual assembly.
403   return (MCSymbol *)1;
404 }
405 
406 void MCStreamer::EmitCFIDefCfa(int64_t Register, int64_t Offset) {
407   MCSymbol *Label = EmitCFILabel();
408   MCCFIInstruction Instruction =
409     MCCFIInstruction::createDefCfa(Label, Register, Offset);
410   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
411   if (!CurFrame)
412     return;
413   CurFrame->Instructions.push_back(Instruction);
414   CurFrame->CurrentCfaRegister = static_cast<unsigned>(Register);
415 }
416 
417 void MCStreamer::EmitCFIDefCfaOffset(int64_t Offset) {
418   MCSymbol *Label = EmitCFILabel();
419   MCCFIInstruction Instruction =
420     MCCFIInstruction::createDefCfaOffset(Label, Offset);
421   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
422   if (!CurFrame)
423     return;
424   CurFrame->Instructions.push_back(Instruction);
425 }
426 
427 void MCStreamer::EmitCFIAdjustCfaOffset(int64_t Adjustment) {
428   MCSymbol *Label = EmitCFILabel();
429   MCCFIInstruction Instruction =
430     MCCFIInstruction::createAdjustCfaOffset(Label, Adjustment);
431   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
432   if (!CurFrame)
433     return;
434   CurFrame->Instructions.push_back(Instruction);
435 }
436 
437 void MCStreamer::EmitCFIDefCfaRegister(int64_t Register) {
438   MCSymbol *Label = EmitCFILabel();
439   MCCFIInstruction Instruction =
440     MCCFIInstruction::createDefCfaRegister(Label, Register);
441   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
442   if (!CurFrame)
443     return;
444   CurFrame->Instructions.push_back(Instruction);
445   CurFrame->CurrentCfaRegister = static_cast<unsigned>(Register);
446 }
447 
448 void MCStreamer::EmitCFIOffset(int64_t Register, int64_t Offset) {
449   MCSymbol *Label = EmitCFILabel();
450   MCCFIInstruction Instruction =
451     MCCFIInstruction::createOffset(Label, Register, Offset);
452   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
453   if (!CurFrame)
454     return;
455   CurFrame->Instructions.push_back(Instruction);
456 }
457 
458 void MCStreamer::EmitCFIRelOffset(int64_t Register, int64_t Offset) {
459   MCSymbol *Label = EmitCFILabel();
460   MCCFIInstruction Instruction =
461     MCCFIInstruction::createRelOffset(Label, Register, Offset);
462   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
463   if (!CurFrame)
464     return;
465   CurFrame->Instructions.push_back(Instruction);
466 }
467 
468 void MCStreamer::EmitCFIPersonality(const MCSymbol *Sym,
469                                     unsigned Encoding) {
470   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
471   if (!CurFrame)
472     return;
473   CurFrame->Personality = Sym;
474   CurFrame->PersonalityEncoding = Encoding;
475 }
476 
477 void MCStreamer::EmitCFILsda(const MCSymbol *Sym, unsigned Encoding) {
478   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
479   if (!CurFrame)
480     return;
481   CurFrame->Lsda = Sym;
482   CurFrame->LsdaEncoding = Encoding;
483 }
484 
485 void MCStreamer::EmitCFIRememberState() {
486   MCSymbol *Label = EmitCFILabel();
487   MCCFIInstruction Instruction = MCCFIInstruction::createRememberState(Label);
488   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
489   if (!CurFrame)
490     return;
491   CurFrame->Instructions.push_back(Instruction);
492 }
493 
494 void MCStreamer::EmitCFIRestoreState() {
495   // FIXME: Error if there is no matching cfi_remember_state.
496   MCSymbol *Label = EmitCFILabel();
497   MCCFIInstruction Instruction = MCCFIInstruction::createRestoreState(Label);
498   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
499   if (!CurFrame)
500     return;
501   CurFrame->Instructions.push_back(Instruction);
502 }
503 
504 void MCStreamer::EmitCFISameValue(int64_t Register) {
505   MCSymbol *Label = EmitCFILabel();
506   MCCFIInstruction Instruction =
507     MCCFIInstruction::createSameValue(Label, Register);
508   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
509   if (!CurFrame)
510     return;
511   CurFrame->Instructions.push_back(Instruction);
512 }
513 
514 void MCStreamer::EmitCFIRestore(int64_t Register) {
515   MCSymbol *Label = EmitCFILabel();
516   MCCFIInstruction Instruction =
517     MCCFIInstruction::createRestore(Label, Register);
518   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
519   if (!CurFrame)
520     return;
521   CurFrame->Instructions.push_back(Instruction);
522 }
523 
524 void MCStreamer::EmitCFIEscape(StringRef Values) {
525   MCSymbol *Label = EmitCFILabel();
526   MCCFIInstruction Instruction = MCCFIInstruction::createEscape(Label, Values);
527   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
528   if (!CurFrame)
529     return;
530   CurFrame->Instructions.push_back(Instruction);
531 }
532 
533 void MCStreamer::EmitCFIGnuArgsSize(int64_t Size) {
534   MCSymbol *Label = EmitCFILabel();
535   MCCFIInstruction Instruction =
536     MCCFIInstruction::createGnuArgsSize(Label, Size);
537   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
538   if (!CurFrame)
539     return;
540   CurFrame->Instructions.push_back(Instruction);
541 }
542 
543 void MCStreamer::EmitCFISignalFrame() {
544   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
545   if (!CurFrame)
546     return;
547   CurFrame->IsSignalFrame = true;
548 }
549 
550 void MCStreamer::EmitCFIUndefined(int64_t Register) {
551   MCSymbol *Label = EmitCFILabel();
552   MCCFIInstruction Instruction =
553     MCCFIInstruction::createUndefined(Label, Register);
554   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
555   if (!CurFrame)
556     return;
557   CurFrame->Instructions.push_back(Instruction);
558 }
559 
560 void MCStreamer::EmitCFIRegister(int64_t Register1, int64_t Register2) {
561   MCSymbol *Label = EmitCFILabel();
562   MCCFIInstruction Instruction =
563     MCCFIInstruction::createRegister(Label, Register1, Register2);
564   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
565   if (!CurFrame)
566     return;
567   CurFrame->Instructions.push_back(Instruction);
568 }
569 
570 void MCStreamer::EmitCFIWindowSave() {
571   MCSymbol *Label = EmitCFILabel();
572   MCCFIInstruction Instruction =
573     MCCFIInstruction::createWindowSave(Label);
574   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
575   if (!CurFrame)
576     return;
577   CurFrame->Instructions.push_back(Instruction);
578 }
579 
580 void MCStreamer::EmitCFIReturnColumn(int64_t Register) {
581   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
582   if (!CurFrame)
583     return;
584   CurFrame->RAReg = Register;
585 }
586 
587 WinEH::FrameInfo *MCStreamer::EnsureValidWinFrameInfo(SMLoc Loc) {
588   const MCAsmInfo *MAI = Context.getAsmInfo();
589   if (!MAI->usesWindowsCFI()) {
590     getContext().reportError(
591         Loc, ".seh_* directives are not supported on this target");
592     return nullptr;
593   }
594   if (!CurrentWinFrameInfo || CurrentWinFrameInfo->End) {
595     getContext().reportError(
596         Loc, ".seh_ directive must appear within an active frame");
597     return nullptr;
598   }
599   return CurrentWinFrameInfo;
600 }
601 
602 void MCStreamer::EmitWinCFIStartProc(const MCSymbol *Symbol, SMLoc Loc) {
603   const MCAsmInfo *MAI = Context.getAsmInfo();
604   if (!MAI->usesWindowsCFI())
605     return getContext().reportError(
606         Loc, ".seh_* directives are not supported on this target");
607   if (CurrentWinFrameInfo && !CurrentWinFrameInfo->End)
608     getContext().reportError(
609         Loc, "Starting a function before ending the previous one!");
610 
611   MCSymbol *StartProc = EmitCFILabel();
612 
613   WinFrameInfos.emplace_back(
614       llvm::make_unique<WinEH::FrameInfo>(Symbol, StartProc));
615   CurrentWinFrameInfo = WinFrameInfos.back().get();
616   CurrentWinFrameInfo->TextSection = getCurrentSectionOnly();
617 }
618 
619 void MCStreamer::EmitWinCFIEndProc(SMLoc Loc) {
620   WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
621   if (!CurFrame)
622     return;
623   if (CurFrame->ChainedParent)
624     getContext().reportError(Loc, "Not all chained regions terminated!");
625 
626   MCSymbol *Label = EmitCFILabel();
627   CurFrame->End = Label;
628 }
629 
630 void MCStreamer::EmitWinCFIFuncletOrFuncEnd(SMLoc Loc) {
631   WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
632   if (!CurFrame)
633     return;
634   if (CurFrame->ChainedParent)
635     getContext().reportError(Loc, "Not all chained regions terminated!");
636 
637   MCSymbol *Label = EmitCFILabel();
638   CurFrame->FuncletOrFuncEnd = Label;
639 }
640 
641 void MCStreamer::EmitWinCFIStartChained(SMLoc Loc) {
642   WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
643   if (!CurFrame)
644     return;
645 
646   MCSymbol *StartProc = EmitCFILabel();
647 
648   WinFrameInfos.emplace_back(llvm::make_unique<WinEH::FrameInfo>(
649       CurFrame->Function, StartProc, CurFrame));
650   CurrentWinFrameInfo = WinFrameInfos.back().get();
651   CurrentWinFrameInfo->TextSection = getCurrentSectionOnly();
652 }
653 
654 void MCStreamer::EmitWinCFIEndChained(SMLoc Loc) {
655   WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
656   if (!CurFrame)
657     return;
658   if (!CurFrame->ChainedParent)
659     return getContext().reportError(
660         Loc, "End of a chained region outside a chained region!");
661 
662   MCSymbol *Label = EmitCFILabel();
663 
664   CurFrame->End = Label;
665   CurrentWinFrameInfo = const_cast<WinEH::FrameInfo *>(CurFrame->ChainedParent);
666 }
667 
668 void MCStreamer::EmitWinEHHandler(const MCSymbol *Sym, bool Unwind, bool Except,
669                                   SMLoc Loc) {
670   WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
671   if (!CurFrame)
672     return;
673   if (CurFrame->ChainedParent)
674     return getContext().reportError(
675         Loc, "Chained unwind areas can't have handlers!");
676   CurFrame->ExceptionHandler = Sym;
677   if (!Except && !Unwind)
678     getContext().reportError(Loc, "Don't know what kind of handler this is!");
679   if (Unwind)
680     CurFrame->HandlesUnwind = true;
681   if (Except)
682     CurFrame->HandlesExceptions = true;
683 }
684 
685 void MCStreamer::EmitWinEHHandlerData(SMLoc Loc) {
686   WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
687   if (!CurFrame)
688     return;
689   if (CurFrame->ChainedParent)
690     getContext().reportError(Loc, "Chained unwind areas can't have handlers!");
691 }
692 
693 void MCStreamer::emitCGProfileEntry(const MCSymbolRefExpr *From,
694                                     const MCSymbolRefExpr *To, uint64_t Count) {
695 }
696 
697 static MCSection *getWinCFISection(MCContext &Context, unsigned *NextWinCFIID,
698                                    MCSection *MainCFISec,
699                                    const MCSection *TextSec) {
700   // If this is the main .text section, use the main unwind info section.
701   if (TextSec == Context.getObjectFileInfo()->getTextSection())
702     return MainCFISec;
703 
704   const auto *TextSecCOFF = cast<MCSectionCOFF>(TextSec);
705   auto *MainCFISecCOFF = cast<MCSectionCOFF>(MainCFISec);
706   unsigned UniqueID = TextSecCOFF->getOrAssignWinCFISectionID(NextWinCFIID);
707 
708   // If this section is COMDAT, this unwind section should be COMDAT associative
709   // with its group.
710   const MCSymbol *KeySym = nullptr;
711   if (TextSecCOFF->getCharacteristics() & COFF::IMAGE_SCN_LNK_COMDAT) {
712     KeySym = TextSecCOFF->getCOMDATSymbol();
713 
714     // In a GNU environment, we can't use associative comdats. Instead, do what
715     // GCC does, which is to make plain comdat selectany section named like
716     // ".[px]data$_Z3foov".
717     if (!Context.getAsmInfo()->hasCOFFAssociativeComdats()) {
718       std::string SectionName =
719           (MainCFISecCOFF->getSectionName() + "$" +
720            TextSecCOFF->getSectionName().split('$').second)
721               .str();
722       return Context.getCOFFSection(
723           SectionName,
724           MainCFISecCOFF->getCharacteristics() | COFF::IMAGE_SCN_LNK_COMDAT,
725           MainCFISecCOFF->getKind(), "", COFF::IMAGE_COMDAT_SELECT_ANY);
726     }
727   }
728 
729   return Context.getAssociativeCOFFSection(MainCFISecCOFF, KeySym, UniqueID);
730 }
731 
732 MCSection *MCStreamer::getAssociatedPDataSection(const MCSection *TextSec) {
733   return getWinCFISection(getContext(), &NextWinCFIID,
734                           getContext().getObjectFileInfo()->getPDataSection(),
735                           TextSec);
736 }
737 
738 MCSection *MCStreamer::getAssociatedXDataSection(const MCSection *TextSec) {
739   return getWinCFISection(getContext(), &NextWinCFIID,
740                           getContext().getObjectFileInfo()->getXDataSection(),
741                           TextSec);
742 }
743 
744 void MCStreamer::EmitSyntaxDirective() {}
745 
746 void MCStreamer::EmitWinCFIPushReg(unsigned Register, SMLoc Loc) {
747   WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
748   if (!CurFrame)
749     return;
750 
751   MCSymbol *Label = EmitCFILabel();
752 
753   WinEH::Instruction Inst = Win64EH::Instruction::PushNonVol(Label, Register);
754   CurFrame->Instructions.push_back(Inst);
755 }
756 
757 void MCStreamer::EmitWinCFISetFrame(unsigned Register, unsigned Offset,
758                                     SMLoc Loc) {
759   WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
760   if (!CurFrame)
761     return;
762   if (CurFrame->LastFrameInst >= 0)
763     return getContext().reportError(
764         Loc, "frame register and offset can be set at most once");
765   if (Offset & 0x0F)
766     return getContext().reportError(Loc, "offset is not a multiple of 16");
767   if (Offset > 240)
768     return getContext().reportError(
769         Loc, "frame offset must be less than or equal to 240");
770 
771   MCSymbol *Label = EmitCFILabel();
772 
773   WinEH::Instruction Inst =
774       Win64EH::Instruction::SetFPReg(Label, Register, Offset);
775   CurFrame->LastFrameInst = CurFrame->Instructions.size();
776   CurFrame->Instructions.push_back(Inst);
777 }
778 
779 void MCStreamer::EmitWinCFIAllocStack(unsigned Size, SMLoc Loc) {
780   WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
781   if (!CurFrame)
782     return;
783   if (Size == 0)
784     return getContext().reportError(Loc,
785                                     "stack allocation size must be non-zero");
786   if (Size & 7)
787     return getContext().reportError(
788         Loc, "stack allocation size is not a multiple of 8");
789 
790   MCSymbol *Label = EmitCFILabel();
791 
792   WinEH::Instruction Inst = Win64EH::Instruction::Alloc(Label, Size);
793   CurFrame->Instructions.push_back(Inst);
794 }
795 
796 void MCStreamer::EmitWinCFISaveReg(unsigned Register, unsigned Offset,
797                                    SMLoc Loc) {
798   WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
799   if (!CurFrame)
800     return;
801 
802   if (Offset & 7)
803     return getContext().reportError(
804         Loc, "register save offset is not 8 byte aligned");
805 
806   MCSymbol *Label = EmitCFILabel();
807 
808   WinEH::Instruction Inst =
809       Win64EH::Instruction::SaveNonVol(Label, Register, Offset);
810   CurFrame->Instructions.push_back(Inst);
811 }
812 
813 void MCStreamer::EmitWinCFISaveXMM(unsigned Register, unsigned Offset,
814                                    SMLoc Loc) {
815   WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
816   if (!CurFrame)
817     return;
818   if (Offset & 0x0F)
819     return getContext().reportError(Loc, "offset is not a multiple of 16");
820 
821   MCSymbol *Label = EmitCFILabel();
822 
823   WinEH::Instruction Inst =
824       Win64EH::Instruction::SaveXMM(Label, Register, Offset);
825   CurFrame->Instructions.push_back(Inst);
826 }
827 
828 void MCStreamer::EmitWinCFIPushFrame(bool Code, SMLoc Loc) {
829   WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
830   if (!CurFrame)
831     return;
832   if (!CurFrame->Instructions.empty())
833     return getContext().reportError(
834         Loc, "If present, PushMachFrame must be the first UOP");
835 
836   MCSymbol *Label = EmitCFILabel();
837 
838   WinEH::Instruction Inst = Win64EH::Instruction::PushMachFrame(Label, Code);
839   CurFrame->Instructions.push_back(Inst);
840 }
841 
842 void MCStreamer::EmitWinCFIEndProlog(SMLoc Loc) {
843   WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
844   if (!CurFrame)
845     return;
846 
847   MCSymbol *Label = EmitCFILabel();
848 
849   CurFrame->PrologEnd = Label;
850 }
851 
852 void MCStreamer::EmitCOFFSafeSEH(MCSymbol const *Symbol) {
853 }
854 
855 void MCStreamer::EmitCOFFSymbolIndex(MCSymbol const *Symbol) {}
856 
857 void MCStreamer::EmitCOFFSectionIndex(MCSymbol const *Symbol) {
858 }
859 
860 void MCStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol, uint64_t Offset) {}
861 
862 void MCStreamer::EmitCOFFImgRel32(MCSymbol const *Symbol, int64_t Offset) {}
863 
864 /// EmitRawText - If this file is backed by an assembly streamer, this dumps
865 /// the specified string in the output .s file.  This capability is
866 /// indicated by the hasRawTextSupport() predicate.
867 void MCStreamer::EmitRawTextImpl(StringRef String) {
868   errs() << "EmitRawText called on an MCStreamer that doesn't support it, "
869   " something must not be fully mc'ized\n";
870   abort();
871 }
872 
873 void MCStreamer::EmitRawText(const Twine &T) {
874   SmallString<128> Str;
875   EmitRawTextImpl(T.toStringRef(Str));
876 }
877 
878 void MCStreamer::EmitWindowsUnwindTables() {
879 }
880 
881 void MCStreamer::Finish() {
882   if ((!DwarfFrameInfos.empty() && !DwarfFrameInfos.back().End) ||
883       (!WinFrameInfos.empty() && !WinFrameInfos.back()->End)) {
884     getContext().reportError(SMLoc(), "Unfinished frame!");
885     return;
886   }
887 
888   MCTargetStreamer *TS = getTargetStreamer();
889   if (TS)
890     TS->finish();
891 
892   FinishImpl();
893 }
894 
895 void MCStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
896   visitUsedExpr(*Value);
897   Symbol->setVariableValue(Value);
898 
899   MCTargetStreamer *TS = getTargetStreamer();
900   if (TS)
901     TS->emitAssignment(Symbol, Value);
902 }
903 
904 void MCTargetStreamer::prettyPrintAsm(MCInstPrinter &InstPrinter, raw_ostream &OS,
905                               const MCInst &Inst, const MCSubtargetInfo &STI) {
906   InstPrinter.printInst(&Inst, OS, "", STI);
907 }
908 
909 void MCStreamer::visitUsedSymbol(const MCSymbol &Sym) {
910 }
911 
912 void MCStreamer::visitUsedExpr(const MCExpr &Expr) {
913   switch (Expr.getKind()) {
914   case MCExpr::Target:
915     cast<MCTargetExpr>(Expr).visitUsedExpr(*this);
916     break;
917 
918   case MCExpr::Constant:
919     break;
920 
921   case MCExpr::Binary: {
922     const MCBinaryExpr &BE = cast<MCBinaryExpr>(Expr);
923     visitUsedExpr(*BE.getLHS());
924     visitUsedExpr(*BE.getRHS());
925     break;
926   }
927 
928   case MCExpr::SymbolRef:
929     visitUsedSymbol(cast<MCSymbolRefExpr>(Expr).getSymbol());
930     break;
931 
932   case MCExpr::Unary:
933     visitUsedExpr(*cast<MCUnaryExpr>(Expr).getSubExpr());
934     break;
935   }
936 }
937 
938 void MCStreamer::EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
939                                  bool) {
940   // Scan for values.
941   for (unsigned i = Inst.getNumOperands(); i--;)
942     if (Inst.getOperand(i).isExpr())
943       visitUsedExpr(*Inst.getOperand(i).getExpr());
944 }
945 
946 void MCStreamer::emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo,
947                                         unsigned Size) {
948   // Get the Hi-Lo expression.
949   const MCExpr *Diff =
950       MCBinaryExpr::createSub(MCSymbolRefExpr::create(Hi, Context),
951                               MCSymbolRefExpr::create(Lo, Context), Context);
952 
953   const MCAsmInfo *MAI = Context.getAsmInfo();
954   if (!MAI->doesSetDirectiveSuppressReloc()) {
955     EmitValue(Diff, Size);
956     return;
957   }
958 
959   // Otherwise, emit with .set (aka assignment).
960   MCSymbol *SetLabel = Context.createTempSymbol("set", true);
961   EmitAssignment(SetLabel, Diff);
962   EmitSymbolValue(SetLabel, Size);
963 }
964 
965 void MCStreamer::emitAbsoluteSymbolDiffAsULEB128(const MCSymbol *Hi,
966                                                  const MCSymbol *Lo) {
967   // Get the Hi-Lo expression.
968   const MCExpr *Diff =
969       MCBinaryExpr::createSub(MCSymbolRefExpr::create(Hi, Context),
970                               MCSymbolRefExpr::create(Lo, Context), Context);
971 
972   EmitULEB128Value(Diff);
973 }
974 
975 void MCStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) {}
976 void MCStreamer::EmitThumbFunc(MCSymbol *Func) {}
977 void MCStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {}
978 void MCStreamer::BeginCOFFSymbolDef(const MCSymbol *Symbol) {
979   llvm_unreachable("this directive only supported on COFF targets");
980 }
981 void MCStreamer::EndCOFFSymbolDef() {
982   llvm_unreachable("this directive only supported on COFF targets");
983 }
984 void MCStreamer::EmitFileDirective(StringRef Filename) {}
985 void MCStreamer::EmitCOFFSymbolStorageClass(int StorageClass) {
986   llvm_unreachable("this directive only supported on COFF targets");
987 }
988 void MCStreamer::EmitCOFFSymbolType(int Type) {
989   llvm_unreachable("this directive only supported on COFF targets");
990 }
991 void MCStreamer::emitELFSize(MCSymbol *Symbol, const MCExpr *Value) {}
992 void MCStreamer::emitELFSymverDirective(StringRef AliasName,
993                                         const MCSymbol *Aliasee) {}
994 void MCStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
995                                        unsigned ByteAlignment) {}
996 void MCStreamer::EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
997                                 uint64_t Size, unsigned ByteAlignment) {}
998 void MCStreamer::ChangeSection(MCSection *, const MCExpr *) {}
999 void MCStreamer::EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {}
1000 void MCStreamer::EmitBytes(StringRef Data) {}
1001 void MCStreamer::EmitBinaryData(StringRef Data) { EmitBytes(Data); }
1002 void MCStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) {
1003   visitUsedExpr(*Value);
1004 }
1005 void MCStreamer::EmitULEB128Value(const MCExpr *Value) {}
1006 void MCStreamer::EmitSLEB128Value(const MCExpr *Value) {}
1007 void MCStreamer::emitFill(const MCExpr &NumBytes, uint64_t Value, SMLoc Loc) {}
1008 void MCStreamer::emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr,
1009                           SMLoc Loc) {}
1010 void MCStreamer::EmitValueToAlignment(unsigned ByteAlignment, int64_t Value,
1011                                       unsigned ValueSize,
1012                                       unsigned MaxBytesToEmit) {}
1013 void MCStreamer::EmitCodeAlignment(unsigned ByteAlignment,
1014                                    unsigned MaxBytesToEmit) {}
1015 void MCStreamer::emitValueToOffset(const MCExpr *Offset, unsigned char Value,
1016                                    SMLoc Loc) {}
1017 void MCStreamer::EmitBundleAlignMode(unsigned AlignPow2) {}
1018 void MCStreamer::EmitBundleLock(bool AlignToEnd) {}
1019 void MCStreamer::FinishImpl() {}
1020 void MCStreamer::EmitBundleUnlock() {}
1021 
1022 void MCStreamer::SwitchSection(MCSection *Section, const MCExpr *Subsection) {
1023   assert(Section && "Cannot switch to a null section!");
1024   MCSectionSubPair curSection = SectionStack.back().first;
1025   SectionStack.back().second = curSection;
1026   if (MCSectionSubPair(Section, Subsection) != curSection) {
1027     ChangeSection(Section, Subsection);
1028     SectionStack.back().first = MCSectionSubPair(Section, Subsection);
1029     assert(!Section->hasEnded() && "Section already ended");
1030     MCSymbol *Sym = Section->getBeginSymbol();
1031     if (Sym && !Sym->isInSection())
1032       EmitLabel(Sym);
1033   }
1034 }
1035 
1036 MCSymbol *MCStreamer::endSection(MCSection *Section) {
1037   // TODO: keep track of the last subsection so that this symbol appears in the
1038   // correct place.
1039   MCSymbol *Sym = Section->getEndSymbol(Context);
1040   if (Sym->isInSection())
1041     return Sym;
1042 
1043   SwitchSection(Section);
1044   EmitLabel(Sym);
1045   return Sym;
1046 }
1047 
1048 void MCStreamer::EmitVersionForTarget(const Triple &Target) {
1049   if (!Target.isOSBinFormatMachO() || !Target.isOSDarwin())
1050     return;
1051   // Do we even know the version?
1052   if (Target.getOSMajorVersion() == 0)
1053     return;
1054 
1055   unsigned Major;
1056   unsigned Minor;
1057   unsigned Update;
1058   MCVersionMinType VersionType;
1059   if (Target.isWatchOS()) {
1060     VersionType = MCVM_WatchOSVersionMin;
1061     Target.getWatchOSVersion(Major, Minor, Update);
1062   } else if (Target.isTvOS()) {
1063     VersionType = MCVM_TvOSVersionMin;
1064     Target.getiOSVersion(Major, Minor, Update);
1065   } else if (Target.isMacOSX()) {
1066     VersionType = MCVM_OSXVersionMin;
1067     if (!Target.getMacOSXVersion(Major, Minor, Update))
1068       Major = 0;
1069   } else {
1070     VersionType = MCVM_IOSVersionMin;
1071     Target.getiOSVersion(Major, Minor, Update);
1072   }
1073   if (Major != 0)
1074     EmitVersionMin(VersionType, Major, Minor, Update);
1075 }
1076