}
if (Slot >= 0) Out << "%" << Slot;
else if (PrintName)
- Out << "<badref>"; // Not embeded into a location?
+ Out << "<badref>"; // Not embedded into a location?
}
}
}
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...
}
}
-// 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";
// 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.
//
/// 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.
/// 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.
// 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() {
::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) {
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);
}
}
-// 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.
//
//===----------------------------------------------------------------------===//
-// Auxilliary classes
+// Auxiliary classes
//===----------------------------------------------------------------------===//
//
// These classes are used to implement specialized behavior for each different
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())
// 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
// * 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
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!",
OSDN Git Service
