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