correct the type of two intrinsics, add int_ppc_altivec_vmladduhm

[oota-llvm.git] / include / llvm / BasicBlock.h

diff --git a/include/llvm/BasicBlock.h b/include/llvm/BasicBlock.h
index 38ac109365964d6aa3d394c0f4cffea98e2b7479..55ecd4052e6925a4349b3257e634815e406d3f4f 100644 (file)
--- a/include/llvm/BasicBlock.h
+++ b/include/llvm/BasicBlock.h
@@ -1,10 +1,10 @@
 //===-- llvm/BasicBlock.h - Represent a basic block in the VM ---*- C++ -*-===//
-// 
+//
 //                     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.
-// 
+//
 //===----------------------------------------------------------------------===//
 //
 //
@@ -16,7 +16,7 @@
 //
 ///===---------------------------------------------------------------------===//
 //
-// Note that well formed basic blocks are formed of a list of instructions 
+// Note that well formed basic blocks are formed of a list of instructions
 // followed by a single TerminatorInst instruction.  TerminatorInst's may not
 // occur in the middle of basic blocks, and must terminate the blocks.
 //
@@ -91,7 +91,7 @@ public:
   ///
   TerminatorInst *getTerminator();
   const TerminatorInst *const getTerminator() const;
-  
+
   /// removeFromParent - This method unlinks 'this' from the containing
   /// function, but does not delete it.
   ///
@@ -101,6 +101,11 @@ public:
   /// and deletes it.
   ///
   void eraseFromParent();
+  
+  /// moveBefore - Unlink this instruction from its current function and
+  /// insert it into the function that MovePos lives in, right before
+  /// MovePos.
+  void moveBefore(BasicBlock *MovePos);
 
   /// getSinglePredecessor - If this basic block has a single predecessor block,
   /// return the block, otherwise return a null pointer.
@@ -134,7 +139,7 @@ public:
   void print(std::ostream &OS, AssemblyAnnotationWriter *AAW) const;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const BasicBlock *BB) { return true; }
+  static inline bool classof(const BasicBlock *) { return true; }
   static inline bool classof(const Value *V) {
     return V->getValueType() == Value::BasicBlockVal;
   }
@@ -144,27 +149,27 @@ public:
   /// 'delete' a whole class at a time, even though there may be circular
   /// references... first all references are dropped, and all use counts go to
   /// zero.  Then everything is delete'd for real.  Note that no operations are
-  /// valid on an object that has "dropped all references", except operator 
+  /// valid on an object that has "dropped all references", except operator
   /// delete.
   ///
   void dropAllReferences();
 
   /// removePredecessor - This method is used to notify a BasicBlock that the
   /// specified Predecessor of the block is no longer able to reach it.  This is
-  /// actually not used to update the Predecessor list, but is actually used to 
+  /// actually not used to update the Predecessor list, but is actually used to
   /// update the PHI nodes that reside in the block.  Note that this should be
   /// called while the predecessor still refers to this block.
   ///
-  void removePredecessor(BasicBlock *Pred);
+  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
   /// stay as part of the original basic block, an unconditional branch is added
-  /// to the new BB, and the rest of the instructions in the BB are moved to the
-  /// new BB, including the old terminator.  The newly formed BasicBlock is
-  /// returned.  This function invalidates the specified iterator.
+  /// to the original BB, and the rest of the instructions in the BB are moved
+  /// to the new BB, including the old terminator.  The newly formed BasicBlock
+  /// is returned.  This function invalidates the specified iterator.
   ///
-  /// Note that this only works on well formed basic blocks (must have a 
+  /// Note that this only works on well formed basic blocks (must have a
   /// terminator), and 'I' must not be the end of instruction list (which would
   /// cause a degenerate basic block to be formed, having a terminator inside of
   /// the basic block).