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

Generated by: LCOV version 1.13