Update LLVM for 3.5 rebase (r209712).

Change-Id: I149556c940fb7dc92d075273c87ff584f400941f

1 files changed, 99 insertions, 93 deletions

diff --git a/include/llvm/Analysis/InstructionSimplify.h b/include/llvm/Analysis/InstructionSimplify.h
index 775d0df..2367c0b 100644
--- a/include/llvm/Analysis/InstructionSimplify.h
+++ b/include/llvm/Analysis/InstructionSimplify.h
@@ -48,160 +48,166 @@ namespace llvm {
   /// SimplifyAddInst - Given operands for an Add, see if we can
   /// fold the result.  If not, this returns null.
   Value *SimplifyAddInst(Value *LHS, Value *RHS, bool isNSW, bool isNUW,
-                         const DataLayout *TD = 0,
-                         const TargetLibraryInfo *TLI = 0,
-                         const DominatorTree *DT = 0);
+                         const DataLayout *TD = nullptr,
+                         const TargetLibraryInfo *TLI = nullptr,
+                         const DominatorTree *DT = nullptr);
 
   /// SimplifySubInst - Given operands for a Sub, see if we can
   /// fold the result.  If not, this returns null.
   Value *SimplifySubInst(Value *LHS, Value *RHS, bool isNSW, bool isNUW,
-                         const DataLayout *TD = 0,
-                         const TargetLibraryInfo *TLI = 0,
-                         const DominatorTree *DT = 0);
+                         const DataLayout *TD = nullptr,
+                         const TargetLibraryInfo *TLI = nullptr,
+                         const DominatorTree *DT = nullptr);
 
   /// Given operands for an FAdd, see if we can fold the result.  If not, this
   /// returns null.
   Value *SimplifyFAddInst(Value *LHS, Value *RHS, FastMathFlags FMF,
-                         const DataLayout *TD = 0,
-                         const TargetLibraryInfo *TLI = 0,
-                         const DominatorTree *DT = 0);
+                         const DataLayout *TD = nullptr,
+                         const TargetLibraryInfo *TLI = nullptr,
+                         const DominatorTree *DT = nullptr);
 
   /// Given operands for an FSub, see if we can fold the result.  If not, this
   /// returns null.
   Value *SimplifyFSubInst(Value *LHS, Value *RHS, FastMathFlags FMF,
-                         const DataLayout *TD = 0,
-                         const TargetLibraryInfo *TLI = 0,
-                         const DominatorTree *DT = 0);
+                         const DataLayout *TD = nullptr,
+                         const TargetLibraryInfo *TLI = nullptr,
+                         const DominatorTree *DT = nullptr);
 
   /// Given operands for an FMul, see if we can fold the result.  If not, this
   /// returns null.
   Value *SimplifyFMulInst(Value *LHS, Value *RHS,
                           FastMathFlags FMF,
-                          const DataLayout *TD = 0,
-                          const TargetLibraryInfo *TLI = 0,
-                          const DominatorTree *DT = 0);
+                          const DataLayout *TD = nullptr,
+                          const TargetLibraryInfo *TLI = nullptr,
+                          const DominatorTree *DT = nullptr);
 
   /// SimplifyMulInst - Given operands for a Mul, see if we can
   /// fold the result.  If not, this returns null.
-  Value *SimplifyMulInst(Value *LHS, Value *RHS, const DataLayout *TD = 0,
-                         const TargetLibraryInfo *TLI = 0,
-                         const DominatorTree *DT = 0);
+  Value *SimplifyMulInst(Value *LHS, Value *RHS, const DataLayout *TD = nullptr,
+                         const TargetLibraryInfo *TLI = nullptr,
+                         const DominatorTree *DT = nullptr);
 
   /// SimplifySDivInst - Given operands for an SDiv, see if we can
   /// fold the result.  If not, this returns null.
-  Value *SimplifySDivInst(Value *LHS, Value *RHS, const DataLayout *TD = 0,
-                          const TargetLibraryInfo *TLI = 0,
-                          const DominatorTree *DT = 0);
+  Value *SimplifySDivInst(Value *LHS, Value *RHS,
+                          const DataLayout *TD = nullptr,
+                          const TargetLibraryInfo *TLI = nullptr,
+                          const DominatorTree *DT = nullptr);
 
   /// SimplifyUDivInst - Given operands for a UDiv, see if we can
   /// fold the result.  If not, this returns null.
