X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;ds=sidebyside;f=include%2Fllvm%2FBasicBlock.h;h=5a1c5a45b2b57df82fe33a8788cc569a042bf928;hb=fc82fabe00b0b820e3c0d7fc9e289bace0295f11;hp=0ca8eae1a3ef01e1865083e111d85b594c55d162;hpb=5c7e326585f3a543388ba871c3425f7664cd9143;p=oota-llvm.git

diff --git a/include/llvm/BasicBlock.h b/include/llvm/BasicBlock.h
index 0ca8eae1a3e..5a1c5a45b2b 100644
--- a/include/llvm/BasicBlock.h
+++ b/include/llvm/BasicBlock.h
@@ -2,8 +2,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
@@ -17,6 +17,7 @@
 #include "llvm/Instruction.h"
 #include "llvm/SymbolTableListTraits.h"
 #include "llvm/ADT/ilist"
+#include "llvm/Support/DataTypes.h"
 
 namespace llvm {
 
@@ -25,11 +26,13 @@ template <class Term, class BB> class SuccIterator;  // Successor Iterator
 template <class Ptr, class USE_iterator> class PredIterator;
 
 template<> struct ilist_traits<Instruction>
-  : public SymbolTableListTraits<Instruction, BasicBlock, Function> {
+  : public SymbolTableListTraits<Instruction, BasicBlock> {
   // createSentinel is used to create a node that marks the end of the list...
   static Instruction *createSentinel();
   static void destroySentinel(Instruction *I) { delete I; }
   static iplist<Instruction> &getList(BasicBlock *BB);
+  static ValueSymbolTable *getSymTab(BasicBlock *ItemParent);
+  static int getListOffset();
 };
 
 /// This represents a single basic block in LLVM. A basic block is simply a
@@ -46,17 +49,19 @@ template<> struct ilist_traits<Instruction>
 /// modifying a program. However, the verifier will ensure that basic blocks
 /// are "well formed".
 /// @brief LLVM Basic Block Representation
-class BasicBlock : public Value {       // Basic blocks are data objects also
+class BasicBlock : public User {       // Basic blocks are data objects also
 public:
   typedef iplist<Instruction> InstListType;
 private :
   InstListType InstList;
   BasicBlock *Prev, *Next; // Next and Prev links for our intrusive linked list
+  Function *Parent;
+  Use unwindDest;
 
   void setParent(Function *parent);
   void setNext(BasicBlock *N) { Next = N; }
   void setPrev(BasicBlock *N) { Prev = N; }
-  friend class SymbolTableListTraits<BasicBlock, Function, Function>;
+  friend class SymbolTableListTraits<BasicBlock, Function>;
 
   BasicBlock(const BasicBlock &);     // Do not implement
   void operator=(const BasicBlock &); // Do not implement
@@ -70,20 +75,25 @@ public:
   /// is automatically inserted at either the end of the function (if
   /// InsertBefore is null), or before the specified basic block.
   ///
-  BasicBlock(const std::string &Name = "", Function *Parent = 0,
-             BasicBlock *InsertBefore = 0);
+  explicit BasicBlock(const std::string &Name = "", Function *Parent = 0,
+                      BasicBlock *InsertBefore = 0, BasicBlock *unwindDest = 0);
   ~BasicBlock();
 
+  /// getUnwindDest - Returns the BasicBlock that flow will enter if an unwind
+  /// instruction occurs in this block. May be null, in which case unwinding
+  /// is undefined in this block.
+  const BasicBlock *getUnwindDest() const;
+  BasicBlock *getUnwindDest();
+
+  /// setUnwindDest - Set which BasicBlock flow will enter if an unwind is
+  /// executed within this block. It may be set to null if unwinding is not
+  /// permitted in this block.
+  void setUnwindDest(BasicBlock *unwindDest);
+
   /// getParent - Return the enclosing method, or null if none
   ///
-  const Function *getParent() const { return InstList.getParent(); }
-        Function *getParent()       { return InstList.getParent(); }
-
-  // getNext/Prev - Return the next or previous basic block in the list.
-        BasicBlock *getNext()       { return Next; }
-  const BasicBlock *getNext() const { return Next; }
-        BasicBlock *getPrev()       { return Prev; }
-  const BasicBlock *getPrev() const { return Prev; }
+  const Function *getParent() const { return Parent; }
+        Function *getParent()       { return Parent; }
 
   /// use_back - Specialize the methods defined in Value, as we know that an
   /// BasicBlock can only be used by Instructions (specifically PHI and terms).
@@ -95,7 +105,7 @@ public:
   /// null pointer back.
   ///
   TerminatorInst *getTerminator();
-  const TerminatorInst *const getTerminator() const;
+  const TerminatorInst *getTerminator() const;
   
   /// Returns a pointer to the first instructon in this block that is not a 
   /// PHINode instruction. When adding instruction to the beginning of the
@@ -158,7 +168,7 @@ public:
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const BasicBlock *) { return true; }
   static inline bool classof(const Value *V) {
-    return V->getValueType() == Value::BasicBlockVal;
+    return V->getValueID() == Value::BasicBlockVal;
   }
 
   /// dropAllReferences() - This function causes all the subinstructions to "let
@@ -192,8 +202,27 @@ public:
   /// the basic block).
   ///
   BasicBlock *splitBasicBlock(iterator I, const std::string &BBName = "");
+  
+  
+  static unsigned getInstListOffset() {
+    BasicBlock *Obj = 0;
+    return unsigned(reinterpret_cast<uintptr_t>(&Obj->InstList));
+  }
+
+private:
+  // getNext/Prev - Return the next or previous basic block in the list.  Access
+  // these with Function::iterator.
+  BasicBlock *getNext()       { return Next; }
+  const BasicBlock *getNext() const { return Next; }
+  BasicBlock *getPrev()       { return Prev; }
+  const BasicBlock *getPrev() const { return Prev; }
 };
 
+inline int 
+ilist_traits<Instruction>::getListOffset() {
+  return BasicBlock::getInstListOffset();
+}
+
 } // End llvm namespace
 
 #endif