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