include/llvm/MC/MCAnalysis/MCModule.h

   1 //===-- llvm/MC/MCModule.h - MCModule class ---------------------*- 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 contains the declaration of the MCModule class, which is used to
  11 // represent a complete, disassembled object file or executable.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_MC_MCMODULE_H
  16 #define LLVM_MC_MCMODULE_H
  17
  18 #include "llvm/ADT/StringRef.h"
  19 #include "llvm/Support/Compiler.h"
  20 #include "llvm/Support/DataTypes.h"
  21 #include <memory>
  22 #include <vector>
  23
  24 namespace llvm {
  25
  26 class MCAtom;
  27 class MCBasicBlock;
  28 class MCDataAtom;
  29 class MCFunction;
  30 class MCObjectDisassembler;
  31 class MCTextAtom;
  32
  33 /// \brief A completely disassembled object file or executable.
  34 /// It comprises a list of MCAtom's, each representing a contiguous range of
  35 /// either instructions or data.
  36 /// An MCModule is created using MCObjectDisassembler::buildModule.
  37 class MCModule {
  38   /// \name Atom tracking
  39   /// @{
  40
  41   /// \brief Atoms in this module, sorted by begin address.
  42   /// FIXME: This doesn't handle overlapping atoms (which happen when a basic
  43   /// block starts in the middle of an instruction of another basic block.)
  44   typedef std::vector<MCAtom*> AtomListTy;
  45   AtomListTy Atoms;
  46
  47   // For access to map/remap.
  48   friend class MCAtom;
  49
  50   /// \brief Remap \p Atom to the given range, and update its Begin/End fields.
  51   /// \param Atom An atom belonging to this module.
  52   /// An atom should always use this method to update its bounds, because this
  53   /// enables the owning MCModule to keep track of its atoms.
  54   void remap(MCAtom *Atom, uint64_t NewBegin, uint64_t NewEnd);
  55
  56   /// \brief Insert an atom in the module, using its Begin and End addresses.
  57   void map(MCAtom *NewAtom);
  58   /// @}
  59
  60   /// \name Basic block tracking
  61   /// @{
  62   typedef std::vector<MCBasicBlock*> BBsByAtomTy;
  63   BBsByAtomTy BBsByAtom;
  64
  65   // For access to basic block > atom tracking.
  66   friend class MCBasicBlock;
  67   friend class MCTextAtom;
  68
  69   /// \brief Keep track of \p BBBackedByAtom as being backed by \p Atom.
  70   /// This is used to update succs/preds when \p Atom is split.
  71   void trackBBForAtom(const MCTextAtom *Atom, MCBasicBlock *BBBackedByAtom);
  72   void splitBasicBlocksForAtom(const MCTextAtom *TA, const MCTextAtom *NewTA);
  73   /// @}
  74
  75   /// \name Function tracking
  76   /// @{
  77   typedef std::vector<std::unique_ptr<MCFunction>> FunctionListTy;
  78   FunctionListTy Functions;
  79   /// @}
  80
  81   /// The address of the entrypoint function.
  82   uint64_t Entrypoint;
  83
  84   MCModule           (const MCModule &) LLVM_DELETED_FUNCTION;
  85   MCModule& operator=(const MCModule &) LLVM_DELETED_FUNCTION;
  86
  87   // MCObjectDisassembler creates MCModules.
  88   friend class MCObjectDisassembler;
  89
  90 public:
  91   MCModule();
  92   ~MCModule();
  93
  94   /// \name Create a new MCAtom covering the specified offset range.
  95   /// @{
  96   MCTextAtom *createTextAtom(uint64_t Begin, uint64_t End);
  97   MCDataAtom *createDataAtom(uint64_t Begin, uint64_t End);
  98   /// @}
  99
 100   /// \name Access to the owned atom list, ordered by begin address.
 101   /// @{
 102   const MCAtom *findAtomContaining(uint64_t Addr) const;
 103         MCAtom *findAtomContaining(uint64_t Addr);
 104   const MCAtom *findFirstAtomAfter(uint64_t Addr) const;
 105         MCAtom *findFirstAtomAfter(uint64_t Addr);
 106
 107   typedef AtomListTy::const_iterator const_atom_iterator;
 108   typedef AtomListTy::      iterator       atom_iterator;
 109   const_atom_iterator atom_begin() const { return Atoms.begin(); }
 110         atom_iterator atom_begin()       { return Atoms.begin(); }
 111   const_atom_iterator atom_end()   const { return Atoms.end(); }
 112         atom_iterator atom_end()         { return Atoms.end(); }
 113   /// @}
 114
 115   /// \brief Create a new MCFunction.
 116   MCFunction *createFunction(StringRef Name);
 117
 118   /// \name Access to the owned function list.
 119   /// @{
 120   typedef FunctionListTy::const_iterator const_func_iterator;
 121   typedef FunctionListTy::      iterator       func_iterator;
 122   const_func_iterator func_begin() const { return Functions.begin(); }
 123         func_iterator func_begin()       { return Functions.begin(); }
 124   const_func_iterator func_end()   const { return Functions.end(); }
 125         func_iterator func_end()         { return Functions.end(); }
 126   /// @}
 127
 128   /// \brief Get the address of the entrypoint function, or 0 if there is none.
 129   uint64_t getEntrypoint() const { return Entrypoint; }
 130 };
 131
 132 }
 133
 134 #endif