diff --git a/docs/CommandLine.html b/docs/CommandLine.html
index 1d46720..a418dcb 100644
--- a/docs/CommandLine.html
+++ b/docs/CommandLine.html
@@ -1398,7 +1398,7 @@
     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 e176435..f537066 100644
--- a/docs/WritingAnLLVMPass.html
+++ b/docs/WritingAnLLVMPass.html
@@ -436,7 +436,7 @@
 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 @@
 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 03e9af4..6c65dc7 100644
--- a/include/llvm/CodeGen/InstrSelection.h
+++ b/include/llvm/CodeGen/InstrSelection.h
@@ -40,7 +40,7 @@
 // 
 // 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 662f11e..60707ba 100644
--- 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 00dbfe2..e451b54 100644
--- 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 efccc74..f8677d6 100644
--- a/include/llvm/DerivedTypes.h
+++ b/include/llvm/DerivedTypes.h
@@ -383,7 +383,7 @@
 
 
 // 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 09c08b8..931ae41 100644
--- a/include/llvm/InstrTypes.h
+++ b/include/llvm/InstrTypes.h
@@ -111,7 +111,7 @@
   /// 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 f0664c3..4ea2c99 100644
--- a/include/llvm/Target/MRegisterInfo.h
+++ b/include/llvm/Target/MRegisterInfo.h
@@ -109,7 +109,7 @@
   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 8a420ea..10708b2 100644
--- a/include/llvm/Type.h
+++ b/include/llvm/Type.h
@@ -184,7 +184,7 @@
   }
 
   /// 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 835169a..49a599f 100644
--- 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 aa5b29d..f99160d 100644
--- a/lib/CodeGen/RegAlloc/RegClass.h
+++ b/lib/CodeGen/RegAlloc/RegClass.h
@@ -17,7 +17,7 @@
 //-----------------------------------------------------------------------------
 // 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 835169a..49a599f 100644
--- 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 aa5b29d..f99160d 100644
--- a/lib/Target/SparcV9/RegAlloc/RegClass.h
+++ b/lib/Target/SparcV9/RegAlloc/RegClass.h
@@ -17,7 +17,7 @@
 //-----------------------------------------------------------------------------
 // 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 a22cdce..ffb57d0 100644
--- a/lib/Transforms/Scalar/ADCE.cpp
+++ b/lib/Transforms/Scalar/ADCE.cpp
@@ -96,13 +96,13 @@
 
 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 5f87a38..ac7be3a 100644
--- a/lib/Transforms/TransformInternals.h
+++ b/lib/Transforms/TransformInternals.h
@@ -94,7 +94,7 @@
   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 8d75ae8..97e2b99 100644
--- 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 eb93da3..7a68348 100644
--- a/lib/VMCore/Constants.cpp
+++ b/lib/VMCore/Constants.cpp
@@ -31,7 +31,7 @@
 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 d74433a..617ee46 100644
--- a/lib/VMCore/Type.cpp
+++ b/lib/VMCore/Type.cpp
@@ -102,7 +102,7 @@
 }
 
 // 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 5a88986..a4daeee 100644
--- a/lib/VMCore/iOperators.cpp
+++ b/lib/VMCore/iOperators.cpp
@@ -130,7 +130,7 @@
 // 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())