The word `dependent' has no `a'.

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

diff --git a/docs/CommandLine.html b/docs/CommandLine.html
index 1d46720f3be87ca3e61c800b4012fa209172739c..a418dcba45ded61eea2ebb7b52d71b4e5e17c218 100644 (file)
--- a/docs/CommandLine.html
+++ b/docs/CommandLine.html
@@ -1398,7 +1398,7 @@ There are two ways to use a new parser:<p>
     doesn't work if your fundemental data type is something that is already
     supported.<p>
 
-<li>Write an independant class, using it explicitly from options that need
+<li>Write an independent class, using it explicitly from options that need
     it.<p>
 
     This approach works well in situations where you would line to parse an

diff --git a/docs/WritingAnLLVMPass.html b/docs/WritingAnLLVMPass.html
index e176435a15fe599c05d78c2e93ba62d0275c664c..f537066547ac969b0a5b300e884f9236f18b4326 100644 (file)
--- a/docs/WritingAnLLVMPass.html
+++ b/docs/WritingAnLLVMPass.html
@@ -436,7 +436,7 @@ In contrast to direct <tt>Pass</tt> subclasses, direct <tt><a
 href="http://llvm.cs.uiuc.edu/doxygen/classPass.html">FunctionPass</a></tt>
 subclasses do have a predictable, local behavior that can be expected by the
 system.  All <tt>FunctionPass</tt> execute on each function in the program
-independant of all of the other functions in the program.
+independent of all of the other functions in the program.
 <tt>FunctionPass</tt>'s do not require that they are executed in a particular
 order, and <tt>FunctionPass</tt>'s do not modify external functions.<p>
 
@@ -474,7 +474,7 @@ fast).<p>
 A good example of how this method should be used is the <a
 href="http://llvm.cs.uiuc.edu/doxygen/LowerAllocations_8cpp-source.html">LowerAllocations</a>
 pass.  This pass converts <tt>malloc</tt> and <tt>free</tt> instructions into
-platform dependant <tt>malloc()</tt> and <tt>free()</tt> function calls.  It
+platform dependent <tt>malloc()</tt> and <tt>free()</tt> function calls.  It
 uses the <tt>doInitialization</tt> method to get a reference to the malloc and
 free functions that it needs, adding prototypes to the module if necessary.<p>
 

diff --git a/include/llvm/CodeGen/InstrSelection.h b/include/llvm/CodeGen/InstrSelection.h
index 03e9af416764aeb1c11f9c9e35b5aa5ca30d7172..6c65dc7eba8c7f39a228abc27d558e517692deb4 100644 (file)
--- a/include/llvm/CodeGen/InstrSelection.h
+++ b/include/llvm/CodeGen/InstrSelection.h
@@ -40,7 +40,7 @@ extern bool   ThisIsAChainRule        (int eruleno);
 // 
 // Purpose:
 //   Entry point for instruction selection using BURG.
-//   Return a pass that performs machine dependant instruction selection.
+//   Return a pass that performs machine dependent instruction selection.
 //---------------------------------------------------------------------------
 
 FunctionPass *createInstructionSelectionPass(TargetMachine &Target);

diff --git a/include/llvm/CodeGen/MachineInstr.h b/include/llvm/CodeGen/MachineInstr.h
index 662f11e531a15ea9f34246097b6ab84a45b932d4..60707ba71efe7a465629b53dd2e035f431e5b2a5 100644 (file)
--- a/include/llvm/CodeGen/MachineInstr.h
+++ b/include/llvm/CodeGen/MachineInstr.h
@@ -1,7 +1,7 @@
 //===-- llvm/CodeGen/MachineInstr.h - MachineInstr class ---------*- C++ -*--=//
 //
 // This file contains the declaration of the MachineInstr class, which is the
-// basic representation for all target dependant machine instructions used by
+// basic representation for all target dependent machine instructions used by
 // the back end.
 //
 //===----------------------------------------------------------------------===//