-  Value *SimplifyUDivInst(Value *LHS, Value *RHS, const DataLayout *TD = 0,
-                          const TargetLibraryInfo *TLI = 0,
-                          const DominatorTree *DT = 0);
+  Value *SimplifyUDivInst(Value *LHS, Value *RHS,
+                          const DataLayout *TD = nullptr,
+                          const TargetLibraryInfo *TLI = nullptr,
+                          const DominatorTree *DT = nullptr);
 
   /// SimplifyFDivInst - Given operands for an FDiv, see if we can
   /// fold the result.  If not, this returns null.
-  Value *SimplifyFDivInst(Value *LHS, Value *RHS, const DataLayout *TD = 0,
-                          const TargetLibraryInfo *TLI = 0,
-                          const DominatorTree *DT = 0);
+  Value *SimplifyFDivInst(Value *LHS, Value *RHS,
+                          const DataLayout *TD = nullptr,
+                          const TargetLibraryInfo *TLI = nullptr,
+                          const DominatorTree *DT = nullptr);
 
   /// SimplifySRemInst - Given operands for an SRem, see if we can
   /// fold the result.  If not, this returns null.
-  Value *SimplifySRemInst(Value *LHS, Value *RHS, const DataLayout *TD = 0,
-                          const TargetLibraryInfo *TLI = 0,
-                          const DominatorTree *DT = 0);
+  Value *SimplifySRemInst(Value *LHS, Value *RHS,
+                          const DataLayout *TD = nullptr,
+                          const TargetLibraryInfo *TLI = nullptr,
+                          const DominatorTree *DT = nullptr);
 
   /// SimplifyURemInst - Given operands for a URem, see if we can
   /// fold the result.  If not, this returns null.
-  Value *SimplifyURemInst(Value *LHS, Value *RHS, const DataLayout *TD = 0,
-                          const TargetLibraryInfo *TLI = 0,
-                          const DominatorTree *DT = 0);
+  Value *SimplifyURemInst(Value *LHS, Value *RHS,
+                          const DataLayout *TD = nullptr,
+                          const TargetLibraryInfo *TLI = nullptr,
+                          const DominatorTree *DT = nullptr);
 
   /// SimplifyFRemInst - Given operands for an FRem, see if we can
   /// fold the result.  If not, this returns null.
-  Value *SimplifyFRemInst(Value *LHS, Value *RHS, const DataLayout *TD = 0,
-                          const TargetLibraryInfo *TLI = 0,
-                          const DominatorTree *DT = 0);
+  Value *SimplifyFRemInst(Value *LHS, Value *RHS,
+                          const DataLayout *TD = nullptr,
+                          const TargetLibraryInfo *TLI = nullptr,
+                          const DominatorTree *DT = nullptr);
 
   /// SimplifyShlInst - Given operands for a Shl, see if we can
   /// fold the result.  If not, this returns null.
   Value *SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
-                         const DataLayout *TD = 0,
-                         const TargetLibraryInfo *TLI = 0,
-                         const DominatorTree *DT = 0);
+                         const DataLayout *TD = nullptr,
+                         const TargetLibraryInfo *TLI = nullptr,
+                         const DominatorTree *DT = nullptr);
 
   /// SimplifyLShrInst - Given operands for a LShr, see if we can
   /// fold the result.  If not, this returns null.
   Value *SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact,
-                          const DataLayout *TD = 0,
-                          const TargetLibraryInfo *TLI = 0,
-                          const DominatorTree *DT = 0);
+                          const DataLayout *TD = nullptr,
+                          const TargetLibraryInfo *TLI = nullptr,
+                          const DominatorTree *DT = nullptr);
 
   /// SimplifyAShrInst - Given operands for a AShr, see if we can
   /// fold the result.  If not, this returns null.
   Value *SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact,
-                          const DataLayout *TD = 0,
-                          const TargetLibraryInfo *TLI = 0,
-                          const DominatorTree *DT = 0);
+                          const DataLayout *TD = nullptr,
+                          const TargetLibraryInfo *TLI = nullptr,
+                          const DominatorTree *DT = nullptr);
 
   /// SimplifyAndInst - Given operands for an And, see if we can
   /// fold the result.  If not, this returns null.
