LCOV - code coverage report
Current view: top level - lib/MC - MCFragment.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 131 142 92.3 %
Date: 2017-09-14 15:23:50 Functions: 16 17 94.1 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- lib/MC/MCFragment.cpp - Assembler Fragment Implementation ----------===//
       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/MCFragment.h"
      11             : #include "llvm/ADT/SmallVector.h"
      12             : #include "llvm/ADT/StringExtras.h"
      13             : #include "llvm/ADT/Twine.h"
      14             : #include "llvm/MC/MCAsmLayout.h"
      15             : #include "llvm/MC/MCAssembler.h"
      16             : #include "llvm/MC/MCContext.h"
      17             : #include "llvm/MC/MCExpr.h"
      18             : #include "llvm/MC/MCFixup.h"
      19             : #include "llvm/MC/MCSection.h"
      20             : #include "llvm/MC/MCSymbol.h"
      21             : #include "llvm/MC/MCValue.h"
      22             : #include "llvm/Support/Casting.h"
      23             : #include "llvm/Support/Compiler.h"
      24             : #include "llvm/Support/ErrorHandling.h"
      25             : #include "llvm/Support/raw_ostream.h"
      26             : #include <cassert>
      27             : #include <cstdint>
      28             : #include <utility>
      29             : 
      30             : using namespace llvm;
      31             : 
      32       12301 : MCAsmLayout::MCAsmLayout(MCAssembler &Asm) : Assembler(Asm) {
      33             :   // Compute the section layout order. Virtual sections must go last.
      34      770456 :   for (MCSection &Sec : Asm)
      35      377026 :     if (!Sec.isVirtualSection())
      36      354838 :       SectionOrder.push_back(&Sec);
      37      770456 :   for (MCSection &Sec : Asm)
      38      377026 :     if (Sec.isVirtualSection())
      39       22188 :       SectionOrder.push_back(&Sec);
      40        4101 : }
      41             : 
      42     6345913 : bool MCAsmLayout::isFragmentValid(const MCFragment *F) const {
      43     6345913 :   const MCSection *Sec = F->getParent();
      44    12691828 :   const MCFragment *LastValid = LastValidFragment.lookup(Sec);
      45     6345657 :   if (!LastValid)
      46             :     return false;
      47             :   assert(LastValid->getParent() == Sec);
      48     5968631 :   return F->getLayoutOrder() <= LastValid->getLayoutOrder();
      49             : }
      50             : 
      51        3068 : void MCAsmLayout::invalidateFragmentsFrom(MCFragment *F) {
      52             :   // If this fragment wasn't already valid, we don't need to do anything.
      53        3068 :   if (!isFragmentValid(F))
      54             :     return;
      55             : 
      56             :   // Otherwise, reset the last valid fragment to the previous fragment
      57             :   // (if this is the first fragment, it will be NULL).
      58        8421 :   LastValidFragment[F->getParent()] = F->getPrevNode();
      59             : }
      60             : 
      61     5487567 : void MCAsmLayout::ensureValid(const MCFragment *F) const {
      62     5487567 :   MCSection *Sec = F->getParent();
      63     5487567 :   MCSection::iterator I;
      64    10975136 :   if (MCFragment *Cur = LastValidFragment[Sec])
      65    10221086 :     I = ++MCSection::iterator(Cur);
      66             :   else
      67      377026 :     I = Sec->begin();
      68             : 
      69             :   // Advance the layout position until the fragment is valid.
      70     6342847 :   while (!isFragmentValid(F)) {
      71             :     assert(I != Sec->end() && "Layout bookkeeping error");
      72      855279 :     const_cast<MCAsmLayout *>(this)->layoutFragment(&*I);
      73             :     ++I;
      74             :   }
      75     5487568 : }
      76             : 
      77     5487568 : uint64_t MCAsmLayout::getFragmentOffset(const MCFragment *F) const {
      78     5487568 :   ensureValid(F);
      79             :   assert(F->Offset != ~UINT64_C(0) && "Address not set!");
      80     5487568 :   return F->Offset;
      81             : }
      82             : 
      83             : // Simple getSymbolOffset helper for the non-varibale case.
      84     3087565 : static bool getLabelOffset(const MCAsmLayout &Layout, const MCSymbol &S,
      85             :                            bool ReportError, uint64_t &Val) {
      86     3087565 :   if (!S.getFragment()) {
      87        6360 :     if (ReportError)
      88           2 :       report_fatal_error("unable to evaluate offset to undefined symbol '" +
      89           3 :                          S.getName() + "'");
      90             :     return false;
      91             :   }
      92     3081205 :   Val = Layout.getFragmentOffset(S.getFragment()) + S.getOffset();
      93     3081206 :   return true;
      94             : }
      95             : 
      96     3087552 : static bool getSymbolOffsetImpl(const MCAsmLayout &Layout, const MCSymbol &S,
      97             :                                 bool ReportError, uint64_t &Val) {
      98     3087552 :   if (!S.isVariable())
      99     3086686 :     return getLabelOffset(Layout, S, ReportError, Val);
     100             : 
     101             :   // If SD is a variable, evaluate it.
     102         866 :   MCValue Target;
     103         866 :   if (!S.getVariableValue()->evaluateAsValue(Target, Layout))
     104           0 :     report_fatal_error("unable to evaluate offset for variable '" +
     105           0 :                        S.getName() + "'");
     106             : 
     107         866 :   uint64_t Offset = Target.getConstant();
     108             : 
     109         866 :   const MCSymbolRefExpr *A = Target.getSymA();
     110         866 :   if (A) {
     111             :     uint64_t ValA;
     112         637 :     if (!getLabelOffset(Layout, A->getSymbol(), ReportError, ValA))
     113          10 :       return false;
     114         627 :     Offset += ValA;
     115             :   }
     116             : 
     117         856 :   const MCSymbolRefExpr *B = Target.getSymB();
     118         856 :   if (B) {
     119             :     uint64_t ValB;
     120         243 :     if (!getLabelOffset(Layout, B->getSymbol(), ReportError, ValB))
     121           0 :       return false;
     122         242 :     Offset -= ValB;
     123             :   }
     124             : 
     125         855 :   Val = Offset;
     126         855 :   return true;
     127             : }
     128             : 
     129      116843 : bool MCAsmLayout::getSymbolOffset(const MCSymbol &S, uint64_t &Val) const {
     130      116843 :   return getSymbolOffsetImpl(*this, S, false, Val);
     131             : }
     132             : 
     133     2970709 : uint64_t MCAsmLayout::getSymbolOffset(const MCSymbol &S) const {
     134             :   uint64_t Val;
     135     2970709 :   getSymbolOffsetImpl(*this, S, true, Val);
     136     2970708 :   return Val;
     137             : }
     138             : 
     139      117038 : const MCSymbol *MCAsmLayout::getBaseSymbol(const MCSymbol &Symbol) const {
     140      117038 :   if (!Symbol.isVariable())
     141             :     return &Symbol;
     142             : 
     143         503 :   const MCExpr *Expr = Symbol.getVariableValue();
     144         503 :   MCValue Value;
     145         503 :   if (!Expr->evaluateAsValue(Value, *this)) {
     146           6 :     Assembler.getContext().reportError(
     147             :         Expr->getLoc(), "expression could not be evaluated");
     148           3 :     return nullptr;
     149             :   }
     150             : 
     151         500 :   const MCSymbolRefExpr *RefB = Value.getSymB();
     152         500 :   if (RefB) {
     153           4 :     Assembler.getContext().reportError(
     154          14 :         Expr->getLoc(), Twine("symbol '") + RefB->getSymbol().getName() +
     155           4 :                      "' could not be evaluated in a subtraction expression");
     156           2 :     return nullptr;
     157             :   }
     158             : 
     159         498 :   const MCSymbolRefExpr *A = Value.getSymA();
     160         498 :   if (!A)
     161             :     return nullptr;
     162             : 
     163         271 :   const MCSymbol &ASym = A->getSymbol();
     164         271 :   const MCAssembler &Asm = getAssembler();
     165         271 :   if (ASym.isCommon()) {
     166           8 :     Asm.getContext().reportError(Expr->getLoc(),
     167          16 :                                  "Common symbol '" + ASym.getName() +
     168           8 :                                      "' cannot be used in assignment expr");
     169           4 :     return nullptr;
     170             :   }
     171             : 
     172             :   return &ASym;
     173             : }
     174             : 
     175       43053 : uint64_t MCAsmLayout::getSectionAddressSize(const MCSection *Sec) const {
     176             :   // The size is the last fragment's end offset.
     177       86106 :   const MCFragment &F = Sec->getFragmentList().back();
     178       43053 :   return getFragmentOffset(&F) + getAssembler().computeFragmentSize(*this, F);
     179             : }
     180             : 
     181        3004 : uint64_t MCAsmLayout::getSectionFileSize(const MCSection *Sec) const {
     182             :   // Virtual sections have no file size.
     183        3004 :   if (Sec->isVirtualSection())
     184             :     return 0;
     185             : 
     186             :   // Otherwise, the file size is the same as the address space size.
     187        2968 :   return getSectionAddressSize(Sec);
     188             : }
     189             : 
     190         879 : uint64_t llvm::computeBundlePadding(const MCAssembler &Assembler,
     191             :                                     const MCFragment *F,
     192             :                                     uint64_t FOffset, uint64_t FSize) {
     193         879 :   uint64_t BundleSize = Assembler.getBundleAlignSize();
     194             :   assert(BundleSize > 0 &&
     195             :          "computeBundlePadding should only be called if bundling is enabled");
     196         879 :   uint64_t BundleMask = BundleSize - 1;
     197         879 :   uint64_t OffsetInBundle = FOffset & BundleMask;
     198         879 :   uint64_t EndOfFragment = OffsetInBundle + FSize;
     199             : 
     200             :   // There are two kinds of bundling restrictions:
     201             :   //
     202             :   // 1) For alignToBundleEnd(), add padding to ensure that the fragment will
     203             :   //    *end* on a bundle boundary.
     204             :   // 2) Otherwise, check if the fragment would cross a bundle boundary. If it
     205             :   //    would, add padding until the end of the bundle so that the fragment
     206             :   //    will start in a new one.
     207         879 :   if (F->alignToBundleEnd()) {
     208             :     // Three possibilities here:
     209             :     //
     210             :     // A) The fragment just happens to end at a bundle boundary, so we're good.
     211             :     // B) The fragment ends before the current bundle boundary: pad it just
     212             :     //    enough to reach the boundary.
     213             :     // C) The fragment ends after the current bundle boundary: pad it until it
     214             :     //    reaches the end of the next bundle boundary.
     215             :     //
     216             :     // Note: this code could be made shorter with some modulo trickery, but it's
     217             :     // intentionally kept in its more explicit form for simplicity.
     218         287 :     if (EndOfFragment == BundleSize)
     219             :       return 0;
     220         269 :     else if (EndOfFragment < BundleSize)
     221         141 :       return BundleSize - EndOfFragment;
     222             :     else { // EndOfFragment > BundleSize
     223         128 :       return 2 * BundleSize - EndOfFragment;
     224             :     }
     225         592 :   } else if (OffsetInBundle > 0 && EndOfFragment > BundleSize)
     226         161 :     return BundleSize - OffsetInBundle;
     227             :   else
     228             :     return 0;
     229             : }
     230             : 
     231             : /* *** */
     232             : 
     233     1608317 : void ilist_alloc_traits<MCFragment>::deleteNode(MCFragment *V) { V->destroy(); }
     234             : 
     235             : MCFragment::~MCFragment() = default;
     236             : 
     237     3099003 : MCFragment::MCFragment(FragmentType Kind, bool HasInstructions,
     238     3099003 :                        uint8_t BundlePadding, MCSection *Parent)
     239             :     : Kind(Kind), HasInstructions(HasInstructions), AlignToBundleEnd(false),
     240             :       BundlePadding(BundlePadding), Parent(Parent), Atom(nullptr),
     241     6198006 :       Offset(~UINT64_C(0)) {
     242     3099003 :   if (Parent && !isDummy())
     243         386 :     Parent->getFragmentList().push_back(this);
     244     3099003 : }
     245             : 
     246     1608316 : void MCFragment::destroy() {
     247             :   // First check if we are the sentinal.
     248     1608316 :   if (Kind == FragmentType(~0)) {
     249           0 :     delete this;
     250             :     return;
     251             :   }
     252             : 
     253     1608316 :   switch (Kind) {
     254       80765 :     case FT_Align:
     255      161530 :       delete cast<MCAlignFragment>(this);
     256             :       return;
     257     1389970 :     case FT_Data:
     258     2779942 :       delete cast<MCDataFragment>(this);
     259             :       return;
     260         131 :     case FT_CompactEncodedInst:
     261         262 :       delete cast<MCCompactEncodedInstFragment>(this);
     262             :       return;
     263       25920 :     case FT_Fill:
     264       51840 :       delete cast<MCFillFragment>(this);
     265             :       return;
     266       57266 :     case FT_Relaxable:
     267       57266 :       delete cast<MCRelaxableFragment>(this);
     268             :       return;
     269          19 :     case FT_Org:
     270          38 :       delete cast<MCOrgFragment>(this);
     271             :       return;
     272       51766 :     case FT_Dwarf:
     273       51766 :       delete cast<MCDwarfLineAddrFragment>(this);
     274             :       return;
     275        2349 :     case FT_DwarfFrame:
     276        2349 :       delete cast<MCDwarfCallFrameFragment>(this);
     277             :       return;
     278           2 :     case FT_LEB:
     279           2 :       delete cast<MCLEBFragment>(this);
     280             :       return;
     281           1 :     case FT_SafeSEH:
     282           2 :       delete cast<MCSafeSEHFragment>(this);
     283             :       return;
     284          22 :     case FT_CVInlineLines:
     285          22 :       delete cast<MCCVInlineLineTableFragment>(this);
     286             :       return;
     287         106 :     case FT_CVDefRange:
     288         106 :       delete cast<MCCVDefRangeFragment>(this);
     289             :       return;
     290           0 :     case FT_Dummy:
     291           0 :       delete cast<MCDummyFragment>(this);
     292             :       return;
     293             :   }
     294             : }
     295             : 
     296             : // Debugging methods
     297             : 
     298             : namespace llvm {
     299             : 
     300           0 : raw_ostream &operator<<(raw_ostream &OS, const MCFixup &AF) {
     301           0 :   OS << "<MCFixup" << " Offset:" << AF.getOffset()
     302           0 :      << " Value:" << *AF.getValue()
     303           0 :      << " Kind:" << AF.getKind() << ">";
     304           0 :   return OS;
     305             : }
     306             : 
     307             : } // end namespace llvm
     308             : 
     309             : #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
     310             : LLVM_DUMP_METHOD void MCFragment::dump() const {
     311             :   raw_ostream &OS = errs();
     312             : 
     313             :   OS << "<";
     314             :   switch (getKind()) {
     315             :   case MCFragment::FT_Align: OS << "MCAlignFragment"; break;
     316             :   case MCFragment::FT_Data:  OS << "MCDataFragment"; break;
     317             :   case MCFragment::FT_CompactEncodedInst:
     318             :     OS << "MCCompactEncodedInstFragment"; break;
     319             :   case MCFragment::FT_Fill:  OS << "MCFillFragment"; break;
     320             :   case MCFragment::FT_Relaxable:  OS << "MCRelaxableFragment"; break;
     321             :   case MCFragment::FT_Org:   OS << "MCOrgFragment"; break;
     322             :   case MCFragment::FT_Dwarf: OS << "MCDwarfFragment"; break;
     323             :   case MCFragment::FT_DwarfFrame: OS << "MCDwarfCallFrameFragment"; break;
     324             :   case MCFragment::FT_LEB:   OS << "MCLEBFragment"; break;
     325             :   case MCFragment::FT_SafeSEH:    OS << "MCSafeSEHFragment"; break;
     326             :   case MCFragment::FT_CVInlineLines: OS << "MCCVInlineLineTableFragment"; break;
     327             :   case MCFragment::FT_CVDefRange: OS << "MCCVDefRangeTableFragment"; break;
     328             :   case MCFragment::FT_Dummy: OS << "MCDummyFragment"; break;
     329             :   }
     330             : 
     331             :   OS << "<MCFragment " << (const void*) this << " LayoutOrder:" << LayoutOrder
     332             :      << " Offset:" << Offset
     333             :      << " HasInstructions:" << hasInstructions()
     334             :      << " BundlePadding:" << static_cast<unsigned>(getBundlePadding()) << ">";
     335             : 
     336             :   switch (getKind()) {
     337             :   case MCFragment::FT_Align: {
     338             :     const MCAlignFragment *AF = cast<MCAlignFragment>(this);
     339             :     if (AF->hasEmitNops())
     340             :       OS << " (emit nops)";
     341             :     OS << "\n       ";
     342             :     OS << " Alignment:" << AF->getAlignment()
     343             :        << " Value:" << AF->getValue() << " ValueSize:" << AF->getValueSize()
     344             :        << " MaxBytesToEmit:" << AF->getMaxBytesToEmit() << ">";
     345             :     break;
     346             :   }
     347             :   case MCFragment::FT_Data:  {
     348             :     const MCDataFragment *DF = cast<MCDataFragment>(this);
     349             :     OS << "\n       ";
     350             :     OS << " Contents:[";
     351             :     const SmallVectorImpl<char> &Contents = DF->getContents();
     352             :     for (unsigned i = 0, e = Contents.size(); i != e; ++i) {
     353             :       if (i) OS << ",";
     354             :       OS << hexdigit((Contents[i] >> 4) & 0xF) << hexdigit(Contents[i] & 0xF);
     355             :     }
     356             :     OS << "] (" << Contents.size() << " bytes)";
     357             : 
     358             :     if (DF->fixup_begin() != DF->fixup_end()) {
     359             :       OS << ",\n       ";
     360             :       OS << " Fixups:[";
     361             :       for (MCDataFragment::const_fixup_iterator it = DF->fixup_begin(),
     362             :              ie = DF->fixup_end(); it != ie; ++it) {
     363             :         if (it != DF->fixup_begin()) OS << ",\n                ";
     364             :         OS << *it;
     365             :       }
     366             :       OS << "]";
     367             :     }
     368             :     break;
     369             :   }
     370             :   case MCFragment::FT_CompactEncodedInst: {
     371             :     const MCCompactEncodedInstFragment *CEIF =
     372             :       cast<MCCompactEncodedInstFragment>(this);
     373             :     OS << "\n       ";
     374             :     OS << " Contents:[";
     375             :     const SmallVectorImpl<char> &Contents = CEIF->getContents();
     376             :     for (unsigned i = 0, e = Contents.size(); i != e; ++i) {
     377             :       if (i) OS << ",";
     378             :       OS << hexdigit((Contents[i] >> 4) & 0xF) << hexdigit(Contents[i] & 0xF);
     379             :     }
     380             :     OS << "] (" << Contents.size() << " bytes)";
     381             :     break;
     382             :   }
     383             :   case MCFragment::FT_Fill:  {
     384             :     const MCFillFragment *FF = cast<MCFillFragment>(this);
     385             :     OS << " Value:" << static_cast<unsigned>(FF->getValue())
     386             :        << " Size:" << FF->getSize();
     387             :     break;
     388             :   }
     389             :   case MCFragment::FT_Relaxable:  {
     390             :     const MCRelaxableFragment *F = cast<MCRelaxableFragment>(this);
     391             :     OS << "\n       ";
     392             :     OS << " Inst:";
     393             :     F->getInst().dump_pretty(OS);
     394             :     break;
     395             :   }
     396             :   case MCFragment::FT_Org:  {
     397             :     const MCOrgFragment *OF = cast<MCOrgFragment>(this);
     398             :     OS << "\n       ";
     399             :     OS << " Offset:" << OF->getOffset()
     400             :        << " Value:" << static_cast<unsigned>(OF->getValue());
     401             :     break;
     402             :   }
     403             :   case MCFragment::FT_Dwarf:  {
     404             :     const MCDwarfLineAddrFragment *OF = cast<MCDwarfLineAddrFragment>(this);
     405             :     OS << "\n       ";
     406             :     OS << " AddrDelta:" << OF->getAddrDelta()
     407             :        << " LineDelta:" << OF->getLineDelta();
     408             :     break;
     409             :   }
     410             :   case MCFragment::FT_DwarfFrame:  {
     411             :     const MCDwarfCallFrameFragment *CF = cast<MCDwarfCallFrameFragment>(this);
     412             :     OS << "\n       ";
     413             :     OS << " AddrDelta:" << CF->getAddrDelta();
     414             :     break;
     415             :   }
     416             :   case MCFragment::FT_LEB: {
     417             :     const MCLEBFragment *LF = cast<MCLEBFragment>(this);
     418             :     OS << "\n       ";
     419             :     OS << " Value:" << LF->getValue() << " Signed:" << LF->isSigned();
     420             :     break;
     421             :   }
     422             :   case MCFragment::FT_SafeSEH: {
     423             :     const MCSafeSEHFragment *F = cast<MCSafeSEHFragment>(this);
     424             :     OS << "\n       ";
     425             :     OS << " Sym:" << F->getSymbol();
     426             :     break;
     427             :   }
     428             :   case MCFragment::FT_CVInlineLines: {
     429             :     const auto *F = cast<MCCVInlineLineTableFragment>(this);
     430             :     OS << "\n       ";
     431             :     OS << " Sym:" << *F->getFnStartSym();
     432             :     break;
     433             :   }
     434             :   case MCFragment::FT_CVDefRange: {
     435             :     const auto *F = cast<MCCVDefRangeFragment>(this);
     436             :     OS << "\n       ";
     437             :     for (std::pair<const MCSymbol *, const MCSymbol *> RangeStartEnd :
     438             :          F->getRanges()) {
     439             :       OS << " RangeStart:" << RangeStartEnd.first;
     440             :       OS << " RangeEnd:" << RangeStartEnd.second;
     441             :     }
     442             :     break;
     443             :   }
     444             :   case MCFragment::FT_Dummy:
     445             :     break;
     446             :   }
     447             :   OS << ">";
     448             : }
     449             : 
     450             : LLVM_DUMP_METHOD void MCAssembler::dump() const{
     451             :   raw_ostream &OS = errs();
     452             : 
     453             :   OS << "<MCAssembler\n";
     454             :   OS << "  Sections:[\n    ";
     455             :   for (const_iterator it = begin(), ie = end(); it != ie; ++it) {
     456             :     if (it != begin()) OS << ",\n    ";
     457             :     it->dump();
     458             :   }
     459             :   OS << "],\n";
     460             :   OS << "  Symbols:[";
     461             : 
     462             :   for (const_symbol_iterator it = symbol_begin(), ie = symbol_end(); it != ie; ++it) {
     463             :     if (it != symbol_begin()) OS << ",\n           ";
     464             :     OS << "(";
     465             :     it->dump();
     466             :     OS << ", Index:" << it->getIndex() << ", ";
     467             :     OS << ")";
     468             :   }
     469             :   OS << "]>\n";
     470             : }
     471             : #endif

Generated by: LCOV version 1.13