diff --git a/include/llvm/CodeGen/Passes.h b/include/llvm/CodeGen/Passes.h
index 00dbfe29c8e98315472eb63b428e931dabf15a66..e451b5476e04505bb17cc6642e924fefc431ca03 100644 (file)
--- a/include/llvm/CodeGen/Passes.h
+++ b/include/llvm/CodeGen/Passes.h
@@ -1,6 +1,6 @@
-//===-- Passes.h - Target independant code generation passes ----*- C++ -*-===//
+//===-- Passes.h - Target independent code generation passes ----*- C++ -*-===//
 //
-// This file defines interfaces to access the target independant code generation
+// This file defines interfaces to access the target independent code generation
 // passes provided by the LLVM backend.
 //
 //===----------------------------------------------------------------------===//

diff --git a/include/llvm/DerivedTypes.h b/include/llvm/DerivedTypes.h
index efccc74a4f4d0a4bf4e380af00a558202bd86881..f8677d635d4987e7ab76a4919a1e250e2d3e5d02 100644 (file)
--- a/include/llvm/DerivedTypes.h
+++ b/include/llvm/DerivedTypes.h
@@ -383,7 +383,7 @@ public:
 
 
 // Define some inline methods for the AbstractTypeUser.h:PATypeHandle class.
-// These are defined here because they MUST be inlined, yet are dependant on 
+// These are defined here because they MUST be inlined, yet are dependent on 
 // the definition of the Type class.  Of course Type derives from Value, which
 // contains an AbstractTypeUser instance, so there is no good way to factor out
 // the code.  Hence this bit of uglyness.

diff --git a/include/llvm/InstrTypes.h b/include/llvm/InstrTypes.h
index 09c08b8342a5d1908500d1fe32542316361dc82b..931ae41a98e516df93bb765805d28dbe3799a11b 100644 (file)
--- a/include/llvm/InstrTypes.h
+++ b/include/llvm/InstrTypes.h
@@ -111,7 +111,7 @@ public:
   /// swapOperands - Exchange the two operands to this instruction.
   /// This instruction is safe to use on any binary instruction and
   /// does not modify the semantics of the instruction.  If the
-  /// instruction is order dependant (SetLT f.e.) the opcode is
+  /// instruction is order dependent (SetLT f.e.) the opcode is
   /// changed.  If the instruction cannot be reversed (ie, it's a Div),
   /// then return true.
   ///

diff --git a/include/llvm/Target/MRegisterInfo.h b/include/llvm/Target/MRegisterInfo.h
index f0664c398aba8ad9ea18a23215ed19df16756309..4ea2c99fbaa915533750f834197c1a75d70d7a65 100644 (file)
--- a/include/llvm/Target/MRegisterInfo.h
+++ b/include/llvm/Target/MRegisterInfo.h
@@ -109,7 +109,7 @@ protected:
   virtual ~MRegisterInfo();
 public:
 
