Fix a typo 'iff' => 'if'

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

84 files changed, 295 insertions, 295 deletions

diff --git a/autoconf/m4/libtool.m4 b/autoconf/m4/libtool.m4
index 05af7a2ee3..f58817e0ef 100644
--- a/autoconf/m4/libtool.m4
+++ b/autoconf/m4/libtool.m4
@@ -6082,7 +6082,7 @@ _LT_EOF
       *)
  	# The compiler driver will combine linker options so we
  	# cannot just pass the convience library names through
- 	# without $wl, iff we do not link with $LD.
+ 	# without $wl, if we do not link with $LD.
  	# Luckily, gcc supports the same syntax we need for Sun Studio.
  	# Supported since Solaris 2.6 (maybe 2.5.1?)
  	case $wlarc in
diff --git a/include/llvm/ADT/APFloat.h b/include/llvm/ADT/APFloat.h
index 5a625a4c83..ea15fd6e29 100644
--- a/include/llvm/ADT/APFloat.h
+++ b/include/llvm/ADT/APFloat.h
@@ -200,7 +200,7 @@ namespace llvm {
 
     /// getNaN - Factory for QNaN values.
     ///
-    /// \param Negative - True iff the NaN generated should be negative.
+    /// \param Negative - True if the NaN generated should be negative.
     /// \param type - The unspecified fill bits for creating the NaN, 0 by
     /// default.  The value is truncated as necessary.
     static APFloat getNaN(const fltSemantics &Sem, bool Negative = false,
@@ -230,20 +230,20 @@ namespace llvm {
     /// getLargest - Returns the largest finite number in the given
     /// semantics.
     ///
-    /// \param Negative - True iff the number should be negative
+    /// \param Negative - True if the number should be negative
     static APFloat getLargest(const fltSemantics &Sem, bool Negative = false);
 
     /// getSmallest - Returns the smallest (by magnitude) finite number
     /// in the given semantics.  Might be denormalized, which implies a
     /// relative loss of precision.
     ///
-    /// \param Negative - True iff the number should be negative
+    /// \param Negative - True if the number should be negative
     static APFloat getSmallest(const fltSemantics &Sem, bool Negative = false);
 
     /// getSmallestNormalized - Returns the smallest (by magnitude)
     /// normalized finite number in the given semantics.
     ///
-    /// \param Negative - True iff the number should be negative
+    /// \param Negative - True if the number should be negative
     static APFloat getSmallestNormalized(const fltSemantics &Sem,
                                          bool Negative = false);
 
diff --git a/include/llvm/ADT/SetVector.h b/include/llvm/ADT/SetVector.h
index 965f0deaca..dcd88376b0 100644
--- a/include/llvm/ADT/SetVector.h
+++ b/include/llvm/ADT/SetVector.h
@@ -96,7 +96,7 @@ public:
     return vector_[n];
   }
 
-  /// @returns true iff the element was inserted into the SetVector.
+  /// @returns true if the element was inserted into the SetVector.
   /// @brief Insert a new element into the SetVector.
   bool insert(const value_type &X) {
     bool result = set_.insert(X);
diff --git a/include/llvm/ADT/SparseBitVector.h b/include/llvm/ADT/SparseBitVector.h
index 791f1082c2..66a5613237 100644
--- a/include/llvm/ADT/SparseBitVector.h
+++ b/include/llvm/ADT/SparseBitVector.h
@@ -763,7 +763,7 @@ public:
     return false;
   }
 
-  // Return true iff all bits set in this SparseBitVector are
+  // Return true if all bits set in this SparseBitVector are
   // also set in RHS.
   bool contains(const SparseBitVector<ElementSize> &RHS) const {
     SparseBitVector<ElementSize> Result(*this);
diff --git a/include/llvm/Analysis/Dominators.h b/include/llvm/Analysis/Dominators.h
index a1cc196eae..22bbc2aefd 100644
--- a/include/llvm/Analysis/Dominators.h
+++ b/include/llvm/Analysis/Dominators.h
@@ -346,7 +346,7 @@ public:
   DomTreeNodeBase<NodeT> *getRootNode() { return RootNode; }
   const DomTreeNodeBase<NodeT> *getRootNode() const { return RootNode; }
 
-  /// properlyDominates - Returns true iff this dominates N and this != N.
+  /// properlyDominates - Returns true if this dominates N and this != N.
   /// Note that this is not a constant time operation!
   ///
   bool properlyDominates(const DomTreeNodeBase<NodeT> *A,
@@ -372,7 +372,7 @@ public:
     return A;
   }
 
-  /// dominates - Returns true iff A dominates B.  Note that this is not a
+  /// dominates - Returns true if A dominates B.  Note that this is not a
   /// constant time operation!
   ///
   inline bool dominates(const DomTreeNodeBase<NodeT> *A,
diff --git a/include/llvm/Analysis/LibCallSemantics.h b/include/llvm/Analysis/LibCallSemantics.h
index f5a9e96cbd..670306872d 100644
--- a/include/llvm/Analysis/LibCallSemantics.h
+++ b/include/llvm/Analysis/LibCallSemantics.h
@@ -31,7 +31,7 @@ namespace llvm {
   /// pointer is the result of a call to "__error()".
   ///
   /// Locations can also be defined in a constant-sensitive way.  For example,
-  /// it is possible to define a location that returns true iff it is passed
+  /// it is possible to define a location that returns true if it is passed
   /// into the call as a specific argument.  This is useful for modeling things
   /// like "printf", which can store to memory, but only through pointers passed
   /// with a '%n' constraint.
diff --git a/include/llvm/Analysis/ScalarEvolution.h b/include/llvm/Analysis/ScalarEvolution.h
index c8c249a1b1..2e7d9ba857 100644
--- a/include/llvm/Analysis/ScalarEvolution.h
+++ b/include/llvm/Analysis/ScalarEvolution.h
@@ -831,7 +831,7 @@ namespace llvm {
                           const SCEV *LHS, const SCEV *RHS);
 
     /// SimplifyICmpOperands - Simplify LHS and RHS in a comparison with
-    /// predicate Pred. Return true iff any changes were made. If the
+    /// predicate Pred. Return true if any changes were made. If the
     /// operands are provably equal or inequal, LHS and RHS are set to
     /// the same value and Pred is set to either ICMP_EQ or ICMP_NE.
     ///
diff --git a/include/llvm/Analysis/ScalarEvolutionExpressions.h b/include/llvm/Analysis/ScalarEvolutionExpressions.h
index ded12974fa..5e06c0a43b 100644
--- a/include/llvm/Analysis/ScalarEvolutionExpressions.h
+++ b/include/llvm/Analysis/ScalarEvolutionExpressions.h
@@ -318,7 +318,7 @@ namespace llvm {
     /// an expressions A+B*x where A and B are loop invariant values.
     bool isAffine() const {
       // We know that the start value is invariant.  This expression is thus
-      // affine iff the step is also invariant.
+      // affine if the step is also invariant.
       return getNumOperands() == 2;
     }
 
diff --git a/include/llvm/Bitcode/Archive.h b/include/llvm/Bitcode/Archive.h
index 4fd4b5d90a..892bfe8314 100644
--- a/include/llvm/Bitcode/Archive.h
+++ b/include/llvm/Bitcode/Archive.h
@@ -108,27 +108,27 @@ class ArchiveMember : public ilist_node<ArchiveMember> {
     /// @brief Get the data content of the archive member
     const char* getData() const { return data; }
 
-    /// @returns true iff the member is a SVR4 (non-LLVM) symbol table
+    /// @returns true if the member is a SVR4 (non-LLVM) symbol table
     /// @brief Determine if this member is a SVR4 symbol table.
     bool isSVR4SymbolTable() const { return flags&SVR4SymbolTableFlag; }
 
-    /// @returns true iff the member is a BSD4.4 (non-LLVM) symbol table
+    /// @returns true if the member is a BSD4.4 (non-LLVM) symbol table
     /// @brief Determine if this member is a BSD4.4 symbol table.
     bool isBSD4SymbolTable() const { return flags&BSD4SymbolTableFlag; }
 
-    /// @returns true iff the archive member is the LLVM symbol table
+    /// @returns true if the archive member is the LLVM symbol table
     /// @brief Determine if this member is the LLVM symbol table.
     bool isLLVMSymbolTable() const { return flags&LLVMSymbolTableFlag; }
 
-    /// @returns true iff the archive member is the ar(1) string table
+    /// @returns true if the archive member is the ar(1) string table
     /// @brief Determine if this member is the ar(1) string table.
     bool isStringTable() const { return flags&StringTableFlag; }
 
-    /// @returns true iff the archive member is a bitcode file.
+    /// @returns true if the archive member is a bitcode file.
     /// @brief Determine if this member is a bitcode file.
     bool isBitcode() const { return flags&BitcodeFlag; }
 
-    /// @returns true iff the file name contains a path (directory) component.
+    /// @returns true if the file name contains a path (directory) component.
     /// @brief Determine if the member has a path
     bool hasPath() const { return flags&HasPathFlag; }
 
@@ -137,7 +137,7 @@ class ArchiveMember : public ilist_node<ArchiveMember> {
     /// separator character (/). To avoid this, a "long format" member name is
     /// allowed that doesn't have this restriction. This method determines if
     /// that "long format" is used for this member.
-    /// @returns true iff the file name uses the long form
+    /// @returns true if the file name uses the long form
     /// @brief Determine if the member has a long file name
     bool hasLongFilename() const { return flags&HasLongFilenameFlag; }
 
diff --git a/include/llvm/CodeGen/FunctionLoweringInfo.h b/include/llvm/CodeGen/FunctionLoweringInfo.h
index 8cf22eca4f..794a95a03b 100644
--- a/include/llvm/CodeGen/FunctionLoweringInfo.h
+++ b/include/llvm/CodeGen/FunctionLoweringInfo.h
@@ -58,7 +58,7 @@ public:
   MachineFunction *MF;
   MachineRegisterInfo *RegInfo;
   BranchProbabilityInfo *BPI;
-  /// CanLowerReturn - true iff the function's return value can be lowered to
+  /// CanLowerReturn - true if the function's return value can be lowered to
   /// registers.
   bool CanLowerReturn;
 
diff --git a/include/llvm/CodeGen/ISDOpcodes.h b/include/llvm/CodeGen/ISDOpcodes.h
index 5d0a3b4c70..ddf1b7d17d 100644
--- a/include/llvm/CodeGen/ISDOpcodes.h
+++ b/include/llvm/CodeGen/ISDOpcodes.h
@@ -340,7 +340,7 @@ namespace ISD {
     /// condition code in op #4, a CondCodeSDNode.
     SELECT_CC,
 
-    /// SetCC operator - This evaluates to a true value iff the condition is
+    /// SetCC operator - This evaluates to a true value if the condition is
     /// true.  If the result value type is not i1 then the high bits conform
     /// to getBooleanContents.  The operands to this are the left and right
     /// operands to compare (ops #0, and #1) and the condition code to compare
diff --git a/include/llvm/CodeGen/MachineBranchProbabilityInfo.h b/include/llvm/CodeGen/MachineBranchProbabilityInfo.h
index 12189ceb7f..87f595adfa 100644
--- a/include/llvm/CodeGen/MachineBranchProbabilityInfo.h
+++ b/include/llvm/CodeGen/MachineBranchProbabilityInfo.h
@@ -69,7 +69,7 @@ public:
 
   // Return a probability as a fraction between 0 (0% probability) and
   // 1 (100% probability), however the value is never equal to 0, and can be 1
-  // only iff SRC block has only one successor.
+  // only if SRC block has only one successor.
   // NB: This routine's complexity is linear on the number of successors of
   // Src. Querying sequentially for each successor's probability is a quadratic
   // query pattern.
@@ -77,7 +77,7 @@ public:
                                        MachineBasicBlock *Dst) const;
 
   // Print value between 0 (0% probability) and 1 (100% probability),
-  // however the value is never equal to 0, and can be 1 only iff SRC block
+  // however the value is never equal to 0, and can be 1 only if SRC block
   // has only one successor.
   raw_ostream &printEdgeProbability(raw_ostream &OS, MachineBasicBlock *Src,
                                     MachineBasicBlock *Dst) const;
diff --git a/include/llvm/CodeGen/SelectionDAG.h b/include/llvm/CodeGen/SelectionDAG.h
index 619ee69943..a8f5f5fa09 100644
--- a/include/llvm/CodeGen/SelectionDAG.h
+++ b/include/llvm/CodeGen/SelectionDAG.h
@@ -1021,7 +1021,7 @@ public:
   /// ISD::ADD with a ConstantSDNode on the right-hand side, or if it is an
   /// ISD::OR with a ConstantSDNode that is guaranteed to have the same
   /// semantics as an ADD.  This handles the equivalence:
-  ///     X|Cst == X+Cst iff X&Cst = 0.
+  ///     X|Cst == X+Cst if X&Cst = 0.
   bool isBaseWithConstantOffset(SDValue Op) const;
 
   /// isKnownNeverNan - Test whether the given SDValue is known to never be NaN.
diff --git a/include/llvm/Constants.h b/include/llvm/Constants.h
index 85fed4259d..097b0f52ec 100644
--- a/include/llvm/Constants.h
+++ b/include/llvm/Constants.h
@@ -170,17 +170,17 @@ public:
     return Val == 1;
   }
 
-  /// This function will return true iff every bit in this constant is set
+  /// This function will return true if every bit in this constant is set
   /// to true.
-  /// @returns true iff this constant's bits are all set to true.
+  /// @returns true if this constant's bits are all set to true.
   /// @brief Determine if the value is all ones.
   bool isMinusOne() const { 
     return Val.isAllOnesValue();
   }
 
-  /// This function will return true iff this constant represents the largest
+  /// This function will return true if this constant represents the largest
   /// value that may be represented by the constant's type.
-  /// @returns true iff this is the largest value that may be represented 
+  /// @returns true if this is the largest value that may be represented 
   /// by this type.
   /// @brief Determine if the value is maximal.
   bool isMaxValue(bool isSigned) const {
@@ -190,7 +190,7 @@ public:
       return Val.isMaxValue();
   }
 
-  /// This function will return true iff this constant represents the smallest
+  /// This function will return true if this constant represents the smallest
   /// value that may be represented by this constant's type.
   /// @returns true if this is the