1 //===-- llvm/MC/MCFunction.h ------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the data structures to hold a CFG reconstructed from
13 //===----------------------------------------------------------------------===//
15 #ifndef LLVM_MC_MCFUNCTION_H
16 #define LLVM_MC_MCFUNCTION_H
18 #include "llvm/ADT/StringRef.h"
19 #include "llvm/MC/MCInst.h"
30 /// \brief Basic block containing a sequence of disassembled instructions.
31 /// The basic block is backed by an MCTextAtom, which holds the instructions,
32 /// and the address range it covers.
33 /// Create a basic block using MCFunction::createBlock.
35 const MCTextAtom *Insts;
37 // MCFunction owns the basic block.
39 friend class MCFunction;
40 MCBasicBlock(const MCTextAtom &Insts, MCFunction *Parent);
42 /// \name Predecessors/Successors, to represent the CFG.
44 typedef std::vector<const MCBasicBlock *> BasicBlockListTy;
45 BasicBlockListTy Successors;
46 BasicBlockListTy Predecessors;
50 /// \brief Get the backing MCTextAtom, containing the instruction sequence.
51 const MCTextAtom *getInsts() const { return Insts; }
53 /// \name Get the owning MCFunction.
55 const MCFunction *getParent() const { return Parent; }
56 MCFunction *getParent() { return Parent; }
59 /// MC CFG access: Predecessors/Successors.
61 typedef BasicBlockListTy::const_iterator succ_const_iterator;
62 succ_const_iterator succ_begin() const { return Successors.begin(); }
63 succ_const_iterator succ_end() const { return Successors.end(); }
65 typedef BasicBlockListTy::const_iterator pred_const_iterator;
66 pred_const_iterator pred_begin() const { return Predecessors.begin(); }
67 pred_const_iterator pred_end() const { return Predecessors.end(); }
69 void addSuccessor(const MCBasicBlock *MCBB);
70 bool isSuccessor(const MCBasicBlock *MCBB) const;
72 void addPredecessor(const MCBasicBlock *MCBB);
73 bool isPredecessor(const MCBasicBlock *MCBB) const;
75 /// \brief Split block, mirrorring NewAtom = Insts->split(..).
76 /// This moves all successors to \p SplitBB, and
77 /// adds a fallthrough to it.
78 /// \p SplitBB The result of splitting Insts, a basic block directly following
80 void splitBasicBlock(MCBasicBlock *SplitBB);
84 /// \brief Represents a function in machine code, containing MCBasicBlocks.
85 /// MCFunctions are created by MCModule.
87 MCFunction (const MCFunction&) LLVM_DELETED_FUNCTION;
88 MCFunction& operator=(const MCFunction&) LLVM_DELETED_FUNCTION;
91 MCModule *ParentModule;
92 typedef std::vector<std::unique_ptr<MCBasicBlock>> BasicBlockListTy;
93 BasicBlockListTy Blocks;
95 // MCModule owns the function.
96 friend class MCModule;
97 MCFunction(StringRef Name, MCModule *Parent);
100 /// \brief Create an MCBasicBlock backed by Insts and add it to this function.
101 /// \param Insts Sequence of straight-line code backing the basic block.
102 /// \returns The newly created basic block.
103 MCBasicBlock &createBlock(const MCTextAtom &Insts);
105 StringRef getName() const { return Name; }
107 /// \name Get the owning MC Module.
109 const MCModule *getParent() const { return ParentModule; }
110 MCModule *getParent() { return ParentModule; }
113 /// \name Access to the function's basic blocks. No ordering is enforced,
114 /// except that the first block is the entry block.
116 /// \brief Get the entry point basic block.
117 const MCBasicBlock *getEntryBlock() const { return front(); }
118 MCBasicBlock *getEntryBlock() { return front(); }
120 bool empty() const { return Blocks.empty(); }
122 typedef BasicBlockListTy::const_iterator const_iterator;
123 typedef BasicBlockListTy:: iterator iterator;
124 const_iterator begin() const { return Blocks.begin(); }
125 iterator begin() { return Blocks.begin(); }
126 const_iterator end() const { return Blocks.end(); }
127 iterator end() { return Blocks.end(); }
129 const MCBasicBlock* front() const { return Blocks.front().get(); }
130 MCBasicBlock* front() { return Blocks.front().get(); }
131 const MCBasicBlock* back() const { return Blocks.back().get(); }
132 MCBasicBlock* back() { return Blocks.back().get(); }
134 /// \brief Find the basic block, if any, that starts at \p StartAddr.
135 const MCBasicBlock *find(uint64_t StartAddr) const;
136 MCBasicBlock *find(uint64_t StartAddr);