contrib/llvm/lib/MC/MCStreamer.cpp

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