Remove 'unwinds to' support from mainline. This patch undoes r47802 r47989

r48047 r48084 r48085 r48086 r48088 r48096 r48099 r48109 and r48123.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@50265 91177308-0d34-0410-b5e6-96231b3b80d8

4 files changed, 20 insertions, 49 deletions

diff --git a/include/llvm/Analysis/LoopInfo.h b/include/llvm/Analysis/LoopInfo.h
index ab7cb7e03e..fdb722c225 100644
--- a/include/llvm/Analysis/LoopInfo.h
+++ b/include/llvm/Analysis/LoopInfo.h
@@ -118,8 +118,8 @@ public:
   block_iterator block_begin() const { return Blocks.begin(); }
   block_iterator block_end() const { return Blocks.end(); }
 
-  /// isLoopExit - True if this block can branch to another block that is
-  /// outside of the current loop.
+  /// isLoopExit - True if terminator in the block can branch to another block
+  /// that is outside of the current loop.
   ///
   bool isLoopExit(const BlockT *BB) const {
     typedef GraphTraits<BlockT*> BlockTraits;
diff --git a/include/llvm/BasicBlock.h b/include/llvm/BasicBlock.h
index 797f50e864..b569a7aeaf 100644
--- a/include/llvm/BasicBlock.h
+++ b/include/llvm/BasicBlock.h
@@ -49,14 +49,13 @@ 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 User {       // Basic blocks are data objects also
+class BasicBlock : public Value {       // 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; }
@@ -71,7 +70,7 @@ private :
   /// InsertBefore is null), or before the specified basic block.
   ///
   explicit BasicBlock(const std::string &Name = "", Function *Parent = 0,
-                      BasicBlock *InsertBefore = 0, BasicBlock *UnwindDest = 0);
+                      BasicBlock *InsertBefore = 0);
 public:
   /// Instruction iterators...
   typedef InstListType::iterator                              iterator;
@@ -79,27 +78,21 @@ public:
 
   // allocate space for exactly zero operands
   static BasicBlock *Create(const std::string &Name = "", Function *Parent = 0,
-                            BasicBlock *InsertBefore = 0, BasicBlock *UnwindDest = 0) {
-    return new(!!UnwindDest) BasicBlock(Name, Parent, InsertBefore, UnwindDest);
+                            BasicBlock *InsertBefore = 0) {
+    return new BasicBlock(Name, Parent, InsertBefore);
   }
   ~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 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).
+  Instruction       *use_back()       { return cast<Instruction>(*use_begin());}
+  const Instruction *use_back() const { return cast<Instruction>(*use_begin());}
+  
   /// getTerminator() - If this is a well formed basic block, then this returns
   /// a pointer to the terminator instruction.  If it is not, then you get a
   /// null pointer back.
@@ -187,14 +180,7 @@ public:
   /// update the PHI nodes that reside in the block.  Note that this should be
   /// called while the predecessor still refers to this block.
   ///
-  /// DontDeleteUselessPHIs will keep PHIs that have one value or the same 
-  /// value for all entries.
-  ///
-  /// OnlyDeleteOne will only remove one entry from a PHI, in case there were
-  /// duplicate entries for the Pred.
-  ///
-  void removePredecessor(BasicBlock *Pred, bool DontDeleteUselessPHIs = false,
-                         bool OnlyDeleteOne = false);
+  void removePredecessor(BasicBlock *Pred, bool DontDeleteUselessPHIs = false);
 
   /// splitBasicBlock - This splits a basic block into two at the specified
   /// instruction.  Note that all instructions BEFORE the specified iterator
diff --git a/include/llvm/Bitcode/LLVMBitCodes.h b/include/llvm/Bitcode/LLVMBitCodes.h
index 377ff420fd..5ef832e187 100644
--- a/include/llvm/Bitcode/LLVMBitCodes.h
+++ b/include/llvm/Bitcode/LLVMBitCodes.h
@@ -202,9 +202,7 @@ namespace bitc {
     // this is so information only available in the pointer type (e.g. address
     // spaces) is retained.
     FUNC_CODE_INST_STORE2      = 24, // STORE:      [ptrty,ptr,val, align, vol]
-    FUNC_CODE_INST_GETRESULT   = 25, // GETRESULT:  [ty, opval, n]
-
-    FUNC_CODE_INST_BB_UNWINDDEST = 26  // BB_UNWINDDEST: [bb#]
+    FUNC_CODE_INST_GETRESULT   = 25  // GETRESULT:  [ty, opval, n]
   };
 } // End bitc namespace
 } // End llvm namespace
diff --git a/include/llvm/Support/CFG.h b/include/llvm/Support/CFG.h
index f8cbeb0a50..0d49aecb09 100644
--- a/include/llvm/Support/CFG.h
+++ b/include/llvm/Support/CFG.h
@@ -34,17 +34,14 @@ public:
   typedef PredIterator<_Ptr,_USE_iterator> _Self;
   typedef typename super::pointer pointer;
 
-  inline void advancePastNonPreds() {
-    // Loop to ignore non predecessor uses (for example PHI nodes)...
-    while (!It.atEnd()) {
-      if (isa<TerminatorInst>(*It) || isa<BasicBlock>(*It))
-	break;
+  inline void advancePastNonTerminators() {
+    // Loop to ignore non terminator uses (for example PHI nodes)...
+    while (!It.atEnd() && !isa<TerminatorInst>(*It))
       ++It;
-    }
   }
 
   inline PredIterator(_Ptr *bb) : It(bb->use_begin()) {
-    advancePastNonPreds();
+    advancePastNonTerminators();
   }
   inline PredIterator(_Ptr *bb, bool) : It(bb->use_end()) {}
 
@@ -53,16 +50,13 @@ public:
 
   inline pointer operator*() const {
     assert(!It.atEnd() && "pred_iterator out of range!");
-    if (isa<TerminatorInst>(*It))      // not dyn_cast due to const-correctness
-      return cast<TerminatorInst>(*It)->getParent();
-
-    return cast<_Ptr>(*It);
+    return cast<TerminatorInst>(*It)->getParent();
   }
   inline pointer *operator->() const { return &(operator*()); }
 
   inline _Self& operator++() {   // Preincrement
     assert(!It.atEnd() && "pred_iterator out of range!");
-    ++It; advancePastNonPreds();
+    ++It; advancePastNonTerminators();
     return *this;
   }
 
@@ -106,8 +100,6 @@ public:
   inline SuccIterator(Term_ T, bool)                       // end iterator
     : Term(T), idx(Term->getNumSuccessors()) {
     assert(T && "getTerminator returned null!");
-    if (Term->getParent()->getUnwindDest())
-      ++idx;
   }
 
   inline const _Self &operator=(const _Self &I) {
@@ -123,12 +115,7 @@ public:
   inline bool operator==(const _Self& x) const { return idx == x.idx; }
   inline bool operator!=(const _Self& x) const { return !operator==(x); }
 
-  inline pointer operator*() const {
-    if (idx == Term->getNumSuccessors())
-      return Term->getParent()->getUnwindDest();
-
-    return Term->getSuccessor(idx);
-  }
+  inline pointer operator*() const { return Term->getSuccessor(idx); }
   inline pointer operator->() const { return operator*(); }
 
   inline _Self& operator++() { ++idx; return *this; } // Preincrement