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"
29 /// \brief Basic block containing a sequence of disassembled instructions.
30 /// The basic block is backed by an MCTextAtom, which holds the instructions,
31 /// and the address range it covers.
32 /// Create a basic block using MCFunction::createBlock.
34 const MCTextAtom *Insts;
36 // MCFunction owns the basic block.
38 friend class MCFunction;
39 MCBasicBlock(const MCTextAtom &Insts, MCFunction *Parent);
41 /// \name Predecessors/Successors, to represent the CFG.
43 typedef std::vector<const MCBasicBlock *> BasicBlockListTy;
44 BasicBlockListTy Successors;
45 BasicBlockListTy Predecessors;
49 /// \brief Get the backing MCTextAtom, containing the instruction sequence.
50 const MCTextAtom *getInsts() const { return Insts; }
52 /// \name Get the owning MCFunction.
54 const MCFunction *getParent() const { return Parent; }
55 MCFunction *getParent() { return Parent; }
58 /// MC CFG access: Predecessors/Successors.
60 typedef BasicBlockListTy::const_iterator succ_const_iterator;
61 succ_const_iterator succ_begin() const { return Successors.begin(); }
62 succ_const_iterator succ_end() const { return Successors.end(); }
64 typedef BasicBlockListTy::const_iterator pred_const_iterator;
65 pred_const_iterator pred_begin() const { return Predecessors.begin(); }
66 pred_const_iterator pred_end() const { return Predecessors.end(); }
68 void addSuccessor(const MCBasicBlock *MCBB);
69 bool isSuccessor(const MCBasicBlock *MCBB) const;
71 void addPredecessor(const MCBasicBlock *MCBB);
72 bool isPredecessor(const MCBasicBlock *MCBB) const;
76 /// \brief Represents a function in machine code, containing MCBasicBlocks.
77 /// MCFunctions are created using MCModule::createFunction.
79 MCFunction (const MCFunction&) LLVM_DELETED_FUNCTION;
80 MCFunction& operator=(const MCFunction&) LLVM_DELETED_FUNCTION;
83 typedef std::vector<MCBasicBlock*> BasicBlockListTy;
84 BasicBlockListTy Blocks;
86 // MCModule owns the function.
87 friend class MCModule;
88 MCFunction(StringRef Name);
92 /// \brief Create an MCBasicBlock backed by Insts and add it to this function.
93 /// \param Insts Sequence of straight-line code backing the basic block.
94 /// \returns The newly created basic block.
95 MCBasicBlock &createBlock(const MCTextAtom &Insts);
97 StringRef getName() const { return Name; }
99 /// \name Access to the function's basic blocks. No ordering is enforced.
101 /// \brief Get the entry point basic block.
102 const MCBasicBlock *getEntryBlock() const { return front(); }
103 MCBasicBlock *getEntryBlock() { return front(); }
105 // NOTE: Dereferencing iterators gives pointers, so maybe a list is best here.
106 typedef BasicBlockListTy::const_iterator const_iterator;
107 typedef BasicBlockListTy:: iterator iterator;
108 const_iterator begin() const { return Blocks.begin(); }
109 iterator begin() { return Blocks.begin(); }
110 const_iterator end() const { return Blocks.end(); }
111 iterator end() { return Blocks.end(); }
113 const MCBasicBlock* front() const { return Blocks.front(); }
114 MCBasicBlock* front() { return Blocks.front(); }
115 const MCBasicBlock* back() const { return Blocks.back(); }
116 MCBasicBlock* back() { return Blocks.back(); }