-  Value *SimplifyAndInst(Value *LHS, Value *RHS, const DataLayout *TD = 0,
-                         const TargetLibraryInfo *TLI = 0,
-                         const DominatorTree *DT = 0);
+  Value *SimplifyAndInst(Value *LHS, Value *RHS, const DataLayout *TD = nullptr,
+                         const TargetLibraryInfo *TLI = nullptr,
+                         const DominatorTree *DT = nullptr);
 
   /// SimplifyOrInst - Given operands for an Or, see if we can
   /// fold the result.  If not, this returns null.
-  Value *SimplifyOrInst(Value *LHS, Value *RHS, const DataLayout *TD = 0,
-                        const TargetLibraryInfo *TLI = 0,
-                        const DominatorTree *DT = 0);
+  Value *SimplifyOrInst(Value *LHS, Value *RHS, const DataLayout *TD = nullptr,
+                        const TargetLibraryInfo *TLI = nullptr,
+                        const DominatorTree *DT = nullptr);
 
   /// SimplifyXorInst - Given operands for a Xor, see if we can
   /// fold the result.  If not, this returns null.
-  Value *SimplifyXorInst(Value *LHS, Value *RHS, const DataLayout *TD = 0,
-                         const TargetLibraryInfo *TLI = 0,
-                         const DominatorTree *DT = 0);
+  Value *SimplifyXorInst(Value *LHS, Value *RHS, const DataLayout *TD = nullptr,
+                         const TargetLibraryInfo *TLI = nullptr,
+                         const DominatorTree *DT = nullptr);
 
   /// SimplifyICmpInst - Given operands for an ICmpInst, see if we can
   /// fold the result.  If not, this returns null.
   Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
-                          const DataLayout *TD = 0,
-                          const TargetLibraryInfo *TLI = 0,
-                          const DominatorTree *DT = 0);
+                          const DataLayout *TD = nullptr,
+                          const TargetLibraryInfo *TLI = nullptr,
+                          const DominatorTree *DT = nullptr);
 
   /// SimplifyFCmpInst - Given operands for an FCmpInst, see if we can
   /// fold the result.  If not, this returns null.
   Value *SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
-                          const DataLayout *TD = 0,
-                          const TargetLibraryInfo *TLI = 0,
-                          const DominatorTree *DT = 0);
+                          const DataLayout *TD = nullptr,
+                          const TargetLibraryInfo *TLI = nullptr,
+                          const DominatorTree *DT = nullptr);
 
   /// SimplifySelectInst - Given operands for a SelectInst, see if we can fold
   /// the result.  If not, this returns null.
   Value *SimplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal,
-                            const DataLayout *TD = 0,
-                            const TargetLibraryInfo *TLI = 0,
-                            const DominatorTree *DT = 0);
+                            const DataLayout *TD = nullptr,
+                            const TargetLibraryInfo *TLI = nullptr,
+                            const DominatorTree *DT = nullptr);
 
   /// SimplifyGEPInst - Given operands for an GetElementPtrInst, see if we can
   /// fold the result.  If not, this returns null.
-  Value *SimplifyGEPInst(ArrayRef<Value *> Ops, const DataLayout *TD = 0,
-                         const TargetLibraryInfo *TLI = 0,
-                         const DominatorTree *DT = 0);
+  Value *SimplifyGEPInst(ArrayRef<Value *> Ops, const DataLayout *TD = nullptr,
+                         const TargetLibraryInfo *TLI = nullptr,
+                         const DominatorTree *DT = nullptr);
 
   /// SimplifyInsertValueInst - Given operands for an InsertValueInst, see if we
   /// can fold the result.  If not, this returns null.
   Value *SimplifyInsertValueInst(Value *Agg, Value *Val,
                                  ArrayRef<unsigned> Idxs,
-                                 const DataLayout *TD = 0,
-                                 const TargetLibraryInfo *TLI = 0,
-                                 const DominatorTree *DT = 0);
+                                 const DataLayout *TD = nullptr,
+                                 const TargetLibraryInfo *TLI = nullptr,
+                                 const DominatorTree *DT = nullptr);
 
   /// SimplifyTruncInst - Given operands for an TruncInst, see if we can fold
   /// the result.  If not, this returns null.
