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