LLVM  9.0.0svn
MCStreamer.cpp
Go to the documentation of this file.
1 //===- lib/MC/MCStreamer.cpp - Streaming Machine Code Output --------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "llvm/MC/MCStreamer.h"
10 #include "llvm/ADT/Optional.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"
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"
31 #include "llvm/Support/LEB128.h"
34 #include <cassert>
35 #include <cstdint>
36 #include <cstdlib>
37 #include <utility>
38 
39 using namespace llvm;
40 
42  S.setTargetStreamer(this);
43 }
44 
45 // Pin the vtables to this file.
47 
49 
51 
54  const MCExpr *Subsection,
55  raw_ostream &OS) {
56  Section->PrintSwitchToSection(
59  Subsection);
60 }
61 
63  Streamer.EmitRawText(Directive);
64 }
65 
67  SmallString<128> Str;
68  raw_svector_ostream OS(Str);
69 
70  Value->print(OS, Streamer.getContext().getAsmInfo());
71  Streamer.EmitRawText(OS.str());
72 }
73 
75  const MCAsmInfo *MAI = Streamer.getContext().getAsmInfo();
76  const char *Directive = MAI->getData8bitsDirective();
77  for (const unsigned char C : Data.bytes()) {
78  SmallString<128> Str;
79  raw_svector_ostream OS(Str);
80 
81  OS << Directive << (unsigned)C;
82  Streamer.EmitRawText(OS.str());
83  }
84 }
85 
87 
89  : Context(Ctx), CurrentWinFrameInfo(nullptr),
90  UseAssemblerInfoForParsing(false) {
91  SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>());
92 }
93 
95 
97  DwarfFrameInfos.clear();
98  CurrentWinFrameInfo = nullptr;
99  WinFrameInfos.clear();
100  SymbolOrdering.clear();
101  SectionStack.clear();
102  SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>());
103 }
104 
106  // By default, discard comments.
107  return nulls();
108 }
109 
110 unsigned MCStreamer::getNumFrameInfos() { return DwarfFrameInfos.size(); }
112  return DwarfFrameInfos;
113 }
114 
115 void MCStreamer::emitRawComment(const Twine &T, bool TabPrefix) {}
116 
119 
121  for (auto &FI : DwarfFrameInfos)
122  FI.CompactUnwindEncoding =
123  (MAB ? MAB->generateCompactUnwindEncoding(FI.Instructions) : 0);
124 }
125 
126 /// EmitIntValue - Special case of EmitValue that avoids the client having to
127 /// pass in a MCExpr for constant integers.
128 void MCStreamer::EmitIntValue(uint64_t Value, unsigned Size) {
129  assert(1 <= Size && Size <= 8 && "Invalid size");
130  assert((isUIntN(8 * Size, Value) || isIntN(8 * Size, Value)) &&
131  "Invalid size");
132  char buf[8];
133  const bool isLittleEndian = Context.getAsmInfo()->isLittleEndian();
134  for (unsigned i = 0; i != Size; ++i) {
135  unsigned index = isLittleEndian ? i : (Size - i - 1);
136  buf[i] = uint8_t(Value >> (index * 8));
137  }
138  EmitBytes(StringRef(buf, Size));
139 }
140 
141 /// EmitULEB128IntValue - Special case of EmitULEB128Value that avoids the
142 /// client having to pass in a MCExpr for constant integers.
143 void MCStreamer::EmitULEB128IntValue(uint64_t Value, unsigned PadTo) {
144  SmallString<128> Tmp;
145  raw_svector_ostream OSE(Tmp);
146  encodeULEB128(Value, OSE, PadTo);
147  EmitBytes(OSE.str());
148 }
149 
150 /// EmitSLEB128IntValue - Special case of EmitSLEB128Value that avoids the
151 /// client having to pass in a MCExpr for constant integers.
153  SmallString<128> Tmp;
154  raw_svector_ostream OSE(Tmp);
155  encodeSLEB128(Value, OSE);
156  EmitBytes(OSE.str());
157 }
158 
159 void MCStreamer::EmitValue(const MCExpr *Value, unsigned Size, SMLoc Loc) {
160  EmitValueImpl(Value, Size, Loc);
161 }
162 
163 void MCStreamer::EmitSymbolValue(const MCSymbol *Sym, unsigned Size,
164  bool IsSectionRelative) {
165  assert((!IsSectionRelative || Size == 4) &&
166  "SectionRelative value requires 4-bytes");
167 
168  if (!IsSectionRelative)
170  else
171  EmitCOFFSecRel32(Sym, /*Offset=*/0);
172 }
173 
175  report_fatal_error("unsupported directive in streamer");
176 }
177 
179  report_fatal_error("unsupported directive in streamer");
180 }
181 
183  report_fatal_error("unsupported directive in streamer");
184 }
185 
187  report_fatal_error("unsupported directive in streamer");
188 }
189 
191  report_fatal_error("unsupported directive in streamer");
192 }
193 
195  report_fatal_error("unsupported directive in streamer");
196 }
197 
198 /// Emit NumBytes bytes worth of the value specified by FillValue.
199 /// This implements directives such as '.space'.
200 void MCStreamer::emitFill(uint64_t NumBytes, uint8_t FillValue) {
201  emitFill(*MCConstantExpr::create(NumBytes, getContext()), FillValue);
202 }
203 
204 /// The implementation in this class just redirects to emitFill.
205 void MCStreamer::EmitZeros(uint64_t NumBytes) {
206  emitFill(NumBytes, 0);
207 }
208 
211  StringRef Filename,
212  Optional<MD5::MD5Result> Checksum,
214  unsigned CUID) {
215  return getContext().getDwarfFile(Directory, Filename, FileNo, Checksum,
216  Source, CUID);
217 }
218 
220  StringRef Filename,
221  Optional<MD5::MD5Result> Checksum,
223  unsigned CUID) {
224  getContext().setMCLineTableRootFile(CUID, Directory, Filename, Checksum,
225  Source);
226 }
227 
229  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
230  if (!CurFrame)
231  return;
232  CurFrame->IsBKeyFrame = true;
233 }
234 
235 void MCStreamer::EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
236  unsigned Column, unsigned Flags,
237  unsigned Isa,
238  unsigned Discriminator,
239  StringRef FileName) {
240  getContext().setCurrentDwarfLoc(FileNo, Line, Column, Flags, Isa,
241  Discriminator);
242 }
243 
246  if (!Table.getLabel()) {
248  Table.setLabel(
249  Context.getOrCreateSymbol(Prefix + "line_table_start" + Twine(CUID)));
250  }
251  return Table.getLabel();
252 }
253 
255  return !DwarfFrameInfos.empty() && !DwarfFrameInfos.back().End;
256 }
257 
258 MCDwarfFrameInfo *MCStreamer::getCurrentDwarfFrameInfo() {
260  getContext().reportError(SMLoc(), "this directive must appear between "
261  ".cfi_startproc and .cfi_endproc "
262  "directives");
263  return nullptr;
264  }
265  return &DwarfFrameInfos.back();
266 }
267 
268 bool MCStreamer::EmitCVFileDirective(unsigned FileNo, StringRef Filename,
269  ArrayRef<uint8_t> Checksum,
270  unsigned ChecksumKind) {
271  return getContext().getCVContext().addFile(*this, FileNo, Filename, Checksum,
272  ChecksumKind);
273 }
274 
275 bool MCStreamer::EmitCVFuncIdDirective(unsigned FunctionId) {
276  return getContext().getCVContext().recordFunctionId(FunctionId);
277 }
278 
280  unsigned IAFunc, unsigned IAFile,
281  unsigned IALine, unsigned IACol,
282  SMLoc Loc) {
283  if (getContext().getCVContext().getCVFunctionInfo(IAFunc) == nullptr) {
284  getContext().reportError(Loc, "parent function id not introduced by "
285  ".cv_func_id or .cv_inline_site_id");
286  return true;
287  }
288 
290  FunctionId, IAFunc, IAFile, IALine, IACol);
291 }
292 
293 void MCStreamer::EmitCVLocDirective(unsigned FunctionId, unsigned FileNo,
294  unsigned Line, unsigned Column,
295  bool PrologueEnd, bool IsStmt,
296  StringRef FileName, SMLoc Loc) {}
297 
298 bool MCStreamer::checkCVLocSection(unsigned FuncId, unsigned FileNo,
299  SMLoc Loc) {
301  MCCVFunctionInfo *FI = CVC.getCVFunctionInfo(FuncId);
302  if (!FI) {
304  Loc, "function id not introduced by .cv_func_id or .cv_inline_site_id");
305  return false;
306  }
307 
308  // Track the section
309  if (FI->Section == nullptr)
311  else if (FI->Section != getCurrentSectionOnly()) {
313  Loc,
314  "all .cv_loc directives for a function must be in the same section");
315  return false;
316  }
317  return true;
318 }
319 
320 void MCStreamer::EmitCVLinetableDirective(unsigned FunctionId,
321  const MCSymbol *Begin,
322  const MCSymbol *End) {}
323 
324 void MCStreamer::EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
325  unsigned SourceFileId,
326  unsigned SourceLineNum,
327  const MCSymbol *FnStartSym,
328  const MCSymbol *FnEndSym) {}
329 
331  ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
332  StringRef FixedSizePortion) {}
333 
335  MCSymbol *EHSymbol) {
336 }
337 
338 void MCStreamer::InitSections(bool NoExecStack) {
339  SwitchSection(getContext().getObjectFileInfo()->getTextSection());
340 }
341 
343  assert(Fragment);
344  Symbol->setFragment(Fragment);
345 
346  // As we emit symbols into a section, track the order so that they can
347  // be sorted upon later. Zero is reserved to mean 'unemitted'.
348  SymbolOrdering[Symbol] = 1 + SymbolOrdering.size();
349 }
350 
352  Symbol->redefineIfPossible();
353 
354  if (!Symbol->isUndefined() || Symbol->isVariable())
355  return getContext().reportError(Loc, "invalid symbol redefinition");
356 
357  assert(!Symbol->isVariable() && "Cannot emit a variable symbol!");
358  assert(getCurrentSectionOnly() && "Cannot emit before setting section!");
359  assert(!Symbol->getFragment() && "Unexpected fragment on symbol data!");
360  assert(Symbol->isUndefined() && "Cannot define a symbol twice!");
361 
362  Symbol->setFragment(&getCurrentSectionOnly()->getDummyFragment());
363 
365  if (TS)
366  TS->emitLabel(Symbol);
367 }
368 
369 void MCStreamer::EmitCFISections(bool EH, bool Debug) {
370  assert(EH || Debug);
371 }
372 
373 void MCStreamer::EmitCFIStartProc(bool IsSimple, SMLoc Loc) {
375  return getContext().reportError(
376  Loc, "starting new .cfi frame before finishing the previous one");
377 
378  MCDwarfFrameInfo Frame;
379  Frame.IsSimple = IsSimple;
380  EmitCFIStartProcImpl(Frame);
381 
382  const MCAsmInfo* MAI = Context.getAsmInfo();
383  if (MAI) {
384  for (const MCCFIInstruction& Inst : MAI->getInitialFrameState()) {
385  if (Inst.getOperation() == MCCFIInstruction::OpDefCfa ||
386  Inst.getOperation() == MCCFIInstruction::OpDefCfaRegister) {
387  Frame.CurrentCfaRegister = Inst.getRegister();
388  }
389  }
390  }
391 
392  DwarfFrameInfos.push_back(Frame);
393 }
394 
396 }
397 
399  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
400  if (!CurFrame)
401  return;
402  EmitCFIEndProcImpl(*CurFrame);
403 }
404 
406  // Put a dummy non-null value in Frame.End to mark that this frame has been
407  // closed.
408  Frame.End = (MCSymbol *)1;
409 }
410 
412  // Return a dummy non-null value so that label fields appear filled in when
413  // generating textual assembly.
414  return (MCSymbol *)1;
415 }
416 
417 void MCStreamer::EmitCFIDefCfa(int64_t Register, int64_t Offset) {
418  MCSymbol *Label = EmitCFILabel();
420  MCCFIInstruction::createDefCfa(Label, Register, Offset);
421  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
422  if (!CurFrame)
423  return;
424  CurFrame->Instructions.push_back(Instruction);
425  CurFrame->CurrentCfaRegister = static_cast<unsigned>(Register);
426 }
427 
429  MCSymbol *Label = EmitCFILabel();
432  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
433  if (!CurFrame)
434  return;
435  CurFrame->Instructions.push_back(Instruction);
436 }
437 
438 void MCStreamer::EmitCFIAdjustCfaOffset(int64_t Adjustment) {
439  MCSymbol *Label = EmitCFILabel();
441  MCCFIInstruction::createAdjustCfaOffset(Label, Adjustment);
442  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
443  if (!CurFrame)
444  return;
445  CurFrame->Instructions.push_back(Instruction);
446 }
447 
449  MCSymbol *Label = EmitCFILabel();
452  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
453  if (!CurFrame)
454  return;
455  CurFrame->Instructions.push_back(Instruction);
456  CurFrame->CurrentCfaRegister = static_cast<unsigned>(Register);
457 }
458 
459 void MCStreamer::EmitCFIOffset(int64_t Register, int64_t Offset) {
460  MCSymbol *Label = EmitCFILabel();
462  MCCFIInstruction::createOffset(Label, Register, Offset);
463  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
464  if (!CurFrame)
465  return;
466  CurFrame->Instructions.push_back(Instruction);
467 }
468 
470  MCSymbol *Label = EmitCFILabel();
472  MCCFIInstruction::createRelOffset(Label, Register, Offset);
473  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
474  if (!CurFrame)
475  return;
476  CurFrame->Instructions.push_back(Instruction);
477 }
478 
480  unsigned Encoding) {
481  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
482  if (!CurFrame)
483  return;
484  CurFrame->Personality = Sym;
485  CurFrame->PersonalityEncoding = Encoding;
486 }
487 
488 void MCStreamer::EmitCFILsda(const MCSymbol *Sym, unsigned Encoding) {
489  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
490  if (!CurFrame)
491  return;
492  CurFrame->Lsda = Sym;
493  CurFrame->LsdaEncoding = Encoding;
494 }
495 
497  MCSymbol *Label = EmitCFILabel();
499  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
500  if (!CurFrame)
501  return;
502  CurFrame->Instructions.push_back(Instruction);
503 }
504 
506  // FIXME: Error if there is no matching cfi_remember_state.
507  MCSymbol *Label = EmitCFILabel();
509  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
510  if (!CurFrame)
511  return;
512  CurFrame->Instructions.push_back(Instruction);
513 }
514 
516  MCSymbol *Label = EmitCFILabel();
518  MCCFIInstruction::createSameValue(Label, Register);
519  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
520  if (!CurFrame)
521  return;
522  CurFrame->Instructions.push_back(Instruction);
523 }
524 
526  MCSymbol *Label = EmitCFILabel();
528  MCCFIInstruction::createRestore(Label, Register);
529  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
530  if (!CurFrame)
531  return;
532  CurFrame->Instructions.push_back(Instruction);
533 }
534 
536  MCSymbol *Label = EmitCFILabel();
538  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
539  if (!CurFrame)
540  return;
541  CurFrame->Instructions.push_back(Instruction);
542 }
543 
545  MCSymbol *Label = EmitCFILabel();
548  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
549  if (!CurFrame)
550  return;
551  CurFrame->Instructions.push_back(Instruction);
552 }
553 
555  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
556  if (!CurFrame)
557  return;
558  CurFrame->IsSignalFrame = true;
559 }
560 
562  MCSymbol *Label = EmitCFILabel();
564  MCCFIInstruction::createUndefined(Label, Register);
565  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
566  if (!CurFrame)
567  return;
568  CurFrame->Instructions.push_back(Instruction);
569 }
570 
571 void MCStreamer::EmitCFIRegister(int64_t Register1, int64_t Register2) {
572  MCSymbol *Label = EmitCFILabel();
574  MCCFIInstruction::createRegister(Label, Register1, Register2);
575  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
576  if (!CurFrame)
577  return;
578  CurFrame->Instructions.push_back(Instruction);
579 }
580 
582  MCSymbol *Label = EmitCFILabel();
585  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
586  if (!CurFrame)
587  return;
588  CurFrame->Instructions.push_back(Instruction);
589 }
590 
592  MCSymbol *Label = EmitCFILabel();
594  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
595  if (!CurFrame)
596  return;
597  CurFrame->Instructions.push_back(Instruction);
598 }
599 
601  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
602  if (!CurFrame)
603  return;
604  CurFrame->RAReg = Register;
605 }
606 
608  const MCAsmInfo *MAI = Context.getAsmInfo();
609  if (!MAI->usesWindowsCFI()) {
611  Loc, ".seh_* directives are not supported on this target");
612  return nullptr;
613  }
614  if (!CurrentWinFrameInfo || CurrentWinFrameInfo->End) {
616  Loc, ".seh_ directive must appear within an active frame");
617  return nullptr;
618  }
619  return CurrentWinFrameInfo;
620 }
621 
623  const MCAsmInfo *MAI = Context.getAsmInfo();
624  if (!MAI->usesWindowsCFI())
625  return getContext().reportError(
626  Loc, ".seh_* directives are not supported on this target");
627  if (CurrentWinFrameInfo && !CurrentWinFrameInfo->End)
629  Loc, "Starting a function before ending the previous one!");
630 
631  MCSymbol *StartProc = EmitCFILabel();
632 
633  WinFrameInfos.emplace_back(
634  llvm::make_unique<WinEH::FrameInfo>(Symbol, StartProc));
635  CurrentWinFrameInfo = WinFrameInfos.back().get();
636  CurrentWinFrameInfo->TextSection = getCurrentSectionOnly();
637 }
638 
640  WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
641  if (!CurFrame)
642  return;
643  if (CurFrame->ChainedParent)
644  getContext().reportError(Loc, "Not all chained regions terminated!");
645 
646  MCSymbol *Label = EmitCFILabel();
647  CurFrame->End = Label;
648 }
649 
651  WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
652  if (!CurFrame)
653  return;
654  if (CurFrame->ChainedParent)
655  getContext().reportError(Loc, "Not all chained regions terminated!");
656 
657  MCSymbol *Label = EmitCFILabel();
658  CurFrame->FuncletOrFuncEnd = Label;
659 }
660 
662  WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
663  if (!CurFrame)
664  return;
665 
666  MCSymbol *StartProc = EmitCFILabel();
667 
668  WinFrameInfos.emplace_back(llvm::make_unique<WinEH::FrameInfo>(
669  CurFrame->Function, StartProc, CurFrame));
670  CurrentWinFrameInfo = WinFrameInfos.back().get();
671  CurrentWinFrameInfo->TextSection = getCurrentSectionOnly();
672 }
673 
675  WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
676  if (!CurFrame)
677  return;
678  if (!CurFrame->ChainedParent)
679  return getContext().reportError(
680  Loc, "End of a chained region outside a chained region!");
681 
682  MCSymbol *Label = EmitCFILabel();
683 
684  CurFrame->End = Label;
685  CurrentWinFrameInfo = const_cast<WinEH::FrameInfo *>(CurFrame->ChainedParent);
686 }
687 
688 void MCStreamer::EmitWinEHHandler(const MCSymbol *Sym, bool Unwind, bool Except,
689  SMLoc Loc) {
690  WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
691  if (!CurFrame)
692  return;
693  if (CurFrame->ChainedParent)
694  return getContext().reportError(
695  Loc, "Chained unwind areas can't have handlers!");
696  CurFrame->ExceptionHandler = Sym;
697  if (!Except && !Unwind)
698  getContext().reportError(Loc, "Don't know what kind of handler this is!");
699  if (Unwind)
700  CurFrame->HandlesUnwind = true;
701  if (Except)
702  CurFrame->HandlesExceptions = true;
703 }
704 
706  WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
707  if (!CurFrame)
708  return;
709  if (CurFrame->ChainedParent)
710  getContext().reportError(Loc, "Chained unwind areas can't have handlers!");
711 }
712 
714  const MCSymbolRefExpr *To, uint64_t Count) {
715 }
716 
717 static MCSection *getWinCFISection(MCContext &Context, unsigned *NextWinCFIID,
718  MCSection *MainCFISec,
719  const MCSection *TextSec) {
720  // If this is the main .text section, use the main unwind info section.
721  if (TextSec == Context.getObjectFileInfo()->getTextSection())
722  return MainCFISec;
723 
724  const auto *TextSecCOFF = cast<MCSectionCOFF>(TextSec);
725  auto *MainCFISecCOFF = cast<MCSectionCOFF>(MainCFISec);
726  unsigned UniqueID = TextSecCOFF->getOrAssignWinCFISectionID(NextWinCFIID);
727 
728  // If this section is COMDAT, this unwind section should be COMDAT associative
729  // with its group.
730  const MCSymbol *KeySym = nullptr;
731  if (TextSecCOFF->getCharacteristics() & COFF::IMAGE_SCN_LNK_COMDAT) {
732  KeySym = TextSecCOFF->getCOMDATSymbol();
733 
734  // In a GNU environment, we can't use associative comdats. Instead, do what
735  // GCC does, which is to make plain comdat selectany section named like
736  // ".[px]data$_Z3foov".
737  if (!Context.getAsmInfo()->hasCOFFAssociativeComdats()) {
738  std::string SectionName =
739  (MainCFISecCOFF->getSectionName() + "$" +
740  TextSecCOFF->getSectionName().split('$').second)
741  .str();
742  return Context.getCOFFSection(
743  SectionName,
744  MainCFISecCOFF->getCharacteristics() | COFF::IMAGE_SCN_LNK_COMDAT,
745  MainCFISecCOFF->getKind(), "", COFF::IMAGE_COMDAT_SELECT_ANY);
746  }
747  }
748 
749  return Context.getAssociativeCOFFSection(MainCFISecCOFF, KeySym, UniqueID);
750 }
751 
753  return getWinCFISection(getContext(), &NextWinCFIID,
754  getContext().getObjectFileInfo()->getPDataSection(),
755  TextSec);
756 }
757 
759  return getWinCFISection(getContext(), &NextWinCFIID,
760  getContext().getObjectFileInfo()->getXDataSection(),
761  TextSec);
762 }
763 
765 
767  WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
768  if (!CurFrame)
769  return;
770 
771  MCSymbol *Label = EmitCFILabel();
772 
774  CurFrame->Instructions.push_back(Inst);
775 }
776 
778  SMLoc Loc) {
779  WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
780  if (!CurFrame)
781  return;
782  if (CurFrame->LastFrameInst >= 0)
783  return getContext().reportError(
784  Loc, "frame register and offset can be set at most once");
785  if (Offset & 0x0F)
786  return getContext().reportError(Loc, "offset is not a multiple of 16");
787  if (Offset > 240)
788  return getContext().reportError(
789  Loc, "frame offset must be less than or equal to 240");
790 
791  MCSymbol *Label = EmitCFILabel();
792 
793  WinEH::Instruction Inst =
794  Win64EH::Instruction::SetFPReg(Label, Register, Offset);
795  CurFrame->LastFrameInst = CurFrame->Instructions.size();
796  CurFrame->Instructions.push_back(Inst);
797 }
798 
800  WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
801  if (!CurFrame)
802  return;
803  if (Size == 0)
804  return getContext().reportError(Loc,
805  "stack allocation size must be non-zero");
806  if (Size & 7)
807  return getContext().reportError(
808  Loc, "stack allocation size is not a multiple of 8");
809 
810  MCSymbol *Label = EmitCFILabel();
811 
813  CurFrame->Instructions.push_back(Inst);
814 }
815 
817  SMLoc Loc) {
818  WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
819  if (!CurFrame)
820  return;
821 
822  if (Offset & 7)
823  return getContext().reportError(
824  Loc, "register save offset is not 8 byte aligned");
825 
826  MCSymbol *Label = EmitCFILabel();
827 
828  WinEH::Instruction Inst =
829  Win64EH::Instruction::SaveNonVol(Label, Register, Offset);
830  CurFrame->Instructions.push_back(Inst);
831 }
832 
834  SMLoc Loc) {
835  WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
836  if (!CurFrame)
837  return;
838  if (Offset & 0x0F)
839  return getContext().reportError(Loc, "offset is not a multiple of 16");
840 
841  MCSymbol *Label = EmitCFILabel();
842 
843  WinEH::Instruction Inst =
844  Win64EH::Instruction::SaveXMM(Label, Register, Offset);
845  CurFrame->Instructions.push_back(Inst);
846 }
847 
849  WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
850  if (!CurFrame)
851  return;
852  if (!CurFrame->Instructions.empty())
853  return getContext().reportError(
854  Loc, "If present, PushMachFrame must be the first UOP");
855 
856  MCSymbol *Label = EmitCFILabel();
857 
859  CurFrame->Instructions.push_back(Inst);
860 }
861 
863  WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
864  if (!CurFrame)
865  return;
866 
867  MCSymbol *Label = EmitCFILabel();
868 
869  CurFrame->PrologEnd = Label;
870 }
871 
873 
875 
877 
879 
881 
882 /// EmitRawText - If this file is backed by an assembly streamer, this dumps
883 /// the specified string in the output .s file. This capability is
884 /// indicated by the hasRawTextSupport() predicate.
886  // This is not llvm_unreachable for the sake of out of tree backend
887  // developers who may not have assembly streamers and should serve as a
888  // reminder to not accidentally call EmitRawText in the absence of such.
889  report_fatal_error("EmitRawText called on an MCStreamer that doesn't support "
890  "it (target backend is likely missing an AsmStreamer "
891  "implementation)");
892 }
893 
895  SmallString<128> Str;
897 }
898 
900 }
901 
903  if ((!DwarfFrameInfos.empty() && !DwarfFrameInfos.back().End) ||
904  (!WinFrameInfos.empty() && !WinFrameInfos.back()->End)) {
905  getContext().reportError(SMLoc(), "Unfinished frame!");
906  return;
907  }
908 
910  if (TS)
911  TS->finish();
912 
913  FinishImpl();
914 }
915 
917  visitUsedExpr(*Value);
918  Symbol->setVariableValue(Value);
919 
921  if (TS)
922  TS->emitAssignment(Symbol, Value);
923 }
924 
926  raw_ostream &OS, const MCInst &Inst,
927  const MCSubtargetInfo &STI) {
928  InstPrinter.printInst(&Inst, OS, "", STI);
929 }
930 
932 }
933 
935  switch (Expr.getKind()) {
936  case MCExpr::Target:
937  cast<MCTargetExpr>(Expr).visitUsedExpr(*this);
938  break;
939 
940  case MCExpr::Constant:
941  break;
942 
943  case MCExpr::Binary: {
944  const MCBinaryExpr &BE = cast<MCBinaryExpr>(Expr);
945  visitUsedExpr(*BE.getLHS());
946  visitUsedExpr(*BE.getRHS());
947  break;
948  }
949 
950  case MCExpr::SymbolRef:
951  visitUsedSymbol(cast<MCSymbolRefExpr>(Expr).getSymbol());
952  break;
953 
954  case MCExpr::Unary:
955  visitUsedExpr(*cast<MCUnaryExpr>(Expr).getSubExpr());
956  break;
957  }
958 }
959 
961  // Scan for values.
962  for (unsigned i = Inst.getNumOperands(); i--;)
963  if (Inst.getOperand(i).isExpr())
964  visitUsedExpr(*Inst.getOperand(i).getExpr());
965 }
966 
968  unsigned Size) {
969  // Get the Hi-Lo expression.
970  const MCExpr *Diff =
972  MCSymbolRefExpr::create(Lo, Context), Context);
973 
974  const MCAsmInfo *MAI = Context.getAsmInfo();
975  if (!MAI->doesSetDirectiveSuppressReloc()) {
976  EmitValue(Diff, Size);
977  return;
978  }
979 
980  // Otherwise, emit with .set (aka assignment).
981  MCSymbol *SetLabel = Context.createTempSymbol("set", true);
982  EmitAssignment(SetLabel, Diff);
983  EmitSymbolValue(SetLabel, Size);
984 }
985 
987  const MCSymbol *Lo) {
988  // Get the Hi-Lo expression.
989  const MCExpr *Diff =
991  MCSymbolRefExpr::create(Lo, Context), Context);
992 
993  EmitULEB128Value(Diff);
994 }
995 
998 void MCStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {}
1000  llvm_unreachable("this directive only supported on COFF targets");
1001 }
1003  llvm_unreachable("this directive only supported on COFF targets");
1004 }
1007  llvm_unreachable("this directive only supported on COFF targets");
1008 }
1010  llvm_unreachable("this directive only supported on COFF targets");
1011 }
1014  const MCSymbol *Aliasee) {}
1016  unsigned ByteAlignment) {}
1018  uint64_t Size, unsigned ByteAlignment) {}
1023 void MCStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) {
1024  visitUsedExpr(*Value);
1025 }
1028 void MCStreamer::emitFill(const MCExpr &NumBytes, uint64_t Value, SMLoc Loc) {}
1029 void MCStreamer::emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr,
1030  SMLoc Loc) {}
1032  unsigned ValueSize,
1033  unsigned MaxBytesToEmit) {}
1035  unsigned MaxBytesToEmit) {}
1037  SMLoc Loc) {}
1038 void MCStreamer::EmitBundleAlignMode(unsigned AlignPow2) {}
1039 void MCStreamer::EmitBundleLock(bool AlignToEnd) {}
1042 
1044  assert(Section && "Cannot switch to a null section!");
1045  MCSectionSubPair curSection = SectionStack.back().first;
1046  SectionStack.back().second = curSection;
1047  if (MCSectionSubPair(Section, Subsection) != curSection) {
1048  ChangeSection(Section, Subsection);
1049  SectionStack.back().first = MCSectionSubPair(Section, Subsection);
1050  assert(!Section->hasEnded() && "Section already ended");
1051  MCSymbol *Sym = Section->getBeginSymbol();
1052  if (Sym && !Sym->isInSection())
1053  EmitLabel(Sym);
1054  }
1055 }
1056 
1058  // TODO: keep track of the last subsection so that this symbol appears in the
1059  // correct place.
1060  MCSymbol *Sym = Section->getEndSymbol(Context);
1061  if (Sym->isInSection())
1062  return Sym;
1063 
1064  SwitchSection(Section);
1065  EmitLabel(Sym);
1066  return Sym;
1067 }
1068 
1070  const VersionTuple &SDKVersion) {
1071  if (!Target.isOSBinFormatMachO() || !Target.isOSDarwin())
1072  return;
1073  // Do we even know the version?
1074  if (Target.getOSMajorVersion() == 0)
1075  return;
1076 
1077  unsigned Major;
1078  unsigned Minor;
1079  unsigned Update;
1080  MCVersionMinType VersionType;
1081  if (Target.isWatchOS()) {
1082  VersionType = MCVM_WatchOSVersionMin;
1083  Target.getWatchOSVersion(Major, Minor, Update);
1084  } else if (Target.isTvOS()) {
1085  VersionType = MCVM_TvOSVersionMin;
1086  Target.getiOSVersion(Major, Minor, Update);
1087  } else if (Target.isMacOSX()) {
1088  VersionType = MCVM_OSXVersionMin;
1089  if (!Target.getMacOSXVersion(Major, Minor, Update))
1090  Major = 0;
1091  } else {
1092  VersionType = MCVM_IOSVersionMin;
1093  Target.getiOSVersion(Major, Minor, Update);
1094  }
1095  if (Major != 0)
1096  EmitVersionMin(VersionType, Major, Minor, Update, SDKVersion);
1097 }
virtual void EmitBundleUnlock()
Ends a bundle-locked group.
virtual void EmitAssemblerFlag(MCAssemblerFlag Flag)
Note in the output the specified Flag.
Definition: MCStreamer.cpp:996
const MCAsmInfo * getAsmInfo() const
Definition: MCContext.h:292
virtual void EmitDwarfLocDirective(unsigned FileNo, unsigned Line, unsigned Column, unsigned Flags, unsigned Isa, unsigned Discriminator, StringRef FileName)
This implements the DWARF2 &#39;.loc fileno lineno ...&#39; assembler directive.
Definition: MCStreamer.cpp:235
uint64_t CallInst * C
virtual void EmitBundleAlignMode(unsigned AlignPow2)
Set the bundle alignment mode from now on in the section.
bool isOSDarwin() const
isOSDarwin - Is this a "Darwin" OS (OS X, iOS, or watchOS).
Definition: Triple.h:476
Profile::FuncID FuncId
Definition: Profile.cpp:320
Instances of this class represent a uniqued identifier for a section in the current translation unit...
Definition: MCSection.h:38
bool doesSetDirectiveSuppressReloc() const
Definition: MCAsmInfo.h:523
void getiOSVersion(unsigned &Major, unsigned &Minor, unsigned &Micro) const
getiOSVersion - Parse the version number as with getOSVersion.
Definition: Triple.cpp:1099
MCStreamer(MCContext &Ctx)
Definition: MCStreamer.cpp:88
bool usesWindowsCFI() const
Definition: MCAsmInfo.h:583
virtual void EmitCFISameValue(int64_t Register)
Definition: MCStreamer.cpp:515
virtual void EmitCVDefRangeDirective(ArrayRef< std::pair< const MCSymbol *, const MCSymbol *>> Ranges, StringRef FixedSizePortion)
This implements the CodeView &#39;.cv_def_range&#39; assembler directive.
Definition: MCStreamer.cpp:330
virtual void EmitCFIPersonality(const MCSymbol *Sym, unsigned Encoding)
Definition: MCStreamer.cpp:479
virtual void EmitWinCFIPushReg(unsigned Register, SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:766
virtual void EmitSLEB128Value(const MCExpr *Value)
virtual void EmitCFIGnuArgsSize(int64_t Size)
Definition: MCStreamer.cpp:544
LLVMContext & Context
void EmitRawText(const Twine &String)
If this file is backed by a assembly streamer, this dumps the specified string in the output ...
Definition: MCStreamer.cpp:894
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:321
void EmitSLEB128IntValue(int64_t Value)
Special case of EmitSLEB128Value that avoids the client having to pass in a MCExpr for constant integ...
Definition: MCStreamer.cpp:152
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:139
This class represents lattice values for constants.
Definition: AllocatorList.h:23
bool isVariable() const
isVariable - Check if this is a variable symbol.
Definition: MCSymbol.h:293
void EmitSymbolValue(const MCSymbol *Sym, unsigned Size, bool IsSectionRelative=false)
Special case of EmitValue that avoids the client having to pass in a MCExpr for MCSymbols.
Definition: MCStreamer.cpp:163
bool isMacOSX() const
isMacOSX - Is this a Mac OS X triple.
Definition: Triple.h:448
virtual void emitValueToOffset(const MCExpr *Offset, unsigned char Value, SMLoc Loc)
Emit some number of copies of Value until the byte offset Offset is reached.
virtual void emitELFSymverDirective(StringRef AliasName, const MCSymbol *Aliasee)
Emit an ELF .symver directive.
virtual void printInst(const MCInst *MI, raw_ostream &OS, StringRef Annot, const MCSubtargetInfo &STI)=0
Print the specified MCInst to the specified raw_ostream.
virtual void EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size, unsigned ByteAlignment=0)
Emit a thread local bss (.tbss) symbol.
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
void redefineIfPossible()
Prepare this symbol to be redefined.
Definition: MCSymbol.h:229
virtual void EmitWinCFIStartProc(const MCSymbol *Symbol, SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:622
virtual void EndCOFFSymbolDef()
Marks the end of the symbol definition.
MCSection * Section
The section of the first .cv_loc directive used for this function, or null if none has been seen yet...
Definition: MCCodeView.h:111
const MCSymbol * End
Definition: MCWinEH.h:33
.watchos_version_min
Definition: MCDirectives.h:68
virtual void EmitULEB128Value(const MCExpr *Value)
static MCCFIInstruction createRememberState(MCSymbol *L)
.cfi_remember_state Save all current rules for all registers.
Definition: MCDwarf.h:554
virtual void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol)
Emit an weak reference from Alias to Symbol.
void push_back(const T &Elt)
Definition: SmallVector.h:211
static WinEH::Instruction SaveNonVol(MCSymbol *L, unsigned Reg, unsigned Offset)
Definition: MCWin64EH.h:36
virtual void EmitWinCFISaveXMM(unsigned Register, unsigned Offset, SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:833
virtual void EmitBytes(StringRef Data)
Emit the bytes in Data into the output.
static MCCFIInstruction createOffset(MCSymbol *L, unsigned Register, int Offset)
.cfi_offset Previous value of Register is saved at offset Offset from CFA.
Definition: MCDwarf.h:504
Target specific streamer interface.
Definition: MCStreamer.h:83
StringRef toStringRef(SmallVectorImpl< char > &Out) const
This returns the twine as a single StringRef if it can be represented as such.
Definition: Twine.h:455
.ios_version_min
Definition: MCDirectives.h:65
virtual void reset()
State management.
Definition: MCStreamer.cpp:96
unsigned CurrentCfaRegister
Definition: MCDwarf.h:611
virtual void EmitWindowsUnwindTables()
Definition: MCStreamer.cpp:899
virtual void BeginCOFFSymbolDef(const MCSymbol *Symbol)
Start emitting COFF symbol definition.
Definition: MCStreamer.cpp:999
virtual Expected< unsigned > tryEmitDwarfFileDirective(unsigned FileNo, StringRef Directory, StringRef Filename, Optional< MD5::MD5Result > Checksum=None, Optional< StringRef > Source=None, unsigned CUID=0)
Associate a filename with a specified logical file number.
Definition: MCStreamer.cpp:210
virtual void EmitDTPRel64Value(const MCExpr *Value)
Emit the expression Value into the output as a dtprel (64-bit DTP relative) value.
Definition: MCStreamer.cpp:174
bool isWatchOS() const
Is this an Apple watchOS triple.
Definition: Triple.h:467
const MCExpr * getLHS() const
Get the left-hand side expression of the binary operator.
Definition: MCExpr.h:562
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:509
virtual void EmitCFIRegister(int64_t Register1, int64_t Register2)
Definition: MCStreamer.cpp:571
virtual void emitExplicitComments()
Emit added explicit comments.
Definition: MCStreamer.cpp:118
virtual void emitValue(const MCExpr *Value)
Definition: MCStreamer.cpp:66
.macosx_version_min
Definition: MCDirectives.h:66
virtual void emitAbsoluteSymbolDiffAsULEB128(const MCSymbol *Hi, const MCSymbol *Lo)
Emit the absolute difference between two symbols encoded with ULEB128.
Definition: MCStreamer.cpp:986
virtual void EmitCFIDefCfaOffset(int64_t Offset)
Definition: MCStreamer.cpp:428
virtual MCSymbol * getDwarfLineTableSymbol(unsigned CUID)
Definition: MCStreamer.cpp:244
StringRef getPrivateGlobalPrefix() const
Definition: MCAsmInfo.h:490
static MCCFIInstruction createDefCfaOffset(MCSymbol *L, int Offset)
.cfi_def_cfa_offset modifies a rule for computing CFA.
Definition: MCDwarf.h:491
COFF::SymbolStorageClass StorageClass
Definition: COFFYAML.cpp:356
virtual void EmitCOFFSymbolStorageClass(int StorageClass)
Emit the storage class of the symbol.
std::vector< Instruction > Instructions
Definition: MCWinEH.h:46
virtual void EmitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc=SMLoc())
Emit the expression Value into the output as a native integer of the given Size bytes.
unsigned LsdaEncoding
Definition: MCDwarf.h:613
virtual void EmitCOFFImgRel32(MCSymbol const *Symbol, int64_t Offset)
Emits a COFF image relative relocation.
Definition: MCStreamer.cpp:880
static MCCFIInstruction createAdjustCfaOffset(MCSymbol *L, int Adjustment)
.cfi_adjust_cfa_offset Same as .cfi_def_cfa_offset, but Offset is a relative value that is added/subt...
Definition: MCDwarf.h:498
virtual void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI)
Emit the given Instruction into the current section.
Definition: MCStreamer.cpp:960
bool addFile(MCStreamer &OS, unsigned FileNumber, StringRef Filename, ArrayRef< uint8_t > ChecksumBytes, uint8_t ChecksumKind)
Definition: MCCodeView.cpp:46
MCSectionCOFF * getCOFFSection(StringRef Section, unsigned Characteristics, SectionKind Kind, StringRef COMDATSymName, int Selection, unsigned UniqueID=GenericSectionID, const char *BeginSymName=nullptr)
Definition: MCContext.cpp:425
virtual void addExplicitComment(const Twine &T)
Add explicit comment T.
Definition: MCStreamer.cpp:117
virtual void EmitCFISections(bool EH, bool Debug)
Definition: MCStreamer.cpp:369
virtual void EmitGPRel32Value(const MCExpr *Value)
Emit the expression Value into the output as a gprel32 (32-bit GP relative) value.
Definition: MCStreamer.cpp:194
MCSectionCOFF * getAssociativeCOFFSection(MCSectionCOFF *Sec, const MCSymbol *KeySym, unsigned UniqueID=GenericSectionID)
Gets or creates a section equivalent to Sec that is associated with the section containing KeySym...
Definition: MCContext.cpp:473
std::vector< MCCFIInstruction > Instructions
Definition: MCDwarf.h:610
static MCCFIInstruction createUndefined(MCSymbol *L, unsigned Register)
.cfi_undefined From now on the previous value of Register can&#39;t be restored anymore.
Definition: MCDwarf.h:543
virtual void EmitCFIRememberState()
Definition: MCStreamer.cpp:496
MCContext & getContext() const
Definition: MCStreamer.h:250
unsigned getNumFrameInfos()
Definition: MCStreamer.cpp:110
virtual void EmitCFILsda(const MCSymbol *Sym, unsigned Encoding)
Definition: MCStreamer.cpp:488
virtual void EmitGPRel64Value(const MCExpr *Value)
Emit the expression Value into the output as a gprel64 (64-bit GP relative) value.
Definition: MCStreamer.cpp:190
void AssignFragment(MCSymbol *Symbol, MCFragment *Fragment)
Sets the symbol&#39;s section.
Definition: MCStreamer.cpp:342
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
virtual void EmitWinCFIEndProc(SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:639
virtual void EmitCFIEscape(StringRef Values)
Definition: MCStreamer.cpp:535
virtual void EmitCOFFSymbolType(int Type)
Emit the type of the symbol.
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
bool isInSection() const
isInSection - Check if this symbol is defined in some section (i.e., it is defined but not absolute)...
Definition: MCSymbol.h:251
virtual void EmitWinEHHandler(const MCSymbol *Sym, bool Unwind, bool Except, SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:688
Represent a reference to a symbol from inside an expression.
Definition: MCExpr.h:165
const MCSymbol * Lsda
Definition: MCDwarf.h:609
void setFragment(MCFragment *F) const
Mark the symbol as defined in the fragment F.
Definition: MCSymbol.h:272
iterator_range< const unsigned char * > bytes() const
Definition: StringRef.h:111
virtual uint32_t generateCompactUnwindEncoding(ArrayRef< MCCFIInstruction >) const
Generate the compact unwind encoding for the CFI instructions.
Definition: MCAsmBackend.h:179
Tagged union holding either a T or a Error.
Definition: CachePruning.h:22
virtual void emitLabel(MCSymbol *Symbol)
Definition: MCStreamer.cpp:48
virtual void EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame)
Definition: MCStreamer.cpp:395
virtual ~MCStreamer()
Definition: MCStreamer.cpp:94
MCDwarfLineTable & getMCDwarfLineTable(unsigned CUID)
Definition: MCContext.h:523
MCSymbol * getEndSymbol(MCContext &Ctx)
Definition: MCSection.cpp:28
virtual void EmitCVLocDirective(unsigned FunctionId, unsigned FileNo, unsigned Line, unsigned Column, bool PrologueEnd, bool IsStmt, StringRef FileName, SMLoc Loc)
This implements the CodeView &#39;.cv_loc&#39; assembler directive.
Definition: MCStreamer.cpp:293
virtual void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value)
Emit an assignment of Value to Symbol.
Definition: MCStreamer.cpp:916
virtual void EmitWinCFIStartChained(SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:661
Context object for machine code objects.
Definition: MCContext.h:62
Expected< unsigned > getDwarfFile(StringRef Directory, StringRef FileName, unsigned FileNumber, Optional< MD5::MD5Result > Checksum, Optional< StringRef > Source, unsigned CUID)
Creates an entry in the dwarf file and directory tables.
Definition: MCContext.cpp:601
virtual bool EmitCVFileDirective(unsigned FileNo, StringRef Filename, ArrayRef< uint8_t > Checksum, unsigned ChecksumKind)
Associate a filename with a specified logical file number, and also specify that file&#39;s checksum info...
Definition: MCStreamer.cpp:268
static WinEH::Instruction PushNonVol(MCSymbol *L, unsigned Reg)
Definition: MCWin64EH.h:26
bool hasEnded() const
Definition: MCSection.cpp:34
static const MCBinaryExpr * createSub(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:544
virtual void finish()
Definition: MCStreamer.cpp:50
const MCExpr * getRHS() const
Get the right-hand side expression of the binary operator.
Definition: MCExpr.h:565
virtual void EmitCFIEndProcImpl(MCDwarfFrameInfo &CurFrame)
Definition: MCStreamer.cpp:405
ArrayRef< MCDwarfFrameInfo > getDwarfFrameInfos() const
Definition: MCStreamer.cpp:111
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
virtual void EmitTPRel64Value(const MCExpr *Value)
Emit the expression Value into the output as a tprel (64-bit TP relative) value.
Definition: MCStreamer.cpp:182
virtual void emitRawComment(const Twine &T, bool TabPrefix=true)
Print T and prefix it with the comment string (normally #) and optionally a tab.
Definition: MCStreamer.cpp:115
virtual void EmitBinaryData(StringRef Data)
Functionally identical to EmitBytes.
const MCExpr * getExpr() const
Definition: MCInst.h:95
virtual void EmitCFIRestoreState()
Definition: MCStreamer.cpp:505
virtual void EmitIntValue(uint64_t Value, unsigned Size)
Special case of EmitValue that avoids the client having to pass in a MCExpr for constant integers...
Definition: MCStreamer.cpp:128
Expected< const typename ELFT::Sym * > getSymbol(typename ELFT::SymRange Symbols, uint32_t Index)
Definition: ELF.h:334
void EmitValue(const MCExpr *Value, unsigned Size, SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:159
Unary expressions.
Definition: MCExpr.h:41
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:158
virtual void EmitCFIRestore(int64_t Register)
Definition: MCStreamer.cpp:525
const char * getData8bitsDirective() const
Definition: MCAsmInfo.h:413
Flag
These should be considered private to the implementation of the MCInstrDesc class.
Definition: MCInstrDesc.h:117
This class is intended to be used as a base class for asm properties and features specific to the tar...
Definition: MCAsmInfo.h:55
virtual void EmitBundleLock(bool AlignToEnd)
The following instructions are a bundle-locked group.
virtual void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size, unsigned ByteAlignment)
Emit a local common (.lcomm) symbol.
static MCCFIInstruction createSameValue(MCSymbol *L, unsigned Register)
.cfi_same_value Current value of Register is the same as in the previous frame.
Definition: MCDwarf.h:549
virtual raw_ostream & GetCommentOS()
Return a raw_ostream that comments can be written to.
Definition: MCStreamer.cpp:105
void EmitZeros(uint64_t NumBytes)
Emit NumBytes worth of zeros.
Definition: MCStreamer.cpp:205
static MCCFIInstruction createNegateRAState(MCSymbol *L)
.cfi_negate_ra_state AArch64 negate RA state.
Definition: MCDwarf.h:530
Streaming machine code generation interface.
Definition: MCStreamer.h:188
virtual void EmitWinCFIFuncletOrFuncEnd(SMLoc Loc=SMLoc())
This is used on platforms, such as Windows on ARM64, that require function or funclet sizes to be emi...
Definition: MCStreamer.cpp:650
MCSymbol * createTempSymbol(bool CanBeUnnamed=true)
Create and return a new assembler temporary symbol with a unique but unspecified name.
Definition: MCContext.cpp:220
void print(raw_ostream &OS, const MCAsmInfo *MAI, bool InParens=false) const
Definition: MCExpr.cpp:41
const FrameInfo * ChainedParent
Definition: MCWinEH.h:45
MCTargetStreamer * getTargetStreamer()
Definition: MCStreamer.h:257
static MCCFIInstruction createDefCfa(MCSymbol *L, unsigned Register, int Offset)
.cfi_def_cfa defines a rule for computing CFA as: take address from Register and add Offset to it...
Definition: MCDwarf.h:477
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
virtual void EmitCVLinetableDirective(unsigned FunctionId, const MCSymbol *FnStart, const MCSymbol *FnEnd)
This implements the CodeView &#39;.cv_linetable&#39; assembler directive.
Definition: MCStreamer.cpp:320
.tvos_version_min
Definition: MCDirectives.h:67
static MCCFIInstruction createDefCfaRegister(MCSymbol *L, unsigned Register)
.cfi_def_cfa_register modifies a rule for computing CFA.
Definition: MCDwarf.h:484
static MCCFIInstruction createWindowSave(MCSymbol *L)
.cfi_window_save SPARC register window is saved.
Definition: MCDwarf.h:525
virtual void SwitchSection(MCSection *Section, const MCExpr *Subsection=nullptr)
Set the current section where code is being emitted to Section.
static MCCFIInstruction createGnuArgsSize(MCSymbol *L, int Size)
A special wrapper for .cfi_escape that indicates GNU_ARGS_SIZE.
Definition: MCDwarf.h:570
static WinEH::Instruction PushMachFrame(MCSymbol *L, bool Code)
Definition: MCWin64EH.h:33
MCSection * getAssociatedPDataSection(const MCSection *TextSec)
Get the .pdata section used for the given section.
Definition: MCStreamer.cpp:752
virtual void EmitSyntaxDirective()
Definition: MCStreamer.cpp:764
virtual void EmitCFIDefCfaRegister(int64_t Register)
Definition: MCStreamer.cpp:448
virtual void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value=0, unsigned ValueSize=1, unsigned MaxBytesToEmit=0)
Emit some number of copies of Value until the byte alignment ByteAlignment is reached.
void getWatchOSVersion(unsigned &Major, unsigned &Minor, unsigned &Micro) const
getWatchOSVersion - Parse the version number as with getOSVersion.
Definition: Triple.cpp:1125
const MCObjectFileInfo * getObjectFileInfo() const
Definition: MCContext.h:296
void reportError(SMLoc L, const Twine &Msg)
Definition: MCContext.cpp:641
static MCCFIInstruction createRelOffset(MCSymbol *L, unsigned Register, int Offset)
.cfi_rel_offset Previous value of Register is saved at offset Offset from the current CFA register...
Definition: MCDwarf.h:512
bool isExpr() const
Definition: MCInst.h:60
static MCCFIInstruction createRestore(MCSymbol *L, unsigned Register)
.cfi_restore says that the rule for Register is now the same as it was at the beginning of the functi...
Definition: MCDwarf.h:537
virtual void EmitRawTextImpl(StringRef String)
EmitRawText - If this file is backed by an assembly streamer, this dumps the specified string in the ...
Definition: MCStreamer.cpp:885
virtual void EmitWinEHHandlerData(SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:705
unsigned getNumOperands() const
Definition: MCInst.h:181
unsigned size() const
Definition: DenseMap.h:125
virtual void EmitCFIUndefined(int64_t Register)
Definition: MCStreamer.cpp:561
virtual void EmitCFINegateRAState()
Definition: MCStreamer.cpp:591
unsigned PersonalityEncoding
Definition: MCDwarf.h:612
bool isOSBinFormatMachO() const
Tests whether the environment is MachO.
Definition: Triple.h:624
static WinEH::Instruction SetFPReg(MCSymbol *L, unsigned Reg, unsigned Off)
Definition: MCWin64EH.h:48
void Finish()
Finish emission of machine code.
Definition: MCStreamer.cpp:902
virtual void EmitEHSymAttributes(const MCSymbol *Symbol, MCSymbol *EHSymbol)
Definition: MCStreamer.cpp:334
virtual void EmitWinCFIEndChained(SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:674
bool isIntN(unsigned N, int64_t x)
Checks if an signed integer fits into the given (dynamic) bit width.
Definition: MathExtras.h:397
static MCCFIInstruction createRestoreState(MCSymbol *L)
.cfi_restore_state Restore the previously saved state.
Definition: MCDwarf.h:559
Binary assembler expressions.
Definition: MCExpr.h:415
virtual void emitDwarfFile0Directive(StringRef Directory, StringRef Filename, Optional< MD5::MD5Result > Checksum, Optional< StringRef > Source, unsigned CUID=0)
Specify the "root" file of the compilation, using the ".file 0" extension.
Definition: MCStreamer.cpp:219
virtual void PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T, raw_ostream &OS, const MCExpr *Subsection) const =0
unsigned getOSMajorVersion() const
getOSMajorVersion - Return just the major version number, this is specialized because it is a common ...
Definition: Triple.h:333
virtual void EmitCOFFSafeSEH(MCSymbol const *Symbol)
Definition: MCStreamer.cpp:872
virtual void EmitWinCFISetFrame(unsigned Register, unsigned Offset, SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:777
void generateCompactUnwindEncodings(MCAsmBackend *MAB)
Definition: MCStreamer.cpp:120
MCCVFunctionInfo * getCVFunctionInfo(unsigned FuncId)
Retreive the function info if this is a valid function id, or nullptr.
Definition: MCCodeView.cpp:78
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:43
static MCSection * getWinCFISection(MCContext &Context, unsigned *NextWinCFIID, MCSection *MainCFISec, const MCSection *TextSec)
Definition: MCStreamer.cpp:717
virtual void EmitWinCFIPushFrame(bool Code, SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:848
const std::vector< MCCFIInstruction > & getInitialFrameState() const
Definition: MCAsmInfo.h:602
static WinEH::Instruction SaveXMM(MCSymbol *L, unsigned Reg, unsigned Offset)
Definition: MCWin64EH.h:42
virtual void EmitTPRel32Value(const MCExpr *Value)
Emit the expression Value into the output as a tprel (32-bit TP relative) value.
Definition: MCStreamer.cpp:186
const MCSymbol * PrologEnd
Definition: MCWinEH.h:37
virtual void InitSections(bool NoExecStack)
Create the default sections and set the initial one.
Definition: MCStreamer.cpp:338
virtual void EmitCFIReturnColumn(int64_t Register)
Definition: MCStreamer.cpp:600
std::pair< MCSection *, const MCExpr * > MCSectionSubPair
Definition: MCStreamer.h:56
BlockVerifier::State From
bool getMacOSXVersion(unsigned &Major, unsigned &Minor, unsigned &Micro) const
getMacOSXVersion - Parse the version number as with getOSVersion and then translate generic "darwin" ...
Definition: Triple.cpp:1058
virtual void emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo, unsigned Size)
Emit the absolute difference between two symbols.
Definition: MCStreamer.cpp:967
virtual void EmitCOFFSymbolIndex(MCSymbol const *Symbol)
Emits the symbol table index of a Symbol into the current section.
Definition: MCStreamer.cpp:874
unsigned encodeULEB128(uint64_t Value, raw_ostream &OS, unsigned PadTo=0)
Utility function to encode a ULEB128 value to an output stream.
Definition: LEB128.h:80
ExprKind getKind() const
Definition: MCExpr.h:72
virtual void EmitCFIOffset(int64_t Register, int64_t Offset)
Definition: MCStreamer.cpp:459
bool isUndefined(bool SetUsed=true) const
isUndefined - Check if this symbol undefined (i.e., implicitly defined).
Definition: MCSymbol.h:256
MCFragment * getFragment(bool SetUsed=true) const
Definition: MCSymbol.h:383
unsigned encodeSLEB128(int64_t Value, raw_ostream &OS, unsigned PadTo=0)
Utility function to encode a SLEB128 value to an output stream.
Definition: LEB128.h:23
const MCSection * TextSection
Definition: MCWinEH.h:39
virtual void EmitWinCFIEndProlog(SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:862
static WinEH::Instruction Alloc(MCSymbol *L, unsigned Size)
Definition: MCWin64EH.h:29
virtual void EmitCodeAlignment(unsigned ByteAlignment, unsigned MaxBytesToEmit=0)
Emit nops until the byte alignment ByteAlignment is reached.
const MCOperand & getOperand(unsigned i) const
Definition: MCInst.h:179
virtual void EmitWinCFIAllocStack(unsigned Size, SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:799
virtual void EmitVersionMin(MCVersionMinType Type, unsigned Major, unsigned Minor, unsigned Update, VersionTuple SDKVersion)
Specify the Mach-O minimum deployment target version.
Definition: MCStreamer.h:452
MCStreamer & Streamer
Definition: MCStreamer.h:85
Promote Memory to Register
Definition: Mem2Reg.cpp:109
virtual void EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId, unsigned SourceFileId, unsigned SourceLineNum, const MCSymbol *FnStartSym, const MCSymbol *FnEndSym)
This implements the CodeView &#39;.cv_inline_linetable&#39; assembler directive.
Definition: MCStreamer.cpp:324
MCSymbol * getBeginSymbol()
Definition: MCSection.h:109
const Triple & getTargetTriple() const
virtual void prettyPrintAsm(MCInstPrinter &InstPrinter, raw_ostream &OS, const MCInst &Inst, const MCSubtargetInfo &STI)
Definition: MCStreamer.cpp:925
StringRef str()
Return a StringRef for the vector contents.
Definition: raw_ostream.h:534
void EmitULEB128IntValue(uint64_t Value, unsigned PadTo=0)
Special case of EmitULEB128Value that avoids the client having to pass in a MCExpr for constant integ...
Definition: MCStreamer.cpp:143
virtual void ChangeSection(MCSection *, const MCExpr *)
Update streamer for a new active section.
void setVariableValue(const MCExpr *Value)
Definition: MCSymbol.cpp:48
bool hasUnfinishedDwarfFrameInfo()
Definition: MCStreamer.cpp:254
virtual void changeSection(const MCSection *CurSection, MCSection *Section, const MCExpr *SubSection, raw_ostream &OS)
Update streamer for a new active section.
Definition: MCStreamer.cpp:52
const MCSymbol * Function
Definition: MCWinEH.h:36
Target - Wrapper for Target specific information.
MCSection * getCurrentSectionOnly() const
Definition: MCStreamer.h:343
void visitUsedExpr(const MCExpr &Expr)
Definition: MCStreamer.cpp:934
bool checkCVLocSection(unsigned FuncId, unsigned FileNo, SMLoc Loc)
Returns true if the the .cv_loc directive is in the right section.
Definition: MCStreamer.cpp:298
MCTargetStreamer(MCStreamer &S)
Definition: MCStreamer.cpp:41
virtual MCSymbol * EmitCFILabel()
When emitting an object file, create and emit a real label.
Definition: MCStreamer.cpp:411
bool recordFunctionId(unsigned FuncId)
Records the function id of a normal function.
Definition: MCCodeView.cpp:86
This is an instance of a target assembly language printer that converts an MCInst to valid target ass...
Definition: MCInstPrinter.h:39
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:26
virtual void EmitThumbFunc(MCSymbol *Func)
Note in the output that the specified Func is a Thumb mode function (ARM target only).
Definition: MCStreamer.cpp:997
const MCSymbol * FuncletOrFuncEnd
Definition: MCWinEH.h:34
virtual void EmitWinCFISaveReg(unsigned Register, unsigned Offset, SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:816
virtual void EmitCFISignalFrame()
Definition: MCStreamer.cpp:554
MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
Definition: MCContext.cpp:123
virtual void EmitCFIRelOffset(int64_t Register, int64_t Offset)
Definition: MCStreamer.cpp:469
const MCSymbol * Personality
Definition: MCDwarf.h:608
MCAssemblerFlag
Definition: MCDirectives.h:48
bool recordInlinedCallSiteId(unsigned FuncId, unsigned IAFunc, unsigned IAFile, unsigned IALine, unsigned IACol)
Records the function id of an inlined call site.
Definition: MCCodeView.cpp:99
bool hasCOFFAssociativeComdats() const
Definition: MCAsmInfo.h:474
virtual void EmitFileDirective(StringRef Filename)
Switch to a new logical file.
virtual void EmitDTPRel32Value(const MCExpr *Value)
Emit the expression Value into the output as a dtprel (32-bit DTP relative) value.
Definition: MCStreamer.cpp:178
Generic base class for all target subtargets.
virtual void emitELFSize(MCSymbol *Symbol, const MCExpr *Value)
Emit an ELF .size directive.
References to labels and assigned expressions.
Definition: MCExpr.h:40
uint32_t Size
Definition: Profile.cpp:46
bool isLittleEndian() const
True if the target is little endian.
Definition: MCAsmInfo.h:404
void emitFill(uint64_t NumBytes, uint8_t FillValue)
Emit NumBytes bytes worth of the value specified by FillValue.
Definition: MCStreamer.cpp:200
virtual void EmitCFIDefCfa(int64_t Register, int64_t Offset)
Definition: MCStreamer.cpp:417
MCSymbol * endSection(MCSection *Section)
void setCurrentDwarfLoc(unsigned FileNum, unsigned Line, unsigned Column, unsigned Flags, unsigned Isa, unsigned Discriminator)
Saves the information from the currently parsed dwarf .loc directive and sets DwarfLocSeen.
Definition: MCContext.h:573
CodeViewContext & getCVContext()
Definition: MCContext.cpp:631
WinEH::FrameInfo * EnsureValidWinFrameInfo(SMLoc Loc)
Retreive the current frame info if one is available and it is not yet closed.
Definition: MCStreamer.cpp:607
virtual void emitRawBytes(StringRef Data)
Emit the bytes in Data into the output.
Definition: MCStreamer.cpp:74
MCSymbol * getLabel() const
Definition: MCDwarf.h:343
MCSection * getTextSection() const
virtual void EmitCOFFSecRel32(MCSymbol const *Symbol, uint64_t Offset)
Emits a COFF section relative relocation.
Definition: MCStreamer.cpp:878
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
virtual void FinishImpl()
Streamer specific finalization.
void setMCLineTableRootFile(unsigned CUID, StringRef CompilationDir, StringRef Filename, Optional< MD5::MD5Result > Checksum, Optional< StringRef > Source)
Specifies the "root" file and directory of the compilation unit.
Definition: MCContext.h:556
virtual bool EmitCVInlineSiteIdDirective(unsigned FunctionId, unsigned IAFunc, unsigned IAFile, unsigned IALine, unsigned IACol, SMLoc Loc)
Introduces an inline call site id for use with .cv_loc.
Definition: MCStreamer.cpp:279
bool isTvOS() const
Is this an Apple tvOS triple.
Definition: Triple.h:462
MCVersionMinType
Definition: MCDirectives.h:64
LLVM Value Representation.
Definition: Value.h:72
Generic interface to target specific assembler backends.
Definition: MCAsmBackend.h:41
static cl::opt< bool, true > Debug("debug", cl::desc("Enable debug output"), cl::Hidden, cl::location(DebugFlag))
Constant expressions.
Definition: MCExpr.h:39
Binary expressions.
Definition: MCExpr.h:38
virtual bool EmitCVFuncIdDirective(unsigned FunctionId)
Introduces a function id for use with .cv_loc.
Definition: MCStreamer.cpp:275
raw_ostream & nulls()
This returns a reference to a raw_ostream which simply discards output.
virtual void EmitCFIBKeyFrame()
Definition: MCStreamer.cpp:228
virtual void EmitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc())
Emit a label for Symbol into the current section.
Definition: MCStreamer.cpp:351
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
virtual void emitCGProfileEntry(const MCSymbolRefExpr *From, const MCSymbolRefExpr *To, uint64_t Count)
Definition: MCStreamer.cpp:713
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
Target specific expression.
Definition: MCExpr.h:42
Information describing a function or inlined call site introduced by .cv_func_id or ...
Definition: MCCodeView.h:91
virtual void visitUsedSymbol(const MCSymbol &Sym)
Definition: MCStreamer.cpp:931
virtual void emitDwarfFileDirective(StringRef Directive)
Definition: MCStreamer.cpp:62
Represents a location in source code.
Definition: SMLoc.h:23
static MCCFIInstruction createEscape(MCSymbol *L, StringRef Vals)
.cfi_escape Allows the user to add arbitrary bytes to the unwind info.
Definition: MCDwarf.h:565
bool isUIntN(unsigned N, uint64_t x)
Checks if an unsigned integer fits into the given (dynamic) bit width.
Definition: MathExtras.h:392
const MCSymbol * ExceptionHandler
Definition: MCWinEH.h:35
void EmitVersionForTarget(const Triple &Target, const VersionTuple &SDKVersion)
void setTargetStreamer(MCTargetStreamer *TS)
Definition: MCStreamer.h:242
virtual void emitAssignment(MCSymbol *Symbol, const MCExpr *Value)
Definition: MCStreamer.cpp:86
virtual void EmitCOFFSectionIndex(MCSymbol const *Symbol)
Emits a COFF section index.
Definition: MCStreamer.cpp:876
static const MCConstantExpr * create(int64_t Value, MCContext &Ctx)
Definition: MCExpr.cpp:163
virtual void EmitCFIAdjustCfaOffset(int64_t Adjustment)
Definition: MCStreamer.cpp:438
void setLabel(MCSymbol *Label)
Definition: MCDwarf.h:347
static MCCFIInstruction createRegister(MCSymbol *L, unsigned Register1, unsigned Register2)
.cfi_register Previous value of Register1 is saved in register Register2.
Definition: MCDwarf.h:519
virtual void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue)
Set the DescValue for the Symbol.
Definition: MCStreamer.cpp:998
void EmitCFIStartProc(bool IsSimple, SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:373
virtual void EmitCFIWindowSave()
Definition: MCStreamer.cpp:581
MCSection * getAssociatedXDataSection(const MCSection *TextSec)
Get the .xdata section used for the given section.
Definition: MCStreamer.cpp:758
Holds state from .cv_file and .cv_loc directives for later emission.
Definition: MCCodeView.h:137