Fix spelling/grammar.

llvm-svn: 9023

llvm/lib/VMCore/AsmWriter.cpp

@@ -420,7 +420,7 @@ static void WriteAsOperandInternal(std::ostream &Out, const Value *V,
       }
       if (Slot >= 0)  Out << "%" << Slot;
       else if (PrintName)
-        Out << "<badref>";     // Not embeded into a location?
+        Out << "<badref>";     // Not embedded into a location?
     }
   }
 }
@@ -708,7 +708,7 @@ void AssemblyWriter::printArgument(const Argument *Arg) {
     Out << "<badref>";
 }
 
-// printBasicBlock - This member is called for each basic block in a methd.
+// printBasicBlock - This member is called for each basic block in a method.
 //
 void AssemblyWriter::printBasicBlock(const BasicBlock *BB) {
   if (BB->hasName()) {              // Print out the label if it exists...
@@ -762,7 +762,7 @@ void AssemblyWriter::printInfoComment(const Value &V) {
   }
 }
 
-// printInstruction - This member is called for each Instruction in a methd.
+// printInstruction - This member is called for each Instruction in a method.
 //
 void AssemblyWriter::printInstruction(const Instruction &I) {
   Out << "\t";

llvm/lib/VMCore/Function.cpp

@@ -140,7 +140,7 @@ const Type *Function::getReturnType() const {
 // go" of all references that they are maintaining.  This allows one to
 // 'delete' a whole class at a time, even though there may be circular
 // references... first all references are dropped, and all use counts go to
-// zero.  Then everything is delete'd for real.  Note that no operations are
+// zero.  Then everything is deleted for real.  Note that no operations are
 // valid on an object that has "dropped all references", except operator 
 // delete.
 //
@@ -152,7 +152,7 @@ void Function::dropAllReferences() {
 
 /// getIntrinsicID - This method returns the ID number of the specified
 /// function, or LLVMIntrinsic::not_intrinsic if the function is not an
-/// instrinsic, or if the pointer is null.  This value is always defined to be
+/// intrinsic, or if the pointer is null.  This value is always defined to be
 /// zero to allow easy checking for whether a function is intrinsic or not.  The
 /// particular intrinsic functions which correspond to this value are defined in
 /// llvm/Intrinsics.h.

llvm/lib/VMCore/Instruction.cpp

@@ -119,7 +119,7 @@ bool Instruction::isAssociative(unsigned Opcode, const Type *Ty) {
 
 /// isCommutative - Return true if the instruction is commutative:
 ///
-///   Commutative operators satistify: (x op y) === (y op x)
+///   Commutative operators satisfy: (x op y) === (y op x)
 ///
 /// In LLVM, these are the associative operators, plus SetEQ and SetNE, when
 /// applied to any type.

llvm/lib/VMCore/Module.cpp

@@ -232,7 +232,7 @@ std::string Module::getTypeName(const Type *Ty) {
 // of all references that they are maintaining.  This allows one to 'delete' a
 // whole module at a time, even though there may be circular references... first
 // all references are dropped, and all use counts go to zero.  Then everything
-// is delete'd for real.  Note that no operations are valid on an object that
+// is deleted for real.  Note that no operations are valid on an object that
 // has "dropped all references", except operator delete.
 //
 void Module::dropAllReferences() {

llvm/lib/VMCore/SymbolTableListTraitsImpl.h

@@ -62,11 +62,11 @@ void SymbolTableListTraits<ValueSubClass,ItemParentClass,SymTabClass,SubClass>
 ::transferNodesFromList(iplist<ValueSubClass, ilist_traits<ValueSubClass> > &L2,
                         ilist_iterator<ValueSubClass> first,
                         ilist_iterator<ValueSubClass> last) {
-  // We only have to do work here if transfering instructions between BB's
+  // We only have to do work here if transferring instructions between BBs
   ItemParentClass *NewIP = ItemParent, *OldIP = L2.ItemParent;
   if (NewIP == OldIP) return;  // No work to do at all...
 
-  // We only have to update symbol table entries if we are transfering the
+  // We only have to update symbol table entries if we are transferring the
   // instructions to a different symtab object...
   SymTabClass *NewSTO = SymTabObject, *OldSTO = L2.SymTabObject;
   if (NewSTO != OldSTO) {
@@ -80,7 +80,7 @@ void SymbolTableListTraits<ValueSubClass,ItemParentClass,SymTabClass,SubClass>
         NewSTO->getSymbolTable().insert(&V);
     }
   } else {
-    // Just transfering between blocks in the same function, simply update the
+    // Just transferring between blocks in the same function, simply update the
     // parent fields in the instructions...
     for (; first != last; ++first)
       first->setParent(NewIP);

llvm/lib/VMCore/Type.cpp

@@ -104,7 +104,7 @@ bool Type::isLosslesslyConvertibleTo(const Type *Ty) const {
   }
 }
 
-// getPrimitiveSize - Return the basic size of this type if it is a primative
+// getPrimitiveSize - Return the basic size of this type if it is a primitive
 // 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.
 //
@@ -273,7 +273,7 @@ const Type *StructType::getTypeAtIndex(const Value *V) const {
 
 
 //===----------------------------------------------------------------------===//
-//                           Auxilliary classes
+//                           Auxiliary classes
 //===----------------------------------------------------------------------===//
 //
 // These classes are used to implement specialized behavior for each different
@@ -452,7 +452,7 @@ static bool TypesEqual(const Type *Ty, const Type *Ty2,
   if (Ty->getPrimitiveID() != Ty2->getPrimitiveID()) return false;
   if (Ty->isPrimitiveType()) return true;
   if (isa<OpaqueType>(Ty))
-    return false;  // Two nonequal opaque types are never equal
+    return false;  // Two unequal opaque types are never equal
 
   std::map<const Type*, const Type*>::iterator It = EqTypes.find(Ty);
   if (It != EqTypes.end())
@@ -825,7 +825,7 @@ void debug_type_tables() {
 // removeAbstractTypeUser - Notify an abstract type that a user of the class
 // no longer has a handle to the type.  This function is called primarily by
 // the PATypeHandle class.  When there are no users of the abstract type, it
-// is anihilated, because there is no way to get a reference to it ever again.
+// is annihilated, because there is no way to get a reference to it ever again.
 //
 void DerivedType::removeAbstractTypeUser(AbstractTypeUser *U) const {
   // Search from back to front because we will notify users from back to

llvm/lib/VMCore/Verifier.cpp

@@ -20,11 +20,11 @@
 //  * PHI nodes must have at least one entry
 //  * All basic blocks should only end with terminator insts, not contain them
 //  * The entry node to a function must not have predecessors
-//  * All Instructions must be embeded into a basic block
+//  * All Instructions must be embedded into a basic block
 //  . Function's cannot take a void typed parameter
 //  * Verify that a function's argument list agrees with it's declared type.
 //  * It is illegal to specify a name for a void value.
-//  * It is illegal to have a internal global value with no intitalizer
+//  * It is illegal to have a internal global value with no initializer
 //  * It is illegal to have a ret instruction that returns a value that does not
 //    agree with the function return value type.
 //  * Function call argument types match the function prototype
@@ -325,7 +325,7 @@ void Verifier::visitUserOp1(Instruction &I) {
 void Verifier::visitPHINode(PHINode &PN) {
   // Ensure that the PHI nodes are all grouped together at the top of the block.
   // This can be tested by checking whether the instruction before this is
-  // either nonexistant (because this is begin()) or is a PHI node.  If not,
+  // either nonexistent (because this is begin()) or is a PHI node.  If not,
   // then there is some other instruction before a PHI.
   Assert2(&PN.getParent()->front() == &PN || isa<PHINode>(PN.getPrev()),
           "PHI nodes not grouped at top of basic block!",