LCOV - code coverage report
Current view: top level - include/llvm/MC - MCSection.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 21 21 100.0 %
Date: 2017-09-14 15:23:50 Functions: 1 1 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- MCSection.h - Machine Code Sections ----------------------*- C++ -*-===//
       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             : // This file declares the MCSection class.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #ifndef LLVM_MC_MCSECTION_H
      15             : #define LLVM_MC_MCSECTION_H
      16             : 
      17             : #include "llvm/ADT/SmallVector.h"
      18             : #include "llvm/ADT/ilist.h"
      19             : #include "llvm/MC/MCFragment.h"
      20             : #include "llvm/MC/SectionKind.h"
      21             : #include <cassert>
      22             : #include <utility>
      23             : 
      24             : namespace llvm {
      25             : 
      26             : class MCAsmInfo;
      27             : class MCContext;
      28             : class MCExpr;
      29             : class MCSymbol;
      30             : class raw_ostream;
      31             : class Triple;
      32             : 
      33             : template <> struct ilist_alloc_traits<MCFragment> {
      34             :   static void deleteNode(MCFragment *V);
      35             : };
      36             : 
      37             : /// Instances of this class represent a uniqued identifier for a section in the
      38             : /// current translation unit.  The MCContext class uniques and creates these.
      39     5629190 : class MCSection {
      40             : public:
      41             :   enum SectionVariant { SV_COFF = 0, SV_ELF, SV_MachO, SV_Wasm };
      42             : 
      43             :   /// \brief Express the state of bundle locked groups while emitting code.
      44             :   enum BundleLockStateType {
      45             :     NotBundleLocked,
      46             :     BundleLocked,
      47             :     BundleLockedAlignToEnd
      48             :   };
      49             : 
      50             :   using FragmentListType = iplist<MCFragment>;
      51             : 
      52             :   using const_iterator = FragmentListType::const_iterator;
      53             :   using iterator = FragmentListType::iterator;
      54             : 
      55             :   using const_reverse_iterator = FragmentListType::const_reverse_iterator;
      56             :   using reverse_iterator = FragmentListType::reverse_iterator;
      57             : 
      58             : private:
      59             :   MCSymbol *Begin;
      60             :   MCSymbol *End = nullptr;
      61             :   /// The alignment requirement of this section.
      62             :   unsigned Alignment = 1;
      63             :   /// The section index in the assemblers section list.
      64             :   unsigned Ordinal = 0;
      65             :   /// The index of this section in the layout order.
      66             :   unsigned LayoutOrder;
      67             : 
      68             :   /// \brief Keeping track of bundle-locked state.
      69             :   BundleLockStateType BundleLockState = NotBundleLocked;
      70             : 
      71             :   /// \brief Current nesting depth of bundle_lock directives.
      72             :   unsigned BundleLockNestingDepth = 0;
      73             : 
      74             :   /// \brief We've seen a bundle_lock directive but not its first instruction
      75             :   /// yet.
      76             :   bool BundleGroupBeforeFirstInst : 1;
      77             : 
      78             :   /// Whether this section has had instructions emitted into it.
      79             :   bool HasInstructions : 1;
      80             : 
      81             :   bool IsRegistered : 1;
      82             : 
      83             :   MCDummyFragment DummyFragment;
      84             : 
      85             :   FragmentListType Fragments;
      86             : 
      87             :   /// Mapping from subsection number to insertion point for subsection numbers
      88             :   /// below that number.
      89             :   SmallVector<std::pair<unsigned, MCFragment *>, 1> SubsectionFragmentMap;
      90             : 
      91             : protected:
      92             :   SectionVariant Variant;
      93             :   SectionKind Kind;
      94             : 
      95             :   MCSection(SectionVariant V, SectionKind K, MCSymbol *Begin);
      96             :   ~MCSection();
      97             : 
      98             : public:
      99             :   MCSection(const MCSection &) = delete;
     100             :   MCSection &operator=(const MCSection &) = delete;
     101             : 
     102             :   SectionKind getKind() const { return Kind; }
     103             : 
     104             :   SectionVariant getVariant() const { return Variant; }
     105             : 
     106             :   MCSymbol *getBeginSymbol() { return Begin; }
     107             :   const MCSymbol *getBeginSymbol() const {
     108     1112263 :     return const_cast<MCSection *>(this)->getBeginSymbol();
     109             :   }
     110             :   void setBeginSymbol(MCSymbol *Sym) {
     111             :     assert(!Begin);
     112          76 :     Begin = Sym;
     113             :   }
     114             :   MCSymbol *getEndSymbol(MCContext &Ctx);
     115             :   bool hasEnded() const;
     116             : 
     117             :   unsigned getAlignment() const { return Alignment; }
     118       64566 :   void setAlignment(unsigned Value) { Alignment = Value; }
     119             : 
     120             :   unsigned getOrdinal() const { return Ordinal; }
     121      377026 :   void setOrdinal(unsigned Value) { Ordinal = Value; }
     122             : 
     123             :   unsigned getLayoutOrder() const { return LayoutOrder; }
     124      377026 :   void setLayoutOrder(unsigned Value) { LayoutOrder = Value; }
     125             : 
     126             :   BundleLockStateType getBundleLockState() const { return BundleLockState; }
     127             :   void setBundleLockState(BundleLockStateType NewState);
     128     1161987 :   bool isBundleLocked() const { return BundleLockState != NotBundleLocked; }
     129             : 
     130             :   bool isBundleGroupBeforeFirstInst() const {
     131        5055 :     return BundleGroupBeforeFirstInst;
     132             :   }
     133             :   void setBundleGroupBeforeFirstInst(bool IsFirst) {
     134        5221 :     BundleGroupBeforeFirstInst = IsFirst;
     135             :   }
     136             : 
     137        2725 :   bool hasInstructions() const { return HasInstructions; }
     138     1480043 :   void setHasInstructions(bool Value) { HasInstructions = Value; }
     139             : 
     140      398522 :   bool isRegistered() const { return IsRegistered; }
     141      377148 :   void setIsRegistered(bool Value) { IsRegistered = Value; }
     142             : 
     143         186 :   MCSection::FragmentListType &getFragmentList() { return Fragments; }
     144             :   const MCSection::FragmentListType &getFragmentList() const {
     145       43053 :     return const_cast<MCSection *>(this)->getFragmentList();
     146             :   }
     147             : 
     148             :   /// Support for MCFragment::getNextNode().
     149             :   static FragmentListType MCSection::*getSublistAccess(MCFragment *) {
     150             :     return &MCSection::Fragments;
     151             :   }
     152             : 
     153             :   const MCDummyFragment &getDummyFragment() const { return DummyFragment; }
     154     1617555 :   MCDummyFragment &getDummyFragment() { return DummyFragment; }
     155             : 
     156     5568270 :   iterator begin() { return Fragments.begin(); }
     157      753814 :   const_iterator begin() const { return Fragments.begin(); }
     158             : 
     159     3138360 :   iterator end() { return Fragments.end(); }
     160      753814 :   const_iterator end() const { return Fragments.end(); }
     161             : 
     162     1508098 :   reverse_iterator rbegin() { return Fragments.rbegin(); }
     163             :   const_reverse_iterator rbegin() const { return Fragments.rbegin(); }
     164             : 
     165             :   reverse_iterator rend() { return Fragments.rend(); }
     166             :   const_reverse_iterator rend() const  { return Fragments.rend(); }
     167             : 
     168             :   MCSection::iterator getSubsectionInsertionPoint(unsigned Subsection);
     169             : 
     170             :   void dump() const;
     171             : 
     172             :   virtual void PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
     173             :                                     raw_ostream &OS,
     174             :                                     const MCExpr *Subsection) const = 0;
     175             : 
     176             :   /// Return true if a .align directive should use "optimized nops" to fill
     177             :   /// instead of 0s.
     178             :   virtual bool UseCodeAlign() const = 0;
     179             : 
     180             :   /// Check whether this section is "virtual", that is has no actual object
     181             :   /// file contents.
     182             :   virtual bool isVirtualSection() const = 0;
     183             : };
     184             : 
     185             : } // end namespace llvm
     186             : 
     187             : #endif // LLVM_MC_MCSECTION_H

Generated by: LCOV version 1.13