-  enum {                        // Define some target independant constants
+  enum {                        // Define some target independent constants
     /// NoRegister - This 'hard' register is a 'noop' register for all backends.
     /// This is used as the destination register for instructions that do not
     /// produce a value.  Some frontends may use this as an operand register to

diff --git a/include/llvm/Type.h b/include/llvm/Type.h
index 8a420ea805f621773077c366256e5fb136c3fa2d..10708b2426fdfad2e75dd1e9c2dcd9d2fc6b3805 100644 (file)
--- a/include/llvm/Type.h
+++ b/include/llvm/Type.h
@@ -184,7 +184,7 @@ public:
   }
 
   /// getPrimitiveSize - Return the basic size of this type if it is a primative
-  /// type.  These are fixed by LLVM and are not target dependant.  This will
+  /// type.  These are fixed by LLVM and are not target dependent.  This will
   /// return zero if the type does not have a size or is not a primitive type.
   ///
   unsigned getPrimitiveSize() const;

diff --git a/lib/CodeGen/InstrSelection/InstrSelection.cpp b/lib/CodeGen/InstrSelection/InstrSelection.cpp
index 835169aeeb8b01add074ac00737a67dcd85b2aae..49a599f548cfdae084f361a53a786065c86f571f 100644 (file)
--- a/lib/CodeGen/InstrSelection/InstrSelection.cpp
+++ b/lib/CodeGen/InstrSelection/InstrSelection.cpp
@@ -1,4 +1,4 @@
-//===- InstrSelection.cpp - Machine Independant Inst Selection Driver -----===//
+//===- InstrSelection.cpp - Machine Independent Inst Selection Driver -----===//
 //
 // Machine-independent driver file for instruction selection.  This file
 // constructs a forest of BURG instruction trees and then uses the

diff --git a/lib/CodeGen/RegAlloc/RegClass.h b/lib/CodeGen/RegAlloc/RegClass.h
index aa5b29da385154d680d1865e583181c032378c91..f99160d469e1ac70b0f16f5df80cba98c0fd3dc9 100644 (file)
--- a/lib/CodeGen/RegAlloc/RegClass.h
+++ b/lib/CodeGen/RegAlloc/RegClass.h
@@ -17,7 +17,7 @@ class TargetRegClassInfo;
 //-----------------------------------------------------------------------------
 // Class RegClass
 //
-//   Implements a machine independant register class. 
+//   Implements a machine independent register class. 
 //
 //   This is the class that contains all data structures and common algos
 //   for coloring a particular register class (e.g., int class, fp class).  

diff --git a/lib/Target/SparcV9/InstrSelection/InstrSelection.cpp b/lib/Target/SparcV9/InstrSelection/InstrSelection.cpp
index 835169aeeb8b01add074ac00737a67dcd85b2aae..49a599f548cfdae084f361a53a786065c86f571f 100644 (file)
--- a/lib/Target/SparcV9/InstrSelection/InstrSelection.cpp
+++ b/lib/Target/SparcV9/InstrSelection/InstrSelection.cpp
@@ -1,4 +1,4 @@
-//===- InstrSelection.cpp - Machine Independant Inst Selection Driver -----===//
+//===- InstrSelection.cpp - Machine Independent Inst Selection Driver -----===//
 //
 // Machine-independent driver file for instruction selection.  This file
 // constructs a forest of BURG instruction trees and then uses the

diff --git a/lib/Target/SparcV9/RegAlloc/RegClass.h b/lib/Target/SparcV9/RegAlloc/RegClass.h
index aa5b29da385154d680d1865e583181c032378c91..f99160d469e1ac70b0f16f5df80cba98c0fd3dc9 100644 (file)
--- a/lib/Target/SparcV9/RegAlloc/RegClass.h
+++ b/lib/Target/SparcV9/RegAlloc/RegClass.h
@@ -17,7 +17,7 @@ class TargetRegClassInfo;
 //-----------------------------------------------------------------------------
 // Class RegClass
 //
-//   Implements a machine independant register class. 
+//   Implements a machine independent register class. 
 //
 //   This is the class that contains all data structures and common algos
 //   for coloring a particular register class (e.g., int class, fp class).  

diff --git a/lib/Transforms/Scalar/ADCE.cpp b/lib/Transforms/Scalar/ADCE.cpp
index a22cdce641b40e620123dc226124003b2f930cde..ffb57d0d6aeb449dc1ec88d4d8b5576b70ca19f9 100644 (file)
--- a/lib/Transforms/Scalar/ADCE.cpp
+++ b/lib/Transforms/Scalar/ADCE.cpp
@@ -96,13 +96,13 @@ Pass *createAggressiveDCEPass() { return new ADCE(); }
 
 void ADCE::markBlockAlive(BasicBlock *BB) {
   // Mark the basic block as being newly ALIVE... and mark all branches that
-  // this block is control dependant on as being alive also...
+  // this block is control dependent on as being alive also...
   //
   PostDominanceFrontier &CDG = getAnalysis<PostDominanceFrontier>();
 
   PostDominanceFrontier::const_iterator It = CDG.find(BB);
   if (It != CDG.end()) {
-    // Get the blocks that this node is control dependant on...
+    // Get the blocks that this node is control dependent on...
     const PostDominanceFrontier::DomSetType &CDB = It->second;
     for_each(CDB.begin(), CDB.end(),   // Mark all their terminators as live
              bind_obj(this, &ADCE::markTerminatorLive));

diff --git a/lib/Transforms/TransformInternals.h b/lib/Transforms/TransformInternals.h
index 5f87a38cc4c19d3b1775bdd25c1280ac139e4c39..ac7be3a49f689aa41c1f64777ce51ef24c8c834e 100644 (file)
--- a/lib/Transforms/TransformInternals.h
+++ b/lib/Transforms/TransformInternals.h
@@ -94,7 +94,7 @@ struct ValueMapCache {
   typedef std::map<const Value *, Value *> ExprMapTy;
 
   // Cast Map - Cast instructions can have their source and destination values
-  // changed independantly for each part.  Because of this, our old naive
+  // changed independently for each part.  Because of this, our old naive
   // implementation would create a TWO new cast instructions, which would cause
   // all kinds of problems.  Here we keep track of the newly allocated casts, so
   // that we only create one for a particular instruction.

diff --git a/lib/Transforms/Utils/LowerAllocations.cpp b/lib/Transforms/Utils/LowerAllocations.cpp
index 8d75ae8e8c61c5dd0732f9a2174d02e6f508cad3..97e2b997cf47733d49e81e2433b09ef5a17cd722 100644 (file)
--- a/lib/Transforms/Utils/LowerAllocations.cpp
+++ b/lib/Transforms/Utils/LowerAllocations.cpp
@@ -1,6 +1,6 @@
 //===- LowerAllocations.cpp - Reduce malloc & free insts to calls ---------===//
 //
-// The LowerAllocations transformation is a target dependant tranformation
+// The LowerAllocations transformation is a target dependent tranformation
 // because it depends on the size of data types and alignment constraints.
 //
 //===----------------------------------------------------------------------===//

diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index eb93da3c1d0a9dbc009a77da20119f410eb11a01..7a6834839698c4a40237136d991ccee612ecf63d 100644 (file)
--- a/lib/VMCore/Constants.cpp
+++ b/lib/VMCore/Constants.cpp
@@ -31,7 +31,7 @@ void Constant::setName(const std::string &Name, SymbolTable *ST) {
 void Constant::destroyConstantImpl() {
   // When a Constant is destroyed, there may be lingering
   // references to the constant by other constants in the constant pool.  These
-  // constants are implicitly dependant on the module that is being deleted,
+  // constants are implicitly dependent on the module that is being deleted,
   // but they don't know that.  Because we only find out when the CPV is
   // deleted, we must now notify all of our users (that should only be
   // Constants) that they are, in fact, invalid now and should be deleted.

diff --git a/lib/VMCore/Type.cpp b/lib/VMCore/Type.cpp
index d74433a97486701271474d343cd5db7b029120ae..617ee46662129bec19421e1791933ba4f4600254 100644 (file)
--- a/lib/VMCore/Type.cpp
+++ b/lib/VMCore/Type.cpp
@@ -102,7 +102,7 @@ bool Type::isLosslesslyConvertibleTo(const Type *Ty) const {
 }
 
 // getPrimitiveSize - Return the basic size of this type if it is a primative
-// type.  These are fixed by LLVM and are not target dependant.  This will
+// type.  These are fixed by LLVM and are not target dependent.  This will
 // return zero if the type does not have a size or is not a primitive type.
 //
 unsigned Type::getPrimitiveSize() const {

diff --git a/lib/VMCore/iOperators.cpp b/lib/VMCore/iOperators.cpp
index 5a88986135bd3082389d04dceef10b7e0b6d971d..a4daeeebff5a1f7e76d08c39a417f99c5f84339a 100644 (file)
--- a/lib/VMCore/iOperators.cpp
+++ b/lib/VMCore/iOperators.cpp
@@ -130,7 +130,7 @@ const Value *BinaryOperator::getNotArgument(const BinaryOperator *Bop) {
 // swapOperands - Exchange the two operands to this instruction.  This
 // instruction is safe to use on any binary instruction and does not
 // modify the semantics of the instruction.  If the instruction is
-// order dependant (SetLT f.e.) the opcode is changed.
+// order dependent (SetLT f.e.) the opcode is changed.
 //
 bool BinaryOperator::swapOperands() {
   if (isCommutative())