include/llvm/BasicBlock.h

   1 //===-- llvm/BasicBlock.h - Represent a basic block in the VM ----*- C++ -*--=//
   2 //
   3 // This file contains the declaration of the BasicBlock class, which represents
   4 // a single basic block in the VM.
   5 //
   6 // Note that basic blocks themselves are Def's, because they are referenced
   7 // by instructions like branches and can go in switch tables and stuff...
   8 //
   9 // This may see wierd at first, but it's really pretty cool.  :)
  10 //
  11 //===----------------------------------------------------------------------===//
  12 //
  13 // Note that well formed basic blocks are formed of a list of instructions
  14 // followed by a single TerminatorInst instruction.  TerminatorInst's may not
  15 // occur in the middle of basic blocks, and must terminate the blocks.
  16 //
  17 // This code allows malformed basic blocks to occur, because it may be useful
  18 // in the intermediate stage of analysis or modification of a program.
  19 //
  20 //===----------------------------------------------------------------------===//
  21
  22 #ifndef LLVM_BASICBLOCK_H
  23 #define LLVM_BASICBLOCK_H
  24
  25 #include "llvm/Value.h"               // Get the definition of Value
  26 #include "llvm/ValueHolder.h"
  27 #include "llvm/CFGdecls.h"
  28
  29 class Instruction;
  30 class Method;
  31 class BasicBlock;
  32 class TerminatorInst;
  33
  34 typedef UseTy<BasicBlock> BasicBlockUse;
  35
  36 class BasicBlock : public Value {       // Basic blocks are data objects also
  37 public:
  38   typedef ValueHolder<Instruction, BasicBlock> InstListType;
  39 private :
  40   InstListType InstList;
  41
  42   friend class ValueHolder<BasicBlock,Method>;
  43   void setParent(Method *parent);
  44
  45 public:
  46   typedef cfg::succ_iterator succ_iterator;   // Include CFG.h to use these
  47   typedef cfg::pred_iterator pred_iterator;
  48   typedef cfg::succ_const_iterator succ_const_iterator;
  49   typedef cfg::pred_const_iterator pred_const_iterator;
  50
  51   BasicBlock(const string &Name = "", Method *Parent = 0);
  52   ~BasicBlock();
  53
  54   // Specialize setName to take care of symbol table majik
  55   virtual void setName(const string &name);
  56
  57   const Method *getParent() const { return (const Method*)InstList.getParent();}
  58         Method *getParent()       { return (Method*)InstList.getParent(); }
  59
  60   const InstListType &getInstList() const { return InstList; }
  61         InstListType &getInstList()       { return InstList; }
  62
  63   // getTerminator() - If this is a well formed basic block, then this returns
  64   // a pointer to the terminator instruction.  If it is not, then you get a null
  65   // pointer back.
  66   //
  67   TerminatorInst *getTerminator();
  68   const TerminatorInst *const getTerminator() const;
  69
  70   // hasConstantPoolReferences() - This predicate is true if there is a
  71   // reference to this basic block in the constant pool for this method.  For
  72   // example, if a block is reached through a switch table, that table resides
  73   // in the constant pool, and the basic block is reference from it.
  74   //
  75   bool hasConstantPoolReferences() const;
  76
  77   // dropAllReferences() - This function causes all the subinstructions to "let
  78   // go" of all references that they are maintaining.  This allows one to
  79   // 'delete' a whole class at a time, even though there may be circular
  80   // references... first all references are dropped, and all use counts go to
  81   // zero.  Then everything is delete'd for real.  Note that no operations are
  82   // valid on an object that has "dropped all references", except operator
  83   // delete.
  84   //
  85   void dropAllReferences();
  86
  87   // splitBasicBlock - This splits a basic block into two at the specified
  88   // instruction.  Note that all instructions BEFORE the specified iterator stay
  89   // as part of the original basic block, an unconditional branch is added to
  90   // the new BB, and the rest of the instructions in the BB are moved to the new
  91   // BB, including the old terminator.  The newly formed BasicBlock is returned.
  92   // This function invalidates the specified iterator.
  93   //
  94   // Note that this only works on well formed basic blocks (must have a
  95   // terminator), and 'I' must not be the end of instruction list (which would
  96   // cause a degenerate basic block to be formed, having a terminator inside of
  97   // the basic block).
  98   //
  99   BasicBlock *splitBasicBlock(InstListType::iterator I);
 100 };
 101
 102 #endif