}
-// ReadArchiveFile - Read bytecode files from the specfied .a file, returning
+// ReadArchiveFile - Read bytecode files from the specified .a file, returning
// true on error, or false on success. This does not support reading files from
// standard input.
//
}
-// ReadArchiveFile - Read bytecode files from the specfied .a file, returning
+// ReadArchiveFile - Read bytecode files from the specified .a file, returning
// true on error, or false on success. This does not support reading files from
// standard input.
//
}
-// ReadArchiveFile - Read bytecode files from the specfied .a file, returning
+// ReadArchiveFile - Read bytecode files from the specified .a file, returning
// true on error, or false on success. This does not support reading files from
// standard input.
//
// constant pools.
//
// Note that this library should be as fast as possible, reentrant, and
-// threadsafe!!
+// thread-safe!!
//
//===----------------------------------------------------------------------===//
-// parseTypeConstants - We have to use this wierd code to handle recursive
+// parseTypeConstants - We have to use this weird code to handle recursive
// types. We know that recursive types will only reference the current slab of
// values in the type plane, but they can forward reference types before they
// have been read. For example, Type #0 might be '{ Ty#1 }' and Type #1 might
// be 'Ty#0*'. When reading Type #0, type number one doesn't exist. To fix
-// this ugly problem, we pesimistically insert an opaque type for each type we
+// this ugly problem, we pessimistically insert an opaque type for each type we
// are about to read. This means that forward references will resolve to
// something and when we reread the type later, we can replace the opaque type
// with a new resolved concrete type.
if (!(GV = dyn_cast<GlobalValue>(Val))) return true;
BCR_TRACE(5, "Value Found in ValueTable!\n");
} else if (RevisionNum > 0) {
- // Revision #0 could have forward references to globals that were wierd.
+ // Revision #0 could have forward references to globals that were weird.
// We got rid of this in subsequent revs.
return true;
} else { // Nope... find or create a forward ref. for it
new SwitchInst(getValue(Raw.Ty, Raw.Arg1),
cast<BasicBlock>(getValue(Type::LabelTy, Raw.Arg2)));
Res = I;
- if (Raw.NumOperands < 3) return false; // No destinations? Wierd.
+ if (Raw.NumOperands < 3) return false; // No destinations? Weird.
if (Raw.NumOperands == 3 || Raw.VarArgs->size() & 1) {
std::cerr << "Switch statement with odd number of arguments!\n";
BCR_TRACE(2, "Global Variable of type: " << *Ty << "\n");
ResolveReferencesToValue(GV, (unsigned)DestSlot);
- if (VarType & 2) { // Does it have an initalizer?
+ if (VarType & 2) { // Does it have an initializer?
unsigned InitSlot;
if (read_vbr(Buf, End, InitSlot)) return true;
GlobalInits.push_back(std::make_pair(GV, InitSlot));
}
-// outputInstrVarArgsCall - Output the obsurdly annoying varargs function calls.
+// outputInstrVarArgsCall - Output the absurdly annoying varargs function calls.
// This are more annoying than most because the signature of the call does not
// tell us anything about the types of the arguments in the varargs portion.
// Because of this, we encode (as type 0) all of the argument types explicitly
}
// If we weren't handled before here, we either have a large number of
- // operands or a large operand index that we are refering to.
+ // operands or a large operand index that we are referring to.
outputInstructionFormat0(&I, Opcode, Table, Type, Out);
}
// This library implements the functionality defined in llvm/Bytecode/Writer.h
//
// Note that this file uses an unusual technique of outputting all the bytecode
-// to a deque of unsigned char's, then copies the deque to an ostream. The
+// to a deque of unsigned chare, then copies the deque to an ostream. The
// reason for this is that we must do "seeking" in the stream to do back-
// patching, and some very important ostreams that we want to support (like
// pipes) do not support seeking. :( :( :(
const std::vector<const Value*> &Plane = Table.getPlane(pno);
if (!Plane.empty()) { // Skip empty type planes...
unsigned ValNo = 0;
- if (isFunction) // Don't reemit module constants
+ if (isFunction) // Don't re-emit module constants
ValNo += Table.getModuleLevel(pno);
if (pno >= Type::FirstDerivedTyID) {
}
//----------------------------------------------------------------------------
-// This method initally creates interference graphs (one in each reg class)
+// This method initially creates interference graphs (one in each reg class)
// and IGNodeList (one in each IG). The actual nodes will be pushed later.
//----------------------------------------------------------------------------
void PhyRegAlloc::createIGNodeListsAndIGs() {
//----------------------------------------------------------------------------
// This method will add all interferences at for a given instruction.
-// Interence occurs only if the LR of Def (Inst or Arg) is of the same reg
+// Interference occurs only if the LR of Def (Inst or Arg) is of the same reg
// class as that of live var. The live var passed to this function is the
// LVset AFTER the instruction
//----------------------------------------------------------------------------
bool isCallInst = TM.getInstrInfo().isCall(MInst->getOpCode());
if (isCallInst ) {
- // set the isCallInterference flag of each live range wich extends
- // accross this call instruction. This information is used by graph
- // coloring algo to avoid allocating volatile colors to live ranges
+ // set the isCallInterference flag of each live range which extends
+ // across this call instruction. This information is used by graph
+ // coloring algorithm to avoid allocating volatile colors to live ranges
// that span across calls (since they have to be saved/restored)
//
setCallInterferences(MInst, &LVSetAI);
} // for all BBs in function
- // add interferences for function arguments. Since there are no explict
+ // add interferences for function arguments. Since there are no explicit
// defs in the function for args, we have to add them manually
//
addInterferencesForArgs();
//--------------------------------------------------------------------------
-// Pseudo instructions will be exapnded to multiple instructions by the
+// Pseudo-instructions will be expanded to multiple instructions by the
// assembler. Consequently, all the opernds must get distinct registers.
// Therefore, we mark all operands of a pseudo instruction as they interfere
// with one another.
//----------------------------------------------------------------------------
// This method is called after register allocation is complete to set the
-// allocated reisters in the machine code. This code will add register numbers
+// allocated registers in the machine code. This code will add register numbers
// to MachineOperands that contain a Value. Also it calls target specific
// methods to produce caller saving instructions. At the end, it adds all
// additional instructions produced by the register allocator to the
// if it contains many spilled operands. Each time it is called, it finds
// a register which is not live at that instruction and also which is not
// used by other spilled operands of the same instruction. Then it uses
-// this register temporarily to accomodate the spilled value.
+// this register temporarily to accommodate the spilled value.
//----------------------------------------------------------------------------
void PhyRegAlloc::insertCode4SpilledLR(const LiveRange *LR,
//----------------------------------------------------------------------------
-// This method inserts caller saving/restoring instructons before/after
+// This method inserts caller saving/restoring instructions before/after
// a call machine instruction. The caller saving/restoring instructions are
// inserted like:
// ** caller saving instructions
//----------------------------------------------------------------------------
// This method is called to get a new unused register that can be used
-// to accomodate a temporary value. This method may be called several times
+// to accommodate a temporary value. This method may be called several times
// for a single machine instruction. Each time it is called, it finds a
// register which is not live at that instruction and also which is not used
// by other spilled operands of the same instruction. Return register number
//----------------------------------------------------------------------------
// The following method will set the stack offsets of the live ranges that
-// are decided to be spillled. This must be called just after coloring the
+// are decided to be spilled. This must be called just after coloring the
// LRs using the graph coloring algo. For each live range that is spilled,
// this method allocate a new spill position on the stack.
//----------------------------------------------------------------------------
for (unsigned rc=0; rc < NumOfRegClasses ; rc++)
RegClassList[rc]->colorAllRegs();
- // Atter graph coloring, if some LRs did not receive a color (i.e, spilled)
- // a poistion for such spilled LRs
+ // After graph coloring, if some LRs did not receive a color (i.e, spilled)
+ // a position for such spilled LRs
//
allocateStackSpace4SpilledLRs();
//
IGNodeSpill->pushOnStack();
- // now push NON-constrined ones, if any
+ // now push NON-constrained ones, if any
//
NeedMoreSpills = !pushUnconstrainedIGNodes();
//----------------------------------------------------------------------------
-// Get the IGNode withe the minimum spill cost
+// Get the IGNode with the minimum spill cost
//----------------------------------------------------------------------------
IGNode * RegClass::getIGNodeWithMinSpillCost()
{
IGNode *NeighIGNode = Node->getAdjIGNode(n);
LiveRange *NeighLR = NeighIGNode->getParentLR();
- // Don't use a color if it is in use by the neighbour,
- // or is suggested for use by the neighbour,
+ // Don't use a color if it is in use by the neighbor,
+ // or is suggested for use by the neighbor,
// markColorsUsed() should be given the color and the reg type for
// LR, not for NeighLR, because it should mark registers used based on
// the type we are looking for, not on the regType for the neighbour.
BasicBlock *Prev = BB->getPrev();
// Don't print the label for the basic block if there are no uses, or if the
- // only terminator use is the precessor basic block's terminator. We have
+ // only terminator use is the predecessor basic block's terminator. We have
// to scan the use list because PHI nodes use basic blocks too but do not
// require a label to be generated.
//
}
}
-// Brach instruction printing - Avoid printing out a brach to a basic block that
-// immediately succeeds the current one.
+// Branch instruction printing - Avoid printing out a branch to a basic block
+// that immediately succeeds the current one.
//
void CWriter::visitBranchInst(BranchInst &I) {
if (I.isConditional()) {
case LLVMIntrinsic::setjmp:
case LLVMIntrinsic::sigsetjmp:
- // This instrinsic should never exist in the program, but until we get
+ // This intrinsic should never exist in the program, but until we get
// setjmp/longjmp transformations going on, we should codegen it to
// something reasonable. This will allow code that never calls longjmp
// to work.
BasicBlock *Prev = BB->getPrev();
// Don't print the label for the basic block if there are no uses, or if the
- // only terminator use is the precessor basic block's terminator. We have
+ // only terminator use is the predecessor basic block's terminator. We have
// to scan the use list because PHI nodes use basic blocks too but do not
// require a label to be generated.
//
}
}
-// Brach instruction printing - Avoid printing out a brach to a basic block that
-// immediately succeeds the current one.
+// Branch instruction printing - Avoid printing out a branch to a basic block
+// that immediately succeeds the current one.
//
void CWriter::visitBranchInst(BranchInst &I) {
if (I.isConditional()) {
case LLVMIntrinsic::setjmp:
case LLVMIntrinsic::sigsetjmp:
- // This instrinsic should never exist in the program, but until we get
+ // This intrinsic should never exist in the program, but until we get
// setjmp/longjmp transformations going on, we should codegen it to
// something reasonable. This will allow code that never calls longjmp
// to work.
}
//----------------------------------------------------------------------------
-// This method initally creates interference graphs (one in each reg class)
+// This method initially creates interference graphs (one in each reg class)
// and IGNodeList (one in each IG). The actual nodes will be pushed later.
//----------------------------------------------------------------------------
void PhyRegAlloc::createIGNodeListsAndIGs() {
//----------------------------------------------------------------------------
// This method will add all interferences at for a given instruction.
-// Interence occurs only if the LR of Def (Inst or Arg) is of the same reg
+// Interference occurs only if the LR of Def (Inst or Arg) is of the same reg
// class as that of live var. The live var passed to this function is the
// LVset AFTER the instruction
//----------------------------------------------------------------------------
bool isCallInst = TM.getInstrInfo().isCall(MInst->getOpCode());
if (isCallInst ) {
- // set the isCallInterference flag of each live range wich extends
- // accross this call instruction. This information is used by graph
- // coloring algo to avoid allocating volatile colors to live ranges
+ // set the isCallInterference flag of each live range which extends
+ // across this call instruction. This information is used by graph
+ // coloring algorithm to avoid allocating volatile colors to live ranges
// that span across calls (since they have to be saved/restored)
//
setCallInterferences(MInst, &LVSetAI);
} // for all BBs in function
- // add interferences for function arguments. Since there are no explict
+ // add interferences for function arguments. Since there are no explicit
// defs in the function for args, we have to add them manually
//
addInterferencesForArgs();
//--------------------------------------------------------------------------
-// Pseudo instructions will be exapnded to multiple instructions by the
+// Pseudo-instructions will be expanded to multiple instructions by the
// assembler. Consequently, all the opernds must get distinct registers.
// Therefore, we mark all operands of a pseudo instruction as they interfere
// with one another.
//----------------------------------------------------------------------------
// This method is called after register allocation is complete to set the
-// allocated reisters in the machine code. This code will add register numbers
+// allocated registers in the machine code. This code will add register numbers
// to MachineOperands that contain a Value. Also it calls target specific
// methods to produce caller saving instructions. At the end, it adds all
// additional instructions produced by the register allocator to the
// if it contains many spilled operands. Each time it is called, it finds
// a register which is not live at that instruction and also which is not
// used by other spilled operands of the same instruction. Then it uses
-// this register temporarily to accomodate the spilled value.
+// this register temporarily to accommodate the spilled value.
//----------------------------------------------------------------------------
void PhyRegAlloc::insertCode4SpilledLR(const LiveRange *LR,
//----------------------------------------------------------------------------
-// This method inserts caller saving/restoring instructons before/after
+// This method inserts caller saving/restoring instructions before/after
// a call machine instruction. The caller saving/restoring instructions are
// inserted like:
// ** caller saving instructions
//----------------------------------------------------------------------------
// This method is called to get a new unused register that can be used
-// to accomodate a temporary value. This method may be called several times
+// to accommodate a temporary value. This method may be called several times
// for a single machine instruction. Each time it is called, it finds a
// register which is not live at that instruction and also which is not used
// by other spilled operands of the same instruction. Return register number
//----------------------------------------------------------------------------
// The following method will set the stack offsets of the live ranges that
-// are decided to be spillled. This must be called just after coloring the
+// are decided to be spilled. This must be called just after coloring the
// LRs using the graph coloring algo. For each live range that is spilled,
// this method allocate a new spill position on the stack.
//----------------------------------------------------------------------------
for (unsigned rc=0; rc < NumOfRegClasses ; rc++)
RegClassList[rc]->colorAllRegs();
- // Atter graph coloring, if some LRs did not receive a color (i.e, spilled)
- // a poistion for such spilled LRs
+ // After graph coloring, if some LRs did not receive a color (i.e, spilled)
+ // a position for such spilled LRs
//
allocateStackSpace4SpilledLRs();
//
IGNodeSpill->pushOnStack();
- // now push NON-constrined ones, if any
+ // now push NON-constrained ones, if any
//
NeedMoreSpills = !pushUnconstrainedIGNodes();
//----------------------------------------------------------------------------
-// Get the IGNode withe the minimum spill cost
+// Get the IGNode with the minimum spill cost
//----------------------------------------------------------------------------
IGNode * RegClass::getIGNodeWithMinSpillCost()
{
IGNode *NeighIGNode = Node->getAdjIGNode(n);
LiveRange *NeighLR = NeighIGNode->getParentLR();
- // Don't use a color if it is in use by the neighbour,
- // or is suggested for use by the neighbour,
+ // Don't use a color if it is in use by the neighbor,
+ // or is suggested for use by the neighbor,
// markColorsUsed() should be given the color and the reg type for
// LR, not for NeighLR, because it should mark registers used based on
// the type we are looking for, not on the regType for the neighbour.
projects / oota-llvm.git / commitdiff