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