LCOV - code coverage report
Current view: top level - lib/MC - MCStreamer.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 477 557 85.6 %
Date: 2018-09-23 13:06:45 Functions: 103 138 74.6 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13