tools/llvm-objdump/MCFunction.h

   1 //===-- MCFunction.h ------------------------------------------------------===//
   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 defines the data structures to hold a CFG reconstructed from
  11 // machine code.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_OBJECTDUMP_MCFUNCTION_H
  16 #define LLVM_OBJECTDUMP_MCFUNCTION_H
  17
  18 #include "llvm/ADT/ArrayRef.h"
  19 #include "llvm/ADT/DenseSet.h"
  20 #include "llvm/MC/MCInst.h"
  21 #include <map>
  22
  23 namespace llvm {
  24
  25 class MCDisassembler;
  26 class MCInstrAnalysis;
  27 class MemoryObject;
  28 class raw_ostream;
  29
  30 /// MCDecodedInst - Small container to hold an MCInst and associated info like
  31 /// address and size.
  32 struct MCDecodedInst {
  33   uint64_t Address;
  34   uint64_t Size;
  35   MCInst Inst;
  36
  37   MCDecodedInst() {}
  38   MCDecodedInst(uint64_t Address, uint64_t Size, MCInst Inst)
  39     : Address(Address), Size(Size), Inst(Inst) {}
  40
  41   bool operator<(const MCDecodedInst &RHS) const {
  42     return Address < RHS.Address;
  43   }
  44 };
  45
  46 /// MCBasicBlock - Consists of multiple MCDecodedInsts and a list of successing
  47 /// MCBasicBlocks.
  48 class MCBasicBlock {
  49   std::vector<MCDecodedInst> Insts;
  50   typedef DenseSet<uint64_t> SetTy;
  51   SetTy Succs;
  52 public:
  53   ArrayRef<MCDecodedInst> getInsts() const { return Insts; }
  54
  55   typedef SetTy::const_iterator succ_iterator;
  56   succ_iterator succ_begin() const { return Succs.begin(); }
  57   succ_iterator succ_end() const { return Succs.end(); }
  58
  59   bool contains(uint64_t Addr) const { return Succs.count(Addr); }
  60
  61   void addInst(const MCDecodedInst &Inst) { Insts.push_back(Inst); }
  62   void addSucc(uint64_t Addr) { Succs.insert(Addr); }
  63
  64   bool operator<(const MCBasicBlock &RHS) const {
  65     return Insts.size() < RHS.Insts.size();
  66   }
  67 };
  68
  69 /// MCFunction - Represents a named function in machine code, containing
  70 /// multiple MCBasicBlocks.
  71 class MCFunction {
  72   const StringRef Name;
  73   // Keep BBs sorted by address.
  74   typedef std::vector<std::pair<uint64_t, MCBasicBlock> > MapTy;
  75   MapTy Blocks;
  76 public:
  77   MCFunction(StringRef Name) : Name(Name) {}
  78
  79   // Create an MCFunction from a region of binary machine code.
  80   static MCFunction
  81   createFunctionFromMC(StringRef Name, const MCDisassembler *DisAsm,
  82                        const MemoryObject &Region, uint64_t Start, uint64_t End,
  83                        const MCInstrAnalysis *Ana, raw_ostream &DebugOut,
  84                        SmallVectorImpl<uint64_t> &Calls);
  85
  86   typedef MapTy::const_iterator iterator;
  87   iterator begin() const { return Blocks.begin(); }
  88   iterator end() const { return Blocks.end(); }
  89
  90   StringRef getName() const { return Name; }
  91
  92   MCBasicBlock &addBlock(uint64_t Address, const MCBasicBlock &BB) {
  93     Blocks.push_back(std::make_pair(Address, BB));
  94     return Blocks.back().second;
  95   }
  96 };
  97
  98 }
  99
 100 #endif