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 MCDwarfFrameInfo *MCStreamer::getCurrentDwarfFrameInfo() {
210   if (DwarfFrameInfos.empty())
211     return nullptr;
212   return &DwarfFrameInfos.back();
213 }
214 
215 bool MCStreamer::hasUnfinishedDwarfFrameInfo() {
216   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
217   return CurFrame && !CurFrame->End;
218 }
219 
220 void MCStreamer::EnsureValidDwarfFrame() {
221   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
222   if (!CurFrame || CurFrame->End)
223     report_fatal_error("No open frame");
224 }
225 
226 bool MCStreamer::EmitCVFileDirective(unsigned FileNo, StringRef Filename,
227                                      ArrayRef<uint8_t> Checksum,
228                                      unsigned ChecksumKind) {
229   return getContext().getCVContext().addFile(*this, FileNo, Filename, Checksum,
230                                              ChecksumKind);
231 }
232 
233 bool MCStreamer::EmitCVFuncIdDirective(unsigned FunctionId) {
234   return getContext().getCVContext().recordFunctionId(FunctionId);
235 }
236 
237 bool MCStreamer::EmitCVInlineSiteIdDirective(unsigned FunctionId,
238                                              unsigned IAFunc, unsigned IAFile,
239                                              unsigned IALine, unsigned IACol,
240                                              SMLoc Loc) {
241   if (getContext().getCVContext().getCVFunctionInfo(IAFunc) == nullptr) {
242     getContext().reportError(Loc, "parent function id not introduced by "
243                                   ".cv_func_id or .cv_inline_site_id");
244     return true;
245   }
246 
247   return getContext().getCVContext().recordInlinedCallSiteId(
248       FunctionId, IAFunc, IAFile, IALine, IACol);
249 }
250 
251 void MCStreamer::EmitCVLocDirective(unsigned FunctionId, unsigned FileNo,
252                                     unsigned Line, unsigned Column,
253                                     bool PrologueEnd, bool IsStmt,
254                                     StringRef FileName, SMLoc Loc) {
255   CodeViewContext &CVC = getContext().getCVContext();
256   MCCVFunctionInfo *FI = CVC.getCVFunctionInfo(FunctionId);
257   if (!FI)
258     return getContext().reportError(
259         Loc, "function id not introduced by .cv_func_id or .cv_inline_site_id");
260 
261   // Track the section
262   if (FI->Section == nullptr)
263     FI->Section = getCurrentSectionOnly();
264   else if (FI->Section != getCurrentSectionOnly())
265     return getContext().reportError(
266         Loc,
267         "all .cv_loc directives for a function must be in the same section");
268 
269   CVC.setCurrentCVLoc(FunctionId, FileNo, Line, Column, PrologueEnd, IsStmt);
270 }
271 
272 void MCStreamer::EmitCVLinetableDirective(unsigned FunctionId,
273                                           const MCSymbol *Begin,
274                                           const MCSymbol *End) {}
275 
276 void MCStreamer::EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
277                                                 unsigned SourceFileId,
278                                                 unsigned SourceLineNum,
279                                                 const MCSymbol *FnStartSym,
280                                                 const MCSymbol *FnEndSym) {}
281 
282 void MCStreamer::EmitCVDefRangeDirective(
283     ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
284     StringRef FixedSizePortion) {}
285 
286 void MCStreamer::EmitEHSymAttributes(const MCSymbol *Symbol,
287                                      MCSymbol *EHSymbol) {
288 }
289 
290 void MCStreamer::InitSections(bool NoExecStack) {
291   SwitchSection(getContext().getObjectFileInfo()->getTextSection());
292 }
293 
294 void MCStreamer::AssignFragment(MCSymbol *Symbol, MCFragment *Fragment) {
295   assert(Fragment);
296   Symbol->setFragment(Fragment);
297 
298   // As we emit symbols into a section, track the order so that they can
299   // be sorted upon later. Zero is reserved to mean 'unemitted'.
300   SymbolOrdering[Symbol] = 1 + SymbolOrdering.size();
301 }
302 
303 void MCStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) {
304   Symbol->redefineIfPossible();
305 
306   if (!Symbol->isUndefined() || Symbol->isVariable())
307     return getContext().reportError(Loc, "invalid symbol redefinition");
308 
309   assert(!Symbol->isVariable() && "Cannot emit a variable symbol!");
310   assert(getCurrentSectionOnly() && "Cannot emit before setting section!");
311   assert(!Symbol->getFragment() && "Unexpected fragment on symbol data!");
312   assert(Symbol->isUndefined() && "Cannot define a symbol twice!");
313 
314   Symbol->setFragment(&getCurrentSectionOnly()->getDummyFragment());
315 
316   MCTargetStreamer *TS = getTargetStreamer();
317   if (TS)
318     TS->emitLabel(Symbol);
319 }
320 
321 void MCStreamer::EmitCFISections(bool EH, bool Debug) {
322   assert(EH || Debug);
323 }
324 
325 void MCStreamer::EmitCFIStartProc(bool IsSimple) {
326   if (hasUnfinishedDwarfFrameInfo())
327     report_fatal_error("Starting a frame before finishing the previous one!");
328 
329   MCDwarfFrameInfo Frame;
330   Frame.IsSimple = IsSimple;
331   EmitCFIStartProcImpl(Frame);
332 
333   const MCAsmInfo* MAI = Context.getAsmInfo();
334   if (MAI) {
335     for (const MCCFIInstruction& Inst : MAI->getInitialFrameState()) {
336       if (Inst.getOperation() == MCCFIInstruction::OpDefCfa ||
337           Inst.getOperation() == MCCFIInstruction::OpDefCfaRegister) {
338         Frame.CurrentCfaRegister = Inst.getRegister();
339       }
340     }
341   }
342 
343   DwarfFrameInfos.push_back(Frame);
344 }
345 
346 void MCStreamer::EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) {
347 }
348 
349 void MCStreamer::EmitCFIEndProc() {
350   EnsureValidDwarfFrame();
351   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
352   EmitCFIEndProcImpl(*CurFrame);
353 }
354 
355 void MCStreamer::EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) {
356   // Put a dummy non-null value in Frame.End to mark that this frame has been
357   // closed.
358   Frame.End = (MCSymbol *) 1;
359 }
360 
361 MCSymbol *MCStreamer::EmitCFILabel() {
362   MCSymbol *Label = getContext().createTempSymbol("cfi", true);
363   EmitLabel(Label);
364   return Label;
365 }
366 
367 MCSymbol *MCStreamer::EmitCFICommon() {
368   EnsureValidDwarfFrame();
369   return EmitCFILabel();
370 }
371 
372 void MCStreamer::EmitCFIDefCfa(int64_t Register, int64_t Offset) {
373   MCSymbol *Label = EmitCFICommon();
374   MCCFIInstruction Instruction =
375     MCCFIInstruction::createDefCfa(Label, Register, Offset);
376   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
377   CurFrame->Instructions.push_back(Instruction);
378   CurFrame->CurrentCfaRegister = static_cast<unsigned>(Register);
379 }
380 
381 void MCStreamer::EmitCFIDefCfaOffset(int64_t Offset) {
382   MCSymbol *Label = EmitCFICommon();
383   MCCFIInstruction Instruction =
384     MCCFIInstruction::createDefCfaOffset(Label, Offset);
385   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
386   CurFrame->Instructions.push_back(Instruction);
387 }
388 
389 void MCStreamer::EmitCFIAdjustCfaOffset(int64_t Adjustment) {
390   MCSymbol *Label = EmitCFICommon();
391   MCCFIInstruction Instruction =
392     MCCFIInstruction::createAdjustCfaOffset(Label, Adjustment);
393   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
394   CurFrame->Instructions.push_back(Instruction);
395 }
396 
397 void MCStreamer::EmitCFIDefCfaRegister(int64_t Register) {
398   MCSymbol *Label = EmitCFICommon();
399   MCCFIInstruction Instruction =
400     MCCFIInstruction::createDefCfaRegister(Label, Register);
401   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
402   CurFrame->Instructions.push_back(Instruction);
403   CurFrame->CurrentCfaRegister = static_cast<unsigned>(Register);
404 }
405 
406 void MCStreamer::EmitCFIOffset(int64_t Register, int64_t Offset) {
407   MCSymbol *Label = EmitCFICommon();
408   MCCFIInstruction Instruction =
409     MCCFIInstruction::createOffset(Label, Register, Offset);
410   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
411   CurFrame->Instructions.push_back(Instruction);
412 }
413 
414 void MCStreamer::EmitCFIRelOffset(int64_t Register, int64_t Offset) {
415   MCSymbol *Label = EmitCFICommon();
416   MCCFIInstruction Instruction =
417     MCCFIInstruction::createRelOffset(Label, Register, Offset);
418   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
419   CurFrame->Instructions.push_back(Instruction);
420 }
421 
422 void MCStreamer::EmitCFIPersonality(const MCSymbol *Sym,
423                                     unsigned Encoding) {
424   EnsureValidDwarfFrame();
425   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
426   CurFrame->Personality = Sym;
427   CurFrame->PersonalityEncoding = Encoding;
428 }
429 
430 void MCStreamer::EmitCFILsda(const MCSymbol *Sym, unsigned Encoding) {
431   EnsureValidDwarfFrame();
432   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
433   CurFrame->Lsda = Sym;
434   CurFrame->LsdaEncoding = Encoding;
435 }
436 
437 void MCStreamer::EmitCFIRememberState() {
438   MCSymbol *Label = EmitCFICommon();
439   MCCFIInstruction Instruction = MCCFIInstruction::createRememberState(Label);
440   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
441   CurFrame->Instructions.push_back(Instruction);
442 }
443 
444 void MCStreamer::EmitCFIRestoreState() {
445   // FIXME: Error if there is no matching cfi_remember_state.
446   MCSymbol *Label = EmitCFICommon();
447   MCCFIInstruction Instruction = MCCFIInstruction::createRestoreState(Label);
448   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
449   CurFrame->Instructions.push_back(Instruction);
450 }
451 
452 void MCStreamer::EmitCFISameValue(int64_t Register) {
453   MCSymbol *Label = EmitCFICommon();
454   MCCFIInstruction Instruction =
455     MCCFIInstruction::createSameValue(Label, Register);
456   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
457   CurFrame->Instructions.push_back(Instruction);
458 }
459 
460 void MCStreamer::EmitCFIRestore(int64_t Register) {
461   MCSymbol *Label = EmitCFICommon();
462   MCCFIInstruction Instruction =
463     MCCFIInstruction::createRestore(Label, Register);
464   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
465   CurFrame->Instructions.push_back(Instruction);
466 }
467 
468 void MCStreamer::EmitCFIEscape(StringRef Values) {
469   MCSymbol *Label = EmitCFICommon();
470   MCCFIInstruction Instruction = MCCFIInstruction::createEscape(Label, Values);
471   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
472   CurFrame->Instructions.push_back(Instruction);
473 }
474 
475 void MCStreamer::EmitCFIGnuArgsSize(int64_t Size) {
476   MCSymbol *Label = EmitCFICommon();
477   MCCFIInstruction Instruction =
478     MCCFIInstruction::createGnuArgsSize(Label, Size);
479   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
480   CurFrame->Instructions.push_back(Instruction);
481 }
482 
483 void MCStreamer::EmitCFISignalFrame() {
484   EnsureValidDwarfFrame();
485   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
486   CurFrame->IsSignalFrame = true;
487 }
488 
489 void MCStreamer::EmitCFIUndefined(int64_t Register) {
490   MCSymbol *Label = EmitCFICommon();
491   MCCFIInstruction Instruction =
492     MCCFIInstruction::createUndefined(Label, Register);
493   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
494   CurFrame->Instructions.push_back(Instruction);
495 }
496 
497 void MCStreamer::EmitCFIRegister(int64_t Register1, int64_t Register2) {
498   MCSymbol *Label = EmitCFICommon();
499   MCCFIInstruction Instruction =
500     MCCFIInstruction::createRegister(Label, Register1, Register2);
501   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
502   CurFrame->Instructions.push_back(Instruction);
503 }
504 
505 void MCStreamer::EmitCFIWindowSave() {
506   MCSymbol *Label = EmitCFICommon();
507   MCCFIInstruction Instruction =
508     MCCFIInstruction::createWindowSave(Label);
509   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
510   CurFrame->Instructions.push_back(Instruction);
511 }
512 
513 void MCStreamer::EmitCFIReturnColumn(int64_t Register) {
514   EnsureValidDwarfFrame();
515   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
516   CurFrame->RAReg = Register;
517 }
518 
519 void MCStreamer::EnsureValidWinFrameInfo() {
520   const MCAsmInfo *MAI = Context.getAsmInfo();
521   if (!MAI->usesWindowsCFI())
522     report_fatal_error(".seh_* directives are not supported on this target");
523   if (!CurrentWinFrameInfo || CurrentWinFrameInfo->End)
524     report_fatal_error("No open Win64 EH frame function!");
525 }
526 
527 void MCStreamer::EmitWinCFIStartProc(const MCSymbol *Symbol) {
528   const MCAsmInfo *MAI = Context.getAsmInfo();
529   if (!MAI->usesWindowsCFI())
530     report_fatal_error(".seh_* directives are not supported on this target");
531   if (CurrentWinFrameInfo && !CurrentWinFrameInfo->End)
532     report_fatal_error("Starting a function before ending the previous one!");
533 
534   MCSymbol *StartProc = EmitCFILabel();
535 
536   WinFrameInfos.emplace_back(
537       llvm::make_unique<WinEH::FrameInfo>(Symbol, StartProc));
538   CurrentWinFrameInfo = WinFrameInfos.back().get();
539   CurrentWinFrameInfo->TextSection = getCurrentSectionOnly();
540 }
541 
542 void MCStreamer::EmitWinCFIEndProc() {
543   EnsureValidWinFrameInfo();
544   if (CurrentWinFrameInfo->ChainedParent)
545     report_fatal_error("Not all chained regions terminated!");
546 
547   MCSymbol *Label = EmitCFILabel();
548   CurrentWinFrameInfo->End = Label;
549 }
550 
551 void MCStreamer::EmitWinCFIStartChained() {
552   EnsureValidWinFrameInfo();
553 
554   MCSymbol *StartProc = EmitCFILabel();
555 
556   WinFrameInfos.emplace_back(llvm::make_unique<WinEH::FrameInfo>(
557       CurrentWinFrameInfo->Function, StartProc, CurrentWinFrameInfo));
558   CurrentWinFrameInfo = WinFrameInfos.back().get();
559   CurrentWinFrameInfo->TextSection = getCurrentSectionOnly();
560 }
561 
562 void MCStreamer::EmitWinCFIEndChained() {
563   EnsureValidWinFrameInfo();
564   if (!CurrentWinFrameInfo->ChainedParent)
565     report_fatal_error("End of a chained region outside a chained region!");
566 
567   MCSymbol *Label = EmitCFILabel();
568 
569   CurrentWinFrameInfo->End = Label;
570   CurrentWinFrameInfo =
571       const_cast<WinEH::FrameInfo *>(CurrentWinFrameInfo->ChainedParent);
572 }
573 
574 void MCStreamer::EmitWinEHHandler(const MCSymbol *Sym, bool Unwind,
575                                   bool Except) {
576   EnsureValidWinFrameInfo();
577   if (CurrentWinFrameInfo->ChainedParent)
578     report_fatal_error("Chained unwind areas can't have handlers!");
579   CurrentWinFrameInfo->ExceptionHandler = Sym;
580   if (!Except && !Unwind)
581     report_fatal_error("Don't know what kind of handler this is!");
582   if (Unwind)
583     CurrentWinFrameInfo->HandlesUnwind = true;
584   if (Except)
585     CurrentWinFrameInfo->HandlesExceptions = true;
586 }
587 
588 void MCStreamer::EmitWinEHHandlerData() {
589   EnsureValidWinFrameInfo();
590   if (CurrentWinFrameInfo->ChainedParent)
591     report_fatal_error("Chained unwind areas can't have handlers!");
592 }
593 
594 static MCSection *getWinCFISection(MCContext &Context, unsigned *NextWinCFIID,
595                                    MCSection *MainCFISec,
596                                    const MCSection *TextSec) {
597   // If this is the main .text section, use the main unwind info section.
598   if (TextSec == Context.getObjectFileInfo()->getTextSection())
599     return MainCFISec;
600 
601   const auto *TextSecCOFF = cast<MCSectionCOFF>(TextSec);
602   unsigned UniqueID = TextSecCOFF->getOrAssignWinCFISectionID(NextWinCFIID);
603 
604   // If this section is COMDAT, this unwind section should be COMDAT associative
605   // with its group.
606   const MCSymbol *KeySym = nullptr;
607   if (TextSecCOFF->getCharacteristics() & COFF::IMAGE_SCN_LNK_COMDAT)
608     KeySym = TextSecCOFF->getCOMDATSymbol();
609 
610   return Context.getAssociativeCOFFSection(cast<MCSectionCOFF>(MainCFISec),
611                                            KeySym, UniqueID);
612 }
613 
614 MCSection *MCStreamer::getAssociatedPDataSection(const MCSection *TextSec) {
615   return getWinCFISection(getContext(), &NextWinCFIID,
616                           getContext().getObjectFileInfo()->getPDataSection(),
617                           TextSec);
618 }
619 
620 MCSection *MCStreamer::getAssociatedXDataSection(const MCSection *TextSec) {
621   return getWinCFISection(getContext(), &NextWinCFIID,
622                           getContext().getObjectFileInfo()->getXDataSection(),
623                           TextSec);
624 }
625 
626 void MCStreamer::EmitSyntaxDirective() {}
627 
628 void MCStreamer::EmitWinCFIPushReg(unsigned Register) {
629   EnsureValidWinFrameInfo();
630 
631   MCSymbol *Label = EmitCFILabel();
632 
633   WinEH::Instruction Inst = Win64EH::Instruction::PushNonVol(Label, Register);
634   CurrentWinFrameInfo->Instructions.push_back(Inst);
635 }
636 
637 void MCStreamer::EmitWinCFISetFrame(unsigned Register, unsigned Offset) {
638   EnsureValidWinFrameInfo();
639   if (CurrentWinFrameInfo->LastFrameInst >= 0)
640     report_fatal_error("Frame register and offset already specified!");
641   if (Offset & 0x0F)
642     report_fatal_error("Misaligned frame pointer offset!");
643   if (Offset > 240)
644     report_fatal_error("Frame offset must be less than or equal to 240!");
645 
646   MCSymbol *Label = EmitCFILabel();
647 
648   WinEH::Instruction Inst =
649       Win64EH::Instruction::SetFPReg(Label, Register, Offset);
650   CurrentWinFrameInfo->LastFrameInst = CurrentWinFrameInfo->Instructions.size();
651   CurrentWinFrameInfo->Instructions.push_back(Inst);
652 }
653 
654 void MCStreamer::EmitWinCFIAllocStack(unsigned Size) {
655   EnsureValidWinFrameInfo();
656   if (Size == 0)
657     report_fatal_error("Allocation size must be non-zero!");
658   if (Size & 7)
659     report_fatal_error("Misaligned stack allocation!");
660 
661   MCSymbol *Label = EmitCFILabel();
662 
663   WinEH::Instruction Inst = Win64EH::Instruction::Alloc(Label, Size);
664   CurrentWinFrameInfo->Instructions.push_back(Inst);
665 }
666 
667 void MCStreamer::EmitWinCFISaveReg(unsigned Register, unsigned Offset) {
668   EnsureValidWinFrameInfo();
669   if (Offset & 7)
670     report_fatal_error("Misaligned saved register offset!");
671 
672   MCSymbol *Label = EmitCFILabel();
673 
674   WinEH::Instruction Inst =
675       Win64EH::Instruction::SaveNonVol(Label, Register, Offset);
676   CurrentWinFrameInfo->Instructions.push_back(Inst);
677 }
678 
679 void MCStreamer::EmitWinCFISaveXMM(unsigned Register, unsigned Offset) {
680   EnsureValidWinFrameInfo();
681   if (Offset & 0x0F)
682     report_fatal_error("Misaligned saved vector register offset!");
683 
684   MCSymbol *Label = EmitCFILabel();
685 
686   WinEH::Instruction Inst =
687       Win64EH::Instruction::SaveXMM(Label, Register, Offset);
688   CurrentWinFrameInfo->Instructions.push_back(Inst);
689 }
690 
691 void MCStreamer::EmitWinCFIPushFrame(bool Code) {
692   EnsureValidWinFrameInfo();
693   if (!CurrentWinFrameInfo->Instructions.empty())
694     report_fatal_error("If present, PushMachFrame must be the first UOP");
695 
696   MCSymbol *Label = EmitCFILabel();
697 
698   WinEH::Instruction Inst = Win64EH::Instruction::PushMachFrame(Label, Code);
699   CurrentWinFrameInfo->Instructions.push_back(Inst);
700 }
701 
702 void MCStreamer::EmitWinCFIEndProlog() {
703   EnsureValidWinFrameInfo();
704 
705   MCSymbol *Label = EmitCFILabel();
706 
707   CurrentWinFrameInfo->PrologEnd = Label;
708 }
709 
710 void MCStreamer::EmitCOFFSafeSEH(MCSymbol const *Symbol) {
711 }
712 
713 void MCStreamer::EmitCOFFSectionIndex(MCSymbol const *Symbol) {
714 }
715 
716 void MCStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol, uint64_t Offset) {}
717 
718 /// EmitRawText - If this file is backed by an assembly streamer, this dumps
719 /// the specified string in the output .s file.  This capability is
720 /// indicated by the hasRawTextSupport() predicate.
721 void MCStreamer::EmitRawTextImpl(StringRef String) {
722   errs() << "EmitRawText called on an MCStreamer that doesn't support it, "
723   " something must not be fully mc'ized\n";
724   abort();
725 }
726 
727 void MCStreamer::EmitRawText(const Twine &T) {
728   SmallString<128> Str;
729   EmitRawTextImpl(T.toStringRef(Str));
730 }
731 
732 void MCStreamer::EmitWindowsUnwindTables() {
733 }
734 
735 void MCStreamer::Finish() {
736   if (!DwarfFrameInfos.empty() && !DwarfFrameInfos.back().End)
737     report_fatal_error("Unfinished frame!");
738 
739   MCTargetStreamer *TS = getTargetStreamer();
740   if (TS)
741     TS->finish();
742 
743   FinishImpl();
744 }
745 
746 void MCStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
747   visitUsedExpr(*Value);
748   Symbol->setVariableValue(Value);
749 
750   MCTargetStreamer *TS = getTargetStreamer();
751   if (TS)
752     TS->emitAssignment(Symbol, Value);
753 }
754 
755 void MCTargetStreamer::prettyPrintAsm(MCInstPrinter &InstPrinter, raw_ostream &OS,
756                               const MCInst &Inst, const MCSubtargetInfo &STI) {
757   InstPrinter.printInst(&Inst, OS, "", STI);
758 }
759 
760 void MCStreamer::visitUsedSymbol(const MCSymbol &Sym) {
761 }
762 
763 void MCStreamer::visitUsedExpr(const MCExpr &Expr) {
764   switch (Expr.getKind()) {
765   case MCExpr::Target:
766     cast<MCTargetExpr>(Expr).visitUsedExpr(*this);
767     break;
768 
769   case MCExpr::Constant:
770     break;
771 
772   case MCExpr::Binary: {
773     const MCBinaryExpr &BE = cast<MCBinaryExpr>(Expr);
774     visitUsedExpr(*BE.getLHS());
775     visitUsedExpr(*BE.getRHS());
776     break;
777   }
778 
779   case MCExpr::SymbolRef:
780     visitUsedSymbol(cast<MCSymbolRefExpr>(Expr).getSymbol());
781     break;
782 
783   case MCExpr::Unary:
784     visitUsedExpr(*cast<MCUnaryExpr>(Expr).getSubExpr());
785     break;
786   }
787 }
788 
789 void MCStreamer::EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
790                                  bool) {
791   // Scan for values.
792   for (unsigned i = Inst.getNumOperands(); i--;)
793     if (Inst.getOperand(i).isExpr())
794       visitUsedExpr(*Inst.getOperand(i).getExpr());
795 }
796 
797 void MCStreamer::emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo,
798                                         unsigned Size) {
799   // Get the Hi-Lo expression.
800   const MCExpr *Diff =
801       MCBinaryExpr::createSub(MCSymbolRefExpr::create(Hi, Context),
802                               MCSymbolRefExpr::create(Lo, Context), Context);
803 
804   const MCAsmInfo *MAI = Context.getAsmInfo();
805   if (!MAI->doesSetDirectiveSuppressReloc()) {
806     EmitValue(Diff, Size);
807     return;
808   }
809 
810   // Otherwise, emit with .set (aka assignment).
811   MCSymbol *SetLabel = Context.createTempSymbol("set", true);
812   EmitAssignment(SetLabel, Diff);
813   EmitSymbolValue(SetLabel, Size);
814 }
815 
816 void MCStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) {}
817 void MCStreamer::EmitThumbFunc(MCSymbol *Func) {}
818 void MCStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {}
819 void MCStreamer::BeginCOFFSymbolDef(const MCSymbol *Symbol) {
820   llvm_unreachable("this directive only supported on COFF targets");
821 }
822 void MCStreamer::EndCOFFSymbolDef() {
823   llvm_unreachable("this directive only supported on COFF targets");
824 }
825 void MCStreamer::EmitFileDirective(StringRef Filename) {}
826 void MCStreamer::EmitCOFFSymbolStorageClass(int StorageClass) {
827   llvm_unreachable("this directive only supported on COFF targets");
828 }
829 void MCStreamer::EmitCOFFSymbolType(int Type) {
830   llvm_unreachable("this directive only supported on COFF targets");
831 }
832 void MCStreamer::emitELFSize(MCSymbol *Symbol, const MCExpr *Value) {}
833 void MCStreamer::emitELFSymverDirective(MCSymbol *Alias,
834                                         const MCSymbol *Aliasee) {}
835 void MCStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
836                                        unsigned ByteAlignment) {}
837 void MCStreamer::EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
838                                 uint64_t Size, unsigned ByteAlignment) {}
839 void MCStreamer::ChangeSection(MCSection *, const MCExpr *) {}
840 void MCStreamer::EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {}
841 void MCStreamer::EmitBytes(StringRef Data) {}
842 void MCStreamer::EmitBinaryData(StringRef Data) { EmitBytes(Data); }
843 void MCStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) {
844   visitUsedExpr(*Value);
845 }
846 void MCStreamer::EmitULEB128Value(const MCExpr *Value) {}
847 void MCStreamer::EmitSLEB128Value(const MCExpr *Value) {}
848 void MCStreamer::emitFill(const MCExpr &NumBytes, uint64_t Value, SMLoc Loc) {}
849 void MCStreamer::emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr,
850                           SMLoc Loc) {}
851 void MCStreamer::EmitValueToAlignment(unsigned ByteAlignment, int64_t Value,
852                                       unsigned ValueSize,
853                                       unsigned MaxBytesToEmit) {}
854 void MCStreamer::EmitCodeAlignment(unsigned ByteAlignment,
855                                    unsigned MaxBytesToEmit) {}
856 void MCStreamer::emitValueToOffset(const MCExpr *Offset, unsigned char Value,
857                                    SMLoc Loc) {}
858 void MCStreamer::EmitBundleAlignMode(unsigned AlignPow2) {}
859 void MCStreamer::EmitBundleLock(bool AlignToEnd) {}
860 void MCStreamer::FinishImpl() {}
861 void MCStreamer::EmitBundleUnlock() {}
862 
863 void MCStreamer::SwitchSection(MCSection *Section, const MCExpr *Subsection) {
864   assert(Section && "Cannot switch to a null section!");
865   MCSectionSubPair curSection = SectionStack.back().first;
866   SectionStack.back().second = curSection;
867   if (MCSectionSubPair(Section, Subsection) != curSection) {
868     ChangeSection(Section, Subsection);
869     SectionStack.back().first = MCSectionSubPair(Section, Subsection);
870     assert(!Section->hasEnded() && "Section already ended");
871     MCSymbol *Sym = Section->getBeginSymbol();
872     if (Sym && !Sym->isInSection())
873       EmitLabel(Sym);
874   }
875 }
876 
877 MCSymbol *MCStreamer::endSection(MCSection *Section) {
878   // TODO: keep track of the last subsection so that this symbol appears in the
879   // correct place.
880   MCSymbol *Sym = Section->getEndSymbol(Context);
881   if (Sym->isInSection())
882     return Sym;
883 
884   SwitchSection(Section);
885   EmitLabel(Sym);
886   return Sym;
887 }
888