Fix a typo 'iff' => 'if'

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

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

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);
 

include/llvm/ADT/SetVector.h

@@ -96,7 +96,7 @@ class SetVector {
     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);

include/llvm/ADT/SparseBitVector.h

@@ -763,7 +763,7 @@ class SparseBitVector {
     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);

include/llvm/Analysis/Dominators.h

@@ -346,7 +346,7 @@ class DominatorTreeBase : public DominatorBase<NodeT> {
   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 @@ class DominatorTreeBase : public DominatorBase<NodeT> {
     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,

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.

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.
     ///

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;
     }
 

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; }
 

include/llvm/CodeGen/FunctionLoweringInfo.h

@@ -58,7 +58,7 @@ class FunctionLoweringInfo {
   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;
 

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

include/llvm/CodeGen/MachineBranchProbabilityInfo.h

@@ -69,15 +69,15 @@ class MachineBranchProbabilityInfo : public ImmutablePass {
 
   // 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.
   BranchProbability getEdgeProbability(MachineBasicBlock *Src,
                                        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;

include/llvm/CodeGen/SelectionDAG.h

@@ -1021,7 +1021,7 @@ class SelectionDAG {
   /// 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.

include/llvm/Constants.h

@@ -170,17 +170,17 @@ class ConstantInt : public Constant {
     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 @@ class ConstantInt : public Constant {
       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 smallest value that may be represented by 
   /// this type.
@@ -202,10 +202,10 @@ class ConstantInt : public Constant {
       return Val.isMinValue();
   }
 
-  /// This function will return true iff this constant represents a value with
+  /// This function will return true if this constant represents a value with
   /// active bits bigger than 64 bits or a value greater than the given uint64_t
   /// value.
-  /// @returns true iff this constant is greater or equal to the given number.
+  /// @returns true if this constant is greater or equal to the given number.
   /// @brief Determine if the value is greater or equal to the given number.
   bool uge(uint64_t Num) const {
     return Val.getActiveBits() > 64 || Val.getZExtValue() >= Num;

include/llvm/InstrTypes.h

@@ -547,14 +547,14 @@ class CastInst : public UnaryInstruction {
   /// There are several places where we need to know if a cast instruction
   /// only deals with integer source and destination types. To simplify that
   /// logic, this method is provided.
-  /// @returns true iff the cast has only integral typed operand and dest type.
+  /// @returns true if the cast has only integral typed operand and dest type.
   /// @brief Determine if this is an integer-only cast.
   bool isIntegerCast() const;
 
   /// A lossless cast is one that does not alter the basic value. It implies
   /// a no-op cast but is more stringent, preventing things like int->float,
   /// long->double, or int->ptr.
-  /// @returns true iff the cast is lossless.
+  /// @returns true if the cast is lossless.
   /// @brief Determine if this is a lossless cast.
   bool isLosslessCast() const;
 
@@ -606,7 +606,7 @@ class CastInst : public UnaryInstruction {
 
   /// This method can be used to determine if a cast from S to DstTy using
   /// Opcode op is valid or not.
-  /// @returns true iff the proposed cast is valid.
+  /// @returns true if the proposed cast is valid.
   /// @brief Determine if a cast is valid without creating one.
   static bool castIsValid(Instruction::CastOps op, Value *S, Type *DstTy);
 

include/llvm/PassAnalysisSupport.h

@@ -94,7 +94,7 @@ class AnalysisUsage {
   void setPreservesAll() { PreservesAll = true; }
   bool getPreservesAll() const { return PreservesAll; }
 
-  /// setPreservesCFG - This function should be called by the pass, iff they do
+  /// setPreservesCFG - This function should be called by the pass, if they do
   /// not:
   ///
   ///  1. Add or remove basic blocks from the function

include/llvm/Support/PathV1.h

@@ -232,7 +232,7 @@ namespace sys {
       /// determine if the current value of \p this is a syntactically valid
       /// path name for the operating system. The path name does not need to
       /// exist, validity is simply syntactical. Empty paths are always invalid.
-      /// @returns true iff the path name is syntactically legal for the
+      /// @returns true if the path name is syntactically legal for the
       /// host operating system.
       /// @brief Determine if a path is syntactically valid or not.
       bool isValid() const;
@@ -242,7 +242,7 @@ namespace sys {
       /// if the file is empty. To get the length of the file itself, Use the
       /// PathWithStatus::getFileStatus() method and then the getSize() method
       /// on the returned FileStatus object.
-      /// @returns true iff the path is empty.
+      /// @returns true if the path is empty.
       /// @brief Determines if the path name is empty (invalid).
       bool isEmpty() const { return path.empty(); }
 

include/llvm/Support/TimeValue.h

@@ -130,12 +130,12 @@ namespace sys {
     }
 
     /// Determine if \p this is less than \p that.
-    /// @returns True iff *this < that.
+    /// @returns True if *this < that.
     /// @brief True if this < that.
     int operator < (const TimeValue &that) const { return that > *this; }
 
     /// Determine if \p this is greather than \p that.
-    /// @returns True iff *this > that.
+    /// @returns True if *this > that.
     /// @brief True if this > that.
     int operator > (const TimeValue &that) const {
       if ( this->seconds_ > that.seconds_ ) {
@@ -147,12 +147,12 @@ namespace sys {
     }
 
     /// Determine if \p this is less than or equal to \p that.
-    /// @returns True iff *this <= that.
+    /// @returns True if *this <= that.
     /// @brief True if this <= that.
     int operator <= (const TimeValue &that) const { return that >= *this; }
 
     /// Determine if \p this is greater than or equal to \p that.
-    /// @returns True iff *this >= that.
+    /// @returns True if *this >= that.
     int operator >= (const TimeValue &that) const {
       if ( this->seconds_ > that.seconds_ ) {
           return 1;
@@ -163,15 +163,15 @@ namespace sys {
     }
 
     /// Determines if two TimeValue objects represent the same moment in time.
-    /// @returns True iff *this == that.
+    /// @returns True if *this == that.
     int operator == (const TimeValue &that) const {
       return (this->seconds_ == that.seconds_) &&
              (this->nanos_ == that.nanos_);
     }
 
     /// Determines if two TimeValue objects represent times that are not the
     /// same.
-    /// @returns True iff *this != that.
+    /// @returns True if *this != that.
     int operator != (const TimeValue &that) const { return !(*this == that); }
 
     /// Adds two TimeValue objects together.

include/llvm/Type.h

@@ -398,7 +398,7 @@ class Type {
 
 private:
   /// isSizedDerivedType - Derived types like structures and arrays are sized
-  /// iff all of the members of the type are sized as well.  Since asking for
+  /// if all of the members of the type are sized as well.  Since asking for
   /// their size is relatively uncommon, move this operation out of line.
   bool isSizedDerivedType() const;
 };

include/llvm/ValueSymbolTable.h

@@ -70,7 +70,7 @@ class ValueSymbolTable {
   /// @brief Lookup a named Value.
   Value *lookup(StringRef Name) const { return vmap.lookup(Name); }
 
-  /// @returns true iff the symbol table is empty
+  /// @returns true if the symbol table is empty
   /// @brief Determine if the symbol table is empty
   inline bool empty() const { return vmap.empty(); }