-  Value *SimplifyTruncInst(Value *Op, Type *Ty, const DataLayout *TD = 0,
-                           const TargetLibraryInfo *TLI = 0,
-                           const DominatorTree *DT = 0);
+  Value *SimplifyTruncInst(Value *Op, Type *Ty, const DataLayout *TD = nullptr,
+                           const TargetLibraryInfo *TLI = nullptr,
+                           const DominatorTree *DT = nullptr);
 
   //=== Helper functions for higher up the class hierarchy.
 
@@ -209,40 +215,40 @@ namespace llvm {
   /// SimplifyCmpInst - Given operands for a CmpInst, see if we can
   /// fold the result.  If not, this returns null.
   Value *SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
-                         const DataLayout *TD = 0,
-                         const TargetLibraryInfo *TLI = 0,
-                         const DominatorTree *DT = 0);
+                         const DataLayout *TD = nullptr,
+                         const TargetLibraryInfo *TLI = nullptr,
+                         const DominatorTree *DT = nullptr);
 
   /// SimplifyBinOp - Given operands for a BinaryOperator, see if we can
   /// fold the result.  If not, this returns null.
   Value *SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS,
-                       const DataLayout *TD = 0,
-                       const TargetLibraryInfo *TLI = 0,
-                       const DominatorTree *DT = 0);
+                       const DataLayout *TD = nullptr,
+                       const TargetLibraryInfo *TLI = nullptr,
+                       const DominatorTree *DT = nullptr);
 
   /// \brief Given a function and iterators over arguments, see if we can fold
   /// the result.
   ///
   /// If this call could not be simplified returns null.
   Value *SimplifyCall(Value *V, User::op_iterator ArgBegin,
-                      User::op_iterator ArgEnd, const DataLayout *TD = 0,
-                      const TargetLibraryInfo *TLI = 0,
-                      const DominatorTree *DT = 0);
+                      User::op_iterator ArgEnd, const DataLayout *TD = nullptr,
+                      const TargetLibraryInfo *TLI = nullptr,
+                      const DominatorTree *DT = nullptr);
 
   /// \brief Given a function and set of arguments, see if we can fold the
   /// result.
   ///
   /// If this call could not be simplified returns null.
   Value *SimplifyCall(Value *V, ArrayRef<Value *> Args,
-                      const DataLayout *TD = 0,
-                      const TargetLibraryInfo *TLI = 0,
-                      const DominatorTree *DT = 0);
+                      const DataLayout *TD = nullptr,
+                      const TargetLibraryInfo *TLI = nullptr,
+                      const DominatorTree *DT = nullptr);
 
   /// SimplifyInstruction - See if we can compute a simplified version of this
   /// instruction.  If not, this returns null.
-  Value *SimplifyInstruction(Instruction *I, const DataLayout *TD = 0,
-                             const TargetLibraryInfo *TLI = 0,
-                             const DominatorTree *DT = 0);
+  Value *SimplifyInstruction(Instruction *I, const DataLayout *TD = nullptr,
+                             const TargetLibraryInfo *TLI = nullptr,
+                             const DominatorTree *DT = nullptr);
 
 
   /// \brief Replace all uses of 'I' with 'SimpleV' and simplify the uses
@@ -254,9 +260,9 @@ namespace llvm {
   ///
   /// The function returns true if any simplifications were performed.
   bool replaceAndRecursivelySimplify(Instruction *I, Value *SimpleV,
-                                     const DataLayout *TD = 0,
-                                     const TargetLibraryInfo *TLI = 0,
-                                     const DominatorTree *DT = 0);
+                                     const DataLayout *TD = nullptr,
+                                     const TargetLibraryInfo *TLI = nullptr,
+                                     const DominatorTree *DT = nullptr);
 
   /// \brief Recursively attempt to simplify an instruction.
   ///
@@ -265,9 +271,9 @@ namespace llvm {
   /// of the users impacted. It returns true if any simplifications were
   /// performed.
   bool recursivelySimplifyInstruction(Instruction *I,
-                                      const DataLayout *TD = 0,
-                                      const TargetLibraryInfo *TLI = 0,
-                                      const DominatorTree *DT = 0);
+                                      const DataLayout *TD = nullptr,
+                                      const TargetLibraryInfo *TLI = nullptr,
+                                      const DominatorTree *DT = nullptr);
 } // end namespace llvm
 
 #endif