LCOV - code coverage report
Current view: top level - lib/MC - MCObjectStreamer.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 314 335 93.7 %
Date: 2018-02-19 03:08:00 Functions: 56 62 90.3 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- lib/MC/MCObjectStreamer.cpp - Object File MCStreamer Interface -----===//
       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/MCObjectStreamer.h"
      11             : #include "llvm/ADT/STLExtras.h"
      12             : #include "llvm/MC/MCAsmBackend.h"
      13             : #include "llvm/MC/MCAssembler.h"
      14             : #include "llvm/MC/MCCodeEmitter.h"
      15             : #include "llvm/MC/MCCodeView.h"
      16             : #include "llvm/MC/MCContext.h"
      17             : #include "llvm/MC/MCDwarf.h"
      18             : #include "llvm/MC/MCExpr.h"
      19             : #include "llvm/MC/MCObjectWriter.h"
      20             : #include "llvm/MC/MCSection.h"
      21             : #include "llvm/MC/MCSymbol.h"
      22             : #include "llvm/Support/ErrorHandling.h"
      23             : #include "llvm/Support/SourceMgr.h"
      24             : using namespace llvm;
      25             : 
      26        7010 : MCObjectStreamer::MCObjectStreamer(MCContext &Context,
      27             :                                    std::unique_ptr<MCAsmBackend> TAB,
      28             :                                    raw_pwrite_stream &OS,
      29        7010 :                                    std::unique_ptr<MCCodeEmitter> Emitter)
      30        7010 :     : MCStreamer(Context), ObjectWriter(TAB->createObjectWriter(OS)),
      31             :       TAB(std::move(TAB)), Emitter(std::move(Emitter)),
      32             :       Assembler(llvm::make_unique<MCAssembler>(Context, *this->TAB,
      33             :                                                *this->Emitter, *ObjectWriter)),
      34       28040 :       EmitEHFrame(true), EmitDebugFrame(false) {}
      35             : 
      36       20946 : MCObjectStreamer::~MCObjectStreamer() {}
      37             : 
      38    17618811 : void MCObjectStreamer::flushPendingLabels(MCFragment *F, uint64_t FOffset) {
      39    17618811 :   if (PendingLabels.empty())
      40             :     return;
      41      218854 :   if (!F) {
      42        4628 :     F = new MCDataFragment();
      43             :     MCSection *CurSection = getCurrentSectionOnly();
      44             :     CurSection->getFragmentList().insert(CurInsertionPoint, F);
      45             :     F->setParent(CurSection);
      46             :   }
      47     1046464 :   for (MCSymbol *Sym : PendingLabels) {
      48             :     Sym->setFragment(F);
      49             :     Sym->setOffset(FOffset);
      50             :   }
      51             :   PendingLabels.clear();
      52             : }
      53             : 
      54             : // As a compile-time optimization, avoid allocating and evaluating an MCExpr
      55             : // tree for (Hi - Lo) when Hi and Lo are offsets into the same fragment.
      56      196488 : static Optional<uint64_t> absoluteSymbolDiff(const MCSymbol *Hi,
      57             :                                              const MCSymbol *Lo) {
      58      497546 :   if (!Hi->getFragment() || Hi->getFragment() != Lo->getFragment() ||
      59      316285 :       Hi->isVariable() || Lo->isVariable())
      60             :     return None;
      61             : 
      62      119780 :   return Hi->getOffset() - Lo->getOffset();
      63             : }
      64             : 
      65       88823 : void MCObjectStreamer::emitAbsoluteSymbolDiff(const MCSymbol *Hi,
      66             :                                               const MCSymbol *Lo,
      67             :                                               unsigned Size) {
      68       88823 :   if (Optional<uint64_t> Diff = absoluteSymbolDiff(Hi, Lo)) {
      69       68549 :     EmitIntValue(*Diff, Size);
      70             :     return;
      71             :   }
      72       20274 :   MCStreamer::emitAbsoluteSymbolDiff(Hi, Lo, Size);
      73             : }
      74             : 
      75      107665 : void MCObjectStreamer::emitAbsoluteSymbolDiffAsULEB128(const MCSymbol *Hi,
      76             :                                                        const MCSymbol *Lo) {
      77      107665 :   if (Optional<uint64_t> Diff = absoluteSymbolDiff(Hi, Lo)) {
      78       51231 :     EmitULEB128IntValue(*Diff);
      79             :     return;
      80             :   }
      81       56434 :   MCStreamer::emitAbsoluteSymbolDiffAsULEB128(Hi, Lo);
      82             : }
      83             : 
      84        3965 : void MCObjectStreamer::reset() {
      85        3965 :   if (Assembler)
      86        3965 :     Assembler->reset();
      87        3965 :   CurInsertionPoint = MCSection::iterator();
      88        3965 :   EmitEHFrame = true;
      89        3965 :   EmitDebugFrame = false;
      90             :   PendingLabels.clear();
      91        3965 :   MCStreamer::reset();
      92        3965 : }
      93             : 
      94        6911 : void MCObjectStreamer::EmitFrames(MCAsmBackend *MAB) {
      95        6911 :   if (!getNumFrameInfos())
      96             :     return;
      97             : 
      98        3037 :   if (EmitEHFrame)
      99        2941 :     MCDwarfFrameEmitter::Emit(*this, MAB, true);
     100             : 
     101        3037 :   if (EmitDebugFrame)
     102          96 :     MCDwarfFrameEmitter::Emit(*this, MAB, false);
     103             : }
     104             : 
     105    23648862 : MCFragment *MCObjectStreamer::getCurrentFragment() const {
     106             :   assert(getCurrentSectionOnly() && "No current section!");
     107             : 
     108    23648862 :   if (CurInsertionPoint != getCurrentSectionOnly()->getFragmentList().begin())
     109             :     return &*std::prev(CurInsertionPoint);
     110             : 
     111             :   return nullptr;
     112             : }
     113             : 
     114    18553986 : MCDataFragment *MCObjectStreamer::getOrCreateDataFragment() {
     115    18553986 :   MCDataFragment *F = dyn_cast_or_null<MCDataFragment>(getCurrentFragment());
     116             :   // When bundling is enabled, we don't want to add data to a fragment that
     117             :   // already has instructions (see MCELFStreamer::EmitInstToData for details)
     118    18231062 :   if (!F || (Assembler->isBundlingEnabled() && !Assembler->getRelaxAll() &&
     119        3391 :              F->hasInstructions())) {
     120      329843 :     F = new MCDataFragment();
     121      329843 :     insert(F);
     122             :   }
     123    18553986 :   return F;
     124             : }
     125             : 
     126           0 : MCPaddingFragment *MCObjectStreamer::getOrCreatePaddingFragment() {
     127             :   MCPaddingFragment *F =
     128           0 :       dyn_cast_or_null<MCPaddingFragment>(getCurrentFragment());
     129             :   if (!F) {
     130           0 :     F = new MCPaddingFragment();
     131           0 :     insert(F);
     132             :   }
     133           0 :   return F;
     134             : }
     135             : 
     136     2715987 : void MCObjectStreamer::visitUsedSymbol(const MCSymbol &Sym) {
     137     2715987 :   Assembler->registerSymbol(Sym);
     138     2715987 : }
     139             : 
     140          96 : void MCObjectStreamer::EmitCFISections(bool EH, bool Debug) {
     141          96 :   MCStreamer::EmitCFISections(EH, Debug);
     142          96 :   EmitEHFrame = EH;
     143          96 :   EmitDebugFrame = Debug;
     144          96 : }
     145             : 
     146     1604949 : void MCObjectStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size,
     147             :                                      SMLoc Loc) {
     148     1604949 :   MCStreamer::EmitValueImpl(Value, Size, Loc);
     149     1604949 :   MCDataFragment *DF = getOrCreateDataFragment();
     150     1604949 :   flushPendingLabels(DF, DF->getContents().size());
     151             : 
     152     1604949 :   MCCVLineEntry::Make(this);
     153     1604949 :   MCDwarfLineEntry::Make(this, getCurrentSectionOnly());
     154             : 
     155             :   // Avoid fixups when possible.
     156             :   int64_t AbsValue;
     157     1604949 :   if (Value->evaluateAsAbsolute(AbsValue, getAssembler())) {
     158       40912 :     if (!isUIntN(8 * Size, AbsValue) && !isIntN(8 * Size, AbsValue)) {
     159           2 :       getContext().reportError(
     160           1 :           Loc, "value evaluated as " + Twine(AbsValue) + " is out of range.");
     161       40913 :       return;
     162             :     }
     163       40911 :     EmitIntValue(AbsValue, Size);
     164       40911 :     return;
     165             :   }
     166     3128074 :   DF->getFixups().push_back(
     167     1564037 :       MCFixup::create(DF->getContents().size(), Value,
     168     1564037 :                       MCFixup::getKindForSize(Size, false), Loc));
     169     3128074 :   DF->getContents().resize(DF->getContents().size() + Size, 0);
     170             : }
     171             : 
     172      293884 : MCSymbol *MCObjectStreamer::EmitCFILabel() {
     173      587768 :   MCSymbol *Label = getContext().createTempSymbol("cfi", true);
     174      293884 :   EmitLabel(Label);
     175      293884 :   return Label;
     176             : }
     177             : 
     178       41928 : void MCObjectStreamer::EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) {
     179             :   // We need to create a local symbol to avoid relocations.
     180       41928 :   Frame.Begin = getContext().createTempSymbol();
     181       41928 :   EmitLabel(Frame.Begin);
     182       41928 : }
     183             : 
     184       41928 : void MCObjectStreamer::EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) {
     185       41928 :   Frame.End = getContext().createTempSymbol();
     186       41928 :   EmitLabel(Frame.End);
     187       41928 : }
     188             : 
     189     2754230 : void MCObjectStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) {
     190     2754230 :   MCStreamer::EmitLabel(Symbol, Loc);
     191             : 
     192     2754230 :   getAssembler().registerSymbol(*Symbol);
     193             : 
     194             :   // If there is a current fragment, mark the symbol as pointing into it.
     195             :   // Otherwise queue the label and set its fragment pointer when we emit the
     196             :   // next fragment.
     197     2754230 :   auto *F = dyn_cast_or_null<MCDataFragment>(getCurrentFragment());
     198     2340459 :   if (F && !(getAssembler().isBundlingEnabled() &&
     199             :              getAssembler().getRelaxAll())) {
     200     2340418 :     Symbol->setFragment(F);
     201             :     Symbol->setOffset(F->getContents().size());
     202             :   } else {
     203      413812 :     PendingLabels.push_back(Symbol);
     204             :   }
     205     2754230 : }
     206             : 
     207          10 : void MCObjectStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc, MCFragment *F) {
     208          10 :   MCStreamer::EmitLabel(Symbol, Loc);
     209          10 :   getAssembler().registerSymbol(*Symbol);
     210             :   auto *DF = dyn_cast_or_null<MCDataFragment>(F);
     211             :   if (DF)
     212          10 :     Symbol->setFragment(F);
     213             :   else
     214           0 :     PendingLabels.push_back(Symbol);
     215          10 : }
     216             : 
     217       56646 : void MCObjectStreamer::EmitULEB128Value(const MCExpr *Value) {
     218             :   int64_t IntValue;
     219       56646 :   if (Value->evaluateAsAbsolute(IntValue, getAssembler())) {
     220         207 :     EmitULEB128IntValue(IntValue);
     221         207 :     return;
     222             :   }
     223       56439 :   insert(new MCLEBFragment(*Value, false));
     224             : }
     225             : 
     226          57 : void MCObjectStreamer::EmitSLEB128Value(const MCExpr *Value) {
     227             :   int64_t IntValue;
     228          57 :   if (Value->evaluateAsAbsolute(IntValue, getAssembler())) {
     229          55 :     EmitSLEB128IntValue(IntValue);
     230          55 :     return;
     231             :   }
     232           2 :   insert(new MCLEBFragment(*Value, true));
     233             : }
     234             : 
     235           0 : void MCObjectStreamer::EmitWeakReference(MCSymbol *Alias,
     236             :                                          const MCSymbol *Symbol) {
     237           0 :   report_fatal_error("This file format doesn't support weak aliases.");
     238             : }
     239             : 
     240        2485 : void MCObjectStreamer::ChangeSection(MCSection *Section,
     241             :                                      const MCExpr *Subsection) {
     242        2485 :   changeSectionImpl(Section, Subsection);
     243        2485 : }
     244             : 
     245      535114 : bool MCObjectStreamer::changeSectionImpl(MCSection *Section,
     246             :                                          const MCExpr *Subsection) {
     247             :   assert(Section && "Cannot switch to a null section!");
     248      535114 :   flushPendingLabels(nullptr);
     249      535114 :   getContext().clearDwarfLocSeen();
     250             : 
     251      535114 :   bool Created = getAssembler().registerSection(*Section);
     252             : 
     253      535114 :   int64_t IntSubsection = 0;
     254      535120 :   if (Subsection &&
     255           6 :       !Subsection->evaluateAsAbsolute(IntSubsection, getAssembler()))
     256           0 :     report_fatal_error("Cannot evaluate subsection number");
     257      535114 :   if (IntSubsection < 0 || IntSubsection > 8192)
     258           0 :     report_fatal_error("Subsection number out of range");
     259      535114 :   CurInsertionPoint =
     260      535114 :       Section->getSubsectionInsertionPoint(unsigned(IntSubsection));
     261      535114 :   return Created;
     262             : }
     263             : 
     264        3853 : void MCObjectStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
     265        3853 :   getAssembler().registerSymbol(*Symbol);
     266        3853 :   MCStreamer::EmitAssignment(Symbol, Value);
     267        3853 : }
     268             : 
     269          30 : bool MCObjectStreamer::mayHaveInstructions(MCSection &Sec) const {
     270          30 :   return Sec.hasInstructions();
     271             : }
     272             : 
     273     2256184 : void MCObjectStreamer::EmitInstruction(const MCInst &Inst,
     274             :                                        const MCSubtargetInfo &STI, bool) {
     275     2256184 :   getAssembler().getBackend().handleCodePaddingInstructionBegin(Inst);
     276     2256183 :   EmitInstructionImpl(Inst, STI);
     277     2256184 :   getAssembler().getBackend().handleCodePaddingInstructionEnd(Inst);
     278     2256184 : }
     279             : 
     280     2256183 : void MCObjectStreamer::EmitInstructionImpl(const MCInst &Inst,
     281             :                                            const MCSubtargetInfo &STI) {
     282     2256183 :   MCStreamer::EmitInstruction(Inst, STI);
     283             : 
     284             :   MCSection *Sec = getCurrentSectionOnly();
     285             :   Sec->setHasInstructions(true);
     286             : 
     287             :   // Now that a machine instruction has been assembled into this section, make
     288             :   // a line entry for any .loc directive that has been seen.
     289     2256183 :   MCCVLineEntry::Make(this);
     290     2256184 :   MCDwarfLineEntry::Make(this, getCurrentSectionOnly());
     291             : 
     292             :   // If this instruction doesn't need relaxation, just emit it as data.
     293             :   MCAssembler &Assembler = getAssembler();
     294     2256184 :   if (!Assembler.getBackend().mayNeedRelaxation(Inst)) {
     295     2158118 :     EmitInstToData(Inst, STI);
     296     2158118 :     return;
     297             :   }
     298             : 
     299             :   // Otherwise, relax and emit it as data if either:
     300             :   // - The RelaxAll flag was passed
     301             :   // - Bundling is enabled and this instruction is inside a bundle-locked
     302             :   //   group. We want to emit all such instructions into the same data
     303             :   //   fragment.
     304      158249 :   if (Assembler.getRelaxAll() ||
     305       60188 :       (Assembler.isBundlingEnabled() && Sec->isBundleLocked())) {
     306             :     MCInst Relaxed;
     307       37885 :     getAssembler().getBackend().relaxInstruction(Inst, STI, Relaxed);
     308       37885 :     while (getAssembler().getBackend().mayNeedRelaxation(Relaxed))
     309           0 :       getAssembler().getBackend().relaxInstruction(Relaxed, STI, Relaxed);
     310       37885 :     EmitInstToData(Relaxed, STI);
     311             :     return;
     312             :   }
     313             : 
     314             :   // Otherwise emit to a separate fragment.
     315       60181 :   EmitInstToFragment(Inst, STI);
     316             : }
     317             : 
     318       60181 : void MCObjectStreamer::EmitInstToFragment(const MCInst &Inst,
     319             :                                           const MCSubtargetInfo &STI) {
     320       60181 :   if (getAssembler().getRelaxAll() && getAssembler().isBundlingEnabled())
     321           0 :     llvm_unreachable("All instructions should have already been relaxed");
     322             : 
     323             :   // Always create a new, separate fragment here, because its size can change
     324             :   // during relaxation.
     325       60181 :   MCRelaxableFragment *IF = new MCRelaxableFragment(Inst, STI);
     326       60181 :   insert(IF);
     327             : 
     328             :   SmallString<128> Code;
     329             :   raw_svector_ostream VecOS(Code);
     330      120362 :   getAssembler().getEmitter().encodeInstruction(Inst, VecOS, IF->getFixups(),
     331       60181 :                                                 STI);
     332       60181 :   IF->getContents().append(Code.begin(), Code.end());
     333       60181 : }
     334             : 
     335             : #ifndef NDEBUG
     336             : static const char *const BundlingNotImplementedMsg =
     337             :   "Aligned bundling is not implemented for this object format";
     338             : #endif
     339             : 
     340           0 : void MCObjectStreamer::EmitBundleAlignMode(unsigned AlignPow2) {
     341           0 :   llvm_unreachable(BundlingNotImplementedMsg);
     342             : }
     343             : 
     344           0 : void MCObjectStreamer::EmitBundleLock(bool AlignToEnd) {
     345           0 :   llvm_unreachable(BundlingNotImplementedMsg);
     346             : }
     347             : 
     348           0 : void MCObjectStreamer::EmitBundleUnlock() {
     349           0 :   llvm_unreachable(BundlingNotImplementedMsg);
     350             : }
     351             : 
     352      700099 : void MCObjectStreamer::EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
     353             :                                              unsigned Column, unsigned Flags,
     354             :                                              unsigned Isa,
     355             :                                              unsigned Discriminator,
     356             :                                              StringRef FileName) {
     357             :   // In case we see two .loc directives in a row, make sure the
     358             :   // first one gets a line entry.
     359      700099 :   MCDwarfLineEntry::Make(this, getCurrentSectionOnly());
     360             : 
     361      700099 :   this->MCStreamer::EmitDwarfLocDirective(FileNo, Line, Column, Flags,
     362             :                                           Isa, Discriminator, FileName);
     363      700099 : }
     364             : 
     365      993541 : static const MCExpr *buildSymbolDiff(MCObjectStreamer &OS, const MCSymbol *A,
     366             :                                      const MCSymbol *B) {
     367      993541 :   MCContext &Context = OS.getContext();
     368             :   MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None;
     369      993541 :   const MCExpr *ARef = MCSymbolRefExpr::create(A, Variant, Context);
     370      993541 :   const MCExpr *BRef = MCSymbolRefExpr::create(B, Variant, Context);
     371             :   const MCExpr *AddrDelta =
     372      993541 :       MCBinaryExpr::create(MCBinaryExpr::Sub, ARef, BRef, Context);
     373      993541 :   return AddrDelta;
     374             : }
     375             : 
     376       36427 : static void emitDwarfSetLineAddr(MCObjectStreamer &OS,
     377             :                                  MCDwarfLineTableParams Params,
     378             :                                  int64_t LineDelta, const MCSymbol *Label,
     379             :                                  int PointerSize) {
     380             :   // emit the sequence to set the address
     381       36427 :   OS.EmitIntValue(dwarf::DW_LNS_extended_op, 1);
     382       36427 :   OS.EmitULEB128IntValue(PointerSize + 1);
     383       36427 :   OS.EmitIntValue(dwarf::DW_LNE_set_address, 1);
     384       36427 :   OS.EmitSymbolValue(Label, PointerSize);
     385             : 
     386             :   // emit the sequence for the LineDelta (from 1) and a zero address delta.
     387       36427 :   MCDwarfLineAddr::Emit(&OS, Params, LineDelta, 0);
     388       36427 : }
     389             : 
     390      736525 : void MCObjectStreamer::EmitDwarfAdvanceLineAddr(int64_t LineDelta,
     391             :                                                 const MCSymbol *LastLabel,
     392             :                                                 const MCSymbol *Label,
     393             :                                                 unsigned PointerSize) {
     394      736525 :   if (!LastLabel) {
     395       72854 :     emitDwarfSetLineAddr(*this, Assembler->getDWARFLinetableParams(), LineDelta,
     396             :                          Label, PointerSize);
     397       36427 :     return;
     398             :   }
     399      700098 :   const MCExpr *AddrDelta = buildSymbolDiff(*this, Label, LastLabel);
     400             :   int64_t Res;
     401      700098 :   if (AddrDelta->evaluateAsAbsolute(Res, getAssembler())) {
     402     1284338 :     MCDwarfLineAddr::Emit(this, Assembler->getDWARFLinetableParams(), LineDelta,
     403             :                           Res);
     404      642169 :     return;
     405             :   }
     406       57929 :   insert(new MCDwarfLineAddrFragment(LineDelta, *AddrDelta));
     407             : }
     408             : 
     409      293443 : void MCObjectStreamer::EmitDwarfAdvanceFrameAddr(const MCSymbol *LastLabel,
     410             :                                                  const MCSymbol *Label) {
     411      293443 :   const MCExpr *AddrDelta = buildSymbolDiff(*this, Label, LastLabel);
     412             :   int64_t Res;
     413      293443 :   if (AddrDelta->evaluateAsAbsolute(Res, getAssembler())) {
     414      290868 :     MCDwarfFrameEmitter::EmitAdvanceLoc(*this, Res);
     415      290868 :     return;
     416             :   }
     417        2575 :   insert(new MCDwarfCallFrameFragment(*AddrDelta));
     418             : }
     419             : 
     420         393 : void MCObjectStreamer::EmitCVLocDirective(unsigned FunctionId, unsigned FileNo,
     421             :                                           unsigned Line, unsigned Column,
     422             :                                           bool PrologueEnd, bool IsStmt,
     423             :                                           StringRef FileName, SMLoc Loc) {
     424             :   // In case we see two .cv_loc directives in a row, make sure the
     425             :   // first one gets a line entry.
     426         393 :   MCCVLineEntry::Make(this);
     427             : 
     428         393 :   this->MCStreamer::EmitCVLocDirective(FunctionId, FileNo, Line, Column,
     429             :                                        PrologueEnd, IsStmt, FileName, Loc);
     430         393 : }
     431             : 
     432         108 : void MCObjectStreamer::EmitCVLinetableDirective(unsigned FunctionId,
     433             :                                                 const MCSymbol *Begin,
     434             :                                                 const MCSymbol *End) {
     435         108 :   getContext().getCVContext().emitLineTableForFunction(*this, FunctionId, Begin,
     436             :                                                        End);
     437         108 :   this->MCStreamer::EmitCVLinetableDirective(FunctionId, Begin, End);
     438         108 : }
     439             : 
     440          22 : void MCObjectStreamer::EmitCVInlineLinetableDirective(
     441             :     unsigned PrimaryFunctionId, unsigned SourceFileId, unsigned SourceLineNum,
     442             :     const MCSymbol *FnStartSym, const MCSymbol *FnEndSym) {
     443          22 :   getContext().getCVContext().emitInlineLineTableForFunction(
     444             :       *this, PrimaryFunctionId, SourceFileId, SourceLineNum, FnStartSym,
     445             :       FnEndSym);
     446          22 :   this->MCStreamer::EmitCVInlineLinetableDirective(
     447             :       PrimaryFunctionId, SourceFileId, SourceLineNum, FnStartSym, FnEndSym);
     448          22 : }
     449             : 
     450         137 : void MCObjectStreamer::EmitCVDefRangeDirective(
     451             :     ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
     452             :     StringRef FixedSizePortion) {
     453         137 :   getContext().getCVContext().emitDefRange(*this, Ranges, FixedSizePortion);
     454         137 :   this->MCStreamer::EmitCVDefRangeDirective(Ranges, FixedSizePortion);
     455         137 : }
     456             : 
     457          75 : void MCObjectStreamer::EmitCVStringTableDirective() {
     458          75 :   getContext().getCVContext().emitStringTable(*this);
     459          75 : }
     460          73 : void MCObjectStreamer::EmitCVFileChecksumsDirective() {
     461          73 :   getContext().getCVContext().emitFileChecksums(*this);
     462          73 : }
     463             : 
     464         129 : void MCObjectStreamer::EmitCVFileChecksumOffsetDirective(unsigned FileNo) {
     465         129 :   getContext().getCVContext().emitFileChecksumOffset(*this, FileNo);
     466         129 : }
     467             : 
     468    14722317 : void MCObjectStreamer::EmitBytes(StringRef Data) {
     469    14722317 :   MCCVLineEntry::Make(this);
     470    14722317 :   MCDwarfLineEntry::Make(this, getCurrentSectionOnly());
     471    14722317 :   MCDataFragment *DF = getOrCreateDataFragment();
     472    14722317 :   flushPendingLabels(DF, DF->getContents().size());
     473    14722317 :   DF->getContents().append(Data.begin(), Data.end());
     474    14722317 : }
     475             : 
     476      174556 : void MCObjectStreamer::EmitValueToAlignment(unsigned ByteAlignment,
     477             :                                             int64_t Value,
     478             :                                             unsigned ValueSize,
     479             :                                             unsigned MaxBytesToEmit) {
     480      174556 :   if (MaxBytesToEmit == 0)
     481             :     MaxBytesToEmit = ByteAlignment;
     482      349112 :   insert(new MCAlignFragment(ByteAlignment, Value, ValueSize, MaxBytesToEmit));
     483             : 
     484             :   // Update the maximum alignment on the current section if necessary.
     485             :   MCSection *CurSec = getCurrentSectionOnly();
     486      174556 :   if (ByteAlignment > CurSec->getAlignment())
     487             :     CurSec->setAlignment(ByteAlignment);
     488      174556 : }
     489             : 
     490       55813 : void MCObjectStreamer::EmitCodeAlignment(unsigned ByteAlignment,
     491             :                                          unsigned MaxBytesToEmit) {
     492       55813 :   EmitValueToAlignment(ByteAlignment, 0, 1, MaxBytesToEmit);
     493       55813 :   cast<MCAlignFragment>(getCurrentFragment())->setEmitNops(true);
     494       55813 : }
     495             : 
     496          19 : void MCObjectStreamer::emitValueToOffset(const MCExpr *Offset,
     497             :                                          unsigned char Value,
     498             :                                          SMLoc Loc) {
     499          38 :   insert(new MCOrgFragment(*Offset, Value, Loc));
     500          19 : }
     501             : 
     502      209509 : void MCObjectStreamer::EmitCodePaddingBasicBlockStart(
     503             :     const MCCodePaddingContext &Context) {
     504      209509 :   getAssembler().getBackend().handleCodePaddingBasicBlockStart(this, Context);
     505      209509 : }
     506             : 
     507      209509 : void MCObjectStreamer::EmitCodePaddingBasicBlockEnd(
     508             :     const MCCodePaddingContext &Context) {
     509      209509 :   getAssembler().getBackend().handleCodePaddingBasicBlockEnd(Context);
     510      209509 : }
     511             : 
     512             : // Associate DTPRel32 fixup with data and resize data area
     513           4 : void MCObjectStreamer::EmitDTPRel32Value(const MCExpr *Value) {
     514           4 :   MCDataFragment *DF = getOrCreateDataFragment();
     515           4 :   flushPendingLabels(DF, DF->getContents().size());
     516             : 
     517           8 :   DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
     518           4 :                                             Value, FK_DTPRel_4));
     519           8 :   DF->getContents().resize(DF->getContents().size() + 4, 0);
     520           4 : }
     521             : 
     522             : // Associate DTPRel64 fixup with data and resize data area
     523           4 : void MCObjectStreamer::EmitDTPRel64Value(const MCExpr *Value) {
     524           4 :   MCDataFragment *DF = getOrCreateDataFragment();
     525           4 :   flushPendingLabels(DF, DF->getContents().size());
     526             : 
     527           8 :   DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
     528           4 :                                             Value, FK_DTPRel_8));
     529           8 :   DF->getContents().resize(DF->getContents().size() + 8, 0);
     530           4 : }
     531             : 
     532             : // Associate TPRel32 fixup with data and resize data area
     533           3 : void MCObjectStreamer::EmitTPRel32Value(const MCExpr *Value) {
     534           3 :   MCDataFragment *DF = getOrCreateDataFragment();
     535           3 :   flushPendingLabels(DF, DF->getContents().size());
     536             : 
     537           6 :   DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
     538           3 :                                             Value, FK_TPRel_4));
     539           6 :   DF->getContents().resize(DF->getContents().size() + 4, 0);
     540           3 : }
     541             : 
     542             : // Associate TPRel64 fixup with data and resize data area
     543           3 : void MCObjectStreamer::EmitTPRel64Value(const MCExpr *Value) {
     544           3 :   MCDataFragment *DF = getOrCreateDataFragment();
     545           3 :   flushPendingLabels(DF, DF->getContents().size());
     546             : 
     547           6 :   DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
     548           3 :                                             Value, FK_TPRel_8));
     549           6 :   DF->getContents().resize(DF->getContents().size() + 8, 0);
     550           3 : }
     551             : 
     552             : // Associate GPRel32 fixup with data and resize data area
     553          11 : void MCObjectStreamer::EmitGPRel32Value(const MCExpr *Value) {
     554          11 :   MCDataFragment *DF = getOrCreateDataFragment();
     555          11 :   flushPendingLabels(DF, DF->getContents().size());
     556             : 
     557          22 :   DF->getFixups().push_back(
     558          22 :       MCFixup::create(DF->getContents().size(), Value, FK_GPRel_4));
     559          22 :   DF->getContents().resize(DF->getContents().size() + 4, 0);
     560          11 : }
     561             : 
     562             : // Associate GPRel64 fixup with data and resize data area
     563          13 : void MCObjectStreamer::EmitGPRel64Value(const MCExpr *Value) {
     564          13 :   MCDataFragment *DF = getOrCreateDataFragment();
     565          13 :   flushPendingLabels(DF, DF->getContents().size());
     566             : 
     567          26 :   DF->getFixups().push_back(
     568          26 :       MCFixup::create(DF->getContents().size(), Value, FK_GPRel_4));
     569          26 :   DF->getContents().resize(DF->getContents().size() + 8, 0);
     570          13 : }
     571             : 
     572          22 : bool MCObjectStreamer::EmitRelocDirective(const MCExpr &Offset, StringRef Name,
     573             :                                           const MCExpr *Expr, SMLoc Loc) {
     574             :   int64_t OffsetValue;
     575          22 :   if (!Offset.evaluateAsAbsolute(OffsetValue))
     576           0 :     llvm_unreachable("Offset is not absolute");
     577             : 
     578          22 :   if (OffsetValue < 0)
     579           0 :     llvm_unreachable("Offset is negative");
     580             : 
     581          22 :   MCDataFragment *DF = getOrCreateDataFragment();
     582          22 :   flushPendingLabels(DF, DF->getContents().size());
     583             : 
     584          22 :   Optional<MCFixupKind> MaybeKind = Assembler->getBackend().getFixupKind(Name);
     585          22 :   if (!MaybeKind.hasValue())
     586             :     return true;
     587             : 
     588          22 :   MCFixupKind Kind = *MaybeKind;
     589             : 
     590          22 :   if (Expr == nullptr)
     591             :     Expr =
     592           3 :         MCSymbolRefExpr::create(getContext().createTempSymbol(), getContext());
     593          44 :   DF->getFixups().push_back(MCFixup::create(OffsetValue, Expr, Kind, Loc));
     594          22 :   return false;
     595             : }
     596             : 
     597       32936 : void MCObjectStreamer::emitFill(const MCExpr &NumBytes, uint64_t FillValue,
     598             :                                 SMLoc Loc) {
     599       32936 :   MCDataFragment *DF = getOrCreateDataFragment();
     600       32936 :   flushPendingLabels(DF, DF->getContents().size());
     601             : 
     602             :   assert(getCurrentSectionOnly() && "need a section");
     603       65872 :   insert(new MCFillFragment(FillValue, NumBytes, Loc));
     604       32936 : }
     605             : 
     606         527 : void MCObjectStreamer::emitFill(const MCExpr &NumValues, int64_t Size,
     607             :                                 int64_t Expr, SMLoc Loc) {
     608             :   int64_t IntNumValues;
     609         527 :   if (!NumValues.evaluateAsAbsolute(IntNumValues, getAssembler())) {
     610           0 :     getContext().reportError(Loc, "expected absolute expression");
     611           2 :     return;
     612             :   }
     613             : 
     614         527 :   if (IntNumValues < 0) {
     615           4 :     getContext().getSourceManager()->PrintMessage(
     616             :         Loc, SourceMgr::DK_Warning,
     617             :         "'.fill' directive with negative repeat count has no effect");
     618           2 :     return;
     619             :   }
     620             : 
     621         525 :   int64_t NonZeroSize = Size > 4 ? 4 : Size;
     622         525 :   Expr &= ~0ULL >> (64 - NonZeroSize * 8);
     623      695153 :   for (uint64_t i = 0, e = IntNumValues; i != e; ++i) {
     624      694628 :     EmitIntValue(Expr, NonZeroSize);
     625      694628 :     if (NonZeroSize < Size)
     626           7 :       EmitIntValue(0, Size - NonZeroSize);
     627             :   }
     628             : }
     629             : 
     630        3486 : void MCObjectStreamer::EmitFileDirective(StringRef Filename) {
     631        3486 :   getAssembler().addFileName(Filename);
     632        3486 : }
     633             : 
     634        6911 : void MCObjectStreamer::FinishImpl() {
     635             :   // If we are generating dwarf for assembly source files dump out the sections.
     636        6911 :   if (getContext().getGenDwarfForAssembly())
     637          23 :     MCGenDwarfInfo::Emit(this);
     638             : 
     639             :   // Dump out the dwarf file & directory tables and line tables.
     640        6911 :   MCDwarfLineTable::Emit(this, getAssembler().getDWARFLinetableParams());
     641             : 
     642        6911 :   flushPendingLabels(nullptr);
     643        6911 :   getAssembler().Finish();
     644        6895 : }

Generated by: LCOV version 1.13