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