provide it, allowing for powerful analyses and transformations to work well
together.<p>
-This document contains information neccesary to successfully implement this
+This document contains information necessary to successfully implement this
interface, use it, and to test both sides. It also explains some of the finer
points about what exactly results mean. If you feel that something is unclear
or should be added, please <a href="mailto:sabre@nondot.org">let me know</a>.<p>
//===----------------------------------------------------------------------===//
</pre>
-A few things to note about this particular format. The "<tt>-*- C++ -*-</tt>" string on the first line is there to tell Emacs that the source file is a C++ file, not a C file (Emacs assumes .h files are C files by default [Note that tag this is not nec
cesary in .cpp files]). The name of the file is also on the first line, along with a very short description of the purpose of the file. This is important when printing out code and flipping though lots of pages.<p>
+A few things to note about this particular format. The "<tt>-*- C++ -*-</tt>" string on the first line is there to tell Emacs that the source file is a C++ file, not a C file (Emacs assumes .h files are C files by default [Note that tag this is not nec
essary in .cpp files]). The name of the file is also on the first line, along with a very short description of the purpose of the file. This is important when printing out code and flipping though lots of pages.<p>
The main body of the description does not have to be very long in most cases. Here it's only two lines. If an algorithm is being implemented or something tricky is going on, a reference to the paper where it is published should be included, as well as any notes or "gotchas" in the code to watch out for.<p>
<h4><li>Method information</h4>
-Methods defined in a class (as well as any global functions) should also be documented properly. A quick note about what it does any a description of the borderline behaviour is all that is nec
cesary here (unless something particularly tricky or insideous is going on). The hope is that people can figure out how to use your interfaces without reading the code itself... that is the goal metric.<p>
+Methods defined in a class (as well as any global functions) should also be documented properly. A quick note about what it does any a description of the borderline behaviour is all that is nec
essary here (unless something particularly tricky or insideous is going on). The hope is that people can figure out how to use your interfaces without reading the code itself... that is the goal metric.<p>
Good things to talk about here are what happens when something unexpected happens: does the method return null? Abort? Format your hard disk?<p>
</ol>
Conditional move is effectly a special case of a predicated
instruction... and I think that all predicated instructions can possibly
be implemented later in LLVM. It would significantly change things, and
-it doesn't seem to be very neccesary right now. It would seem to
+it doesn't seem to be very necessary right now. It would seem to
complicate flow control analysis a LOT in the virtual machine. I would
tend to prefer that a predicated architecture like IA64 convert from a
"basic block" representation to a predicated rep as part of it's dynamic
2. A pointer to the dtor for the contained object
3. The contained object itself
-Note that it is neccesary to maintain #1 & #2 in the exception object itself
+Note that it is necessary to maintain #1 & #2 in the exception object itself
because objects without virtual function tables may be thrown (as in this
example). Assuming this, TryHandler would look something like this:
which is much more natural and what users expect.
-* Simplification of #include's: Before, it was neccesary for a .cpp file to
+* Simplification of #include's: Before, it was necessary for a .cpp file to
include every .h file that it used. Now things are batched a little bit more
to make it easier to use. Specifically, the include graph now includes these
edges:
<li>Graphs - It would be great to have gnuplot graphs to keep track of how the
tree is changing over time. We already gather a several statistics, it
- just neccesary to add the script-fu to gnuplotize it.
+ just necessary to add the script-fu to gnuplotize it.
<li>Regression tests - We should run the regression tests in addition to the
program tests...
<li><tt>Function::BasicBlockListType &getBasicBlockList()</tt><p>
Returns the list of <a href="#BasicBlock"><tt>BasicBlock</tt></a>s. This is
-neccesary to use when you need to update the list or perform a complex action
+necessary to use when you need to update the list or perform a complex action
that doesn't have a forwarding method.<p>
<li><tt>Function::ArgumentListType &getArgumentList()</tt><p>
Returns the list of <a href="#Argument"><tt>Argument</tt></a>s. This is
-neccesary to use when you need to update the list or perform a complex action
+necessary to use when you need to update the list or perform a complex action
that doesn't have a forwarding method.<p>
<li><tt>Module::FunctionListType &getFunctionList()</tt><p>
Returns the list of <a href="#Function"><tt>Function</tt></a>s. This is
-neccesary to use when you need to update the list or perform a complex action
+necessary to use when you need to update the list or perform a complex action
that doesn't have a forwarding method.<p>
<!-- Global Variable -->
<li><tt>Module::GlobalListType &getGlobalList()</tt><p>
Returns the list of <a href="#GlobalVariable"><tt>GlobalVariable</tt></a>s.
-This is neccesary to use when you need to update the list or perform a complex
+This is necessary to use when you need to update the list or perform a complex
action that doesn't have a forwarding method.<p>
When choosing a superclass for your Pass, you should choose the <b>most
specific</b> class possible, while still being able to meet the requirements
-listed. This gives the LLVM Pass Infrastructure information neccesary to
+listed. This gives the LLVM Pass Infrastructure information necessary to
optimize how passes are run, so that the resultant compiler isn't unneccesarily
slow.<p>
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
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 nec
cesary.<p>
+free functions that it needs, adding prototypes to the module if nec
essary.<p>
<!-- _______________________________________________________________________ -->
</ul><h4><a name="runOnFunction"><hr size=0>The <tt>runOnFunction</tt> method</h4><ul>
/// addCustomGraphFeatures - If a graph is made up of more than just
/// straight-forward nodes and edges, this is the place to put all of the
- /// custom stuff neccesary. The GraphWriter object, instantiated with your
+ /// custom stuff necessary. The GraphWriter object, instantiated with your
/// GraphType is passed in as an argument. You may call arbitrary methods on
/// it to add things to the output graph.
///
// computer RPO from a graph. Because of this, the construction of the
// ReversePostOrderTraversal object is expensive (it must walk the entire graph
// with a postorder iterator to build the data structures). The moral of this
-// story is: Don't create more ReversePostOrderTraversal classes than neccesary.
+// story is: Don't create more ReversePostOrderTraversal classes than necessary.
//
// This class should be used like this:
// {
// computer RPO from a graph. Because of this, the construction of the
// ReversePostOrderTraversal object is expensive (it must walk the entire graph
// with a postorder iterator to build the data structures). The moral of this
-// story is: Don't create more ReversePostOrderTraversal classes than neccesary.
+// story is: Don't create more ReversePostOrderTraversal classes than necessary.
//
// This class should be used like this:
// {
/// AccessType - Keep track of whether this alias set merely refers to the
/// locations of memory, whether it modifies the memory, or whether it does
/// both. The lattice goes from "NoModRef" to either Refs or Mods, then to
- /// ModRef as neccesary.
+ /// ModRef as necessary.
///
enum AccessType {
NoModRef = 0, Refs = 1, // Ref = bit 1
virtual void print(std::ostream &OS) const;
/// dominates - Return true if A dominates B. This performs the special
- /// checks neccesary if A and B are in the same basic block.
+ /// checks necessary if A and B are in the same basic block.
///
bool dominates(Instruction *A, Instruction *B) const;
if (Done) return *this; // Found a new interval! Use it!
}
- // Free interval memory... if neccesary
+ // Free interval memory... if necessary
if (IOwnMem) delete IntStack.top().first;
// We ran out of successors for this interval... pop off the stack
//
// Using the routines defined in this file does not require linking to any
// libraries, as all of the services are small self contained units that are to
-// be inlined as neccesary.
+// be inlined as necessary.
//
//===----------------------------------------------------------------------===//
/// print - Print out the internal state of the pass. This is called by
/// Analyze to print out the contents of an analysis. Otherwise it is not
- /// neccesary to implement this method. Beware that the module pointer MAY be
+ /// necessary to implement this method. Beware that the module pointer MAY be
/// null. This automatically forwards to a virtual function that does not
/// provide the Module* in case the analysis doesn't need it it can just be
/// ignored.
///
struct FunctionPass : public Pass {
/// doInitialization - Virtual method overridden by subclasses to do
- /// any neccesary per-module initialization.
+ /// any necessary per-module initialization.
///
virtual bool doInitialization(Module &M) { return false; }
///
struct BasicBlockPass : public FunctionPass {
/// doInitialization - Virtual method overridden by subclasses to do
- /// any neccesary per-module initialization.
+ /// any necessary per-module initialization.
///
virtual bool doInitialization(Module &M) { return false; }
/// doInitialization - Virtual method overridden by BasicBlockPass subclasses
- /// to do any neccesary per-function initialization.
+ /// to do any necessary per-function initialization.
///
virtual bool doInitialization(Function &F) { return false; }
/// addCustomGraphFeatures - If a graph is made up of more than just
/// straight-forward nodes and edges, this is the place to put all of the
- /// custom stuff neccesary. The GraphWriter object, instantiated with your
+ /// custom stuff necessary. The GraphWriter object, instantiated with your
/// GraphType is passed in as an argument. You may call arbitrary methods on
/// it to add things to the output graph.
///
// Specific Instruction type classes... note that all of the casts are
- // neccesary because we use the instruction classes as opaque types...
+ // necessary because we use the instruction classes as opaque types...
//
RetTy visitReturnInst(ReturnInst &I) { DELEGATE(TerminatorInst);}
RetTy visitBranchInst(BranchInst &I) { DELEGATE(TerminatorInst);}
unsigned char getPointerSize() const { return PointerSize; }
AnnotationID getStructLayoutAID() const { return AID; }
- // getTypeSize - Return the number of bytes neccesary to hold the specified
+ // getTypeSize - Return the number of bytes necessary to hold the specified
// type
uint64_t getTypeSize (const Type *Ty) const;
// Remove duplicates from the CandidateLoads list because alias analysis
// processing may be somewhat expensive and we don't want to do more work
- // than neccesary.
+ // than necessary.
//
unsigned OldSize = CandidateLoads.size();
std::sort(CandidateLoads.begin(), CandidateLoads.end());
if (I != GlobalRefs.end()) {
GlobalVariable *OldGV = I->second; // Get the placeholder...
- I->first.second.destroy(); // Free string memory if neccesary
+ I->first.second.destroy(); // Free string memory if necessary
// Loop over all of the uses of the GlobalValue. The only thing they are
// allowed to be is ConstantPointerRef's.
Module *R = Parser.ParseBytecode(Buffer, Buffer+Length, ModuleID);
if (ErrorStr) *ErrorStr = Parser.getError();
- delete [] PtrToDelete; // Delete alignment buffer if neccesary
+ delete [] PtrToDelete; // Delete alignment buffer if necessary
return R;
}
void AllocateBasicBlock(MachineBasicBlock &MBB);
/// getStackSpaceFor - This returns the offset of the specified virtual
- /// register on the stack, allocating space if neccesary.
+ /// register on the stack, allocating space if necessary.
int getStackSpaceFor(unsigned VirtReg, const TargetRegisterClass *RC);
/// Given a virtual register, return a compatible physical register that is
void *Args[] = { Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, 0 };
// Loop over the format string, munging read values as appropriate (performs
- // byteswaps as neccesary).
+ // byteswaps as necessary).
unsigned ArgNo = 0;
while (*Fmt) {
if (*Fmt++ == '%') {
}
// Specific Instruction type classes... note that all of the casts are
-// neccesary because we use the instruction classes as opaque types...
+// necessary because we use the instruction classes as opaque types...
//
void CWriter::visitReturnInst(ReturnInst &I) {
// Don't output a void return if this is the last basic block in the function
printBranchToBlock(I.getParent(), I.getSuccessor(1), 2);
}
} else {
- // First goto not neccesary, assume second one is...
+ // First goto not necessary, assume second one is...
Out << " if (!";
writeOperand(I.getCondition());
Out << ") {\n";
}
// Specific Instruction type classes... note that all of the casts are
-// neccesary because we use the instruction classes as opaque types...
+// necessary because we use the instruction classes as opaque types...
//
void CWriter::visitReturnInst(ReturnInst &I) {
// Don't output a void return if this is the last basic block in the function
printBranchToBlock(I.getParent(), I.getSuccessor(1), 2);
}
} else {
- // First goto not neccesary, assume second one is...
+ // First goto not necessary, assume second one is...
Out << " if (!";
writeOperand(I.getCondition());
Out << ") {\n";
//===-- EmitAssembly.cpp - Emit Sparc Specific .s File ---------------------==//
//
-// This file implements all of the stuff neccesary to output a .s file from
+// This file implements all of the stuff necessary to output a .s file from
// LLVM. The code in this file assumes that the specified module has already
// been compiled into the internal data structures of the Module.
//
}
// enterSection - Use this method to enter a different section of the output
- // executable. This is used to only output neccesary section transitions.
+ // executable. This is used to only output necessary section transitions.
//
void enterSection(enum Sections S) {
- if (S == CurSection) return; // Only switch section if neccesary
+ if (S == CurSection) return; // Only switch section if necessary
CurSection = S;
toAsm << "\n\t.section ";
#include "llvm/DerivedTypes.h"
#include "llvm/Constants.h"
-// Handle the Pass registration stuff neccesary to use TargetData's.
+// Handle the Pass registration stuff necessary to use TargetData's.
namespace {
// Register the default SparcV9 implementation...
RegisterPass<TargetData> X("targetdata", "Target Data Layout");
getTypeInfo(Ty, &TD, TySize, A);
TyAlign = A;
- // Add padding if neccesary to make the data element aligned properly...
+ // Add padding if necessary to make the data element aligned properly...
if (StructSize % TyAlign != 0)
StructSize = (StructSize/TyAlign + 1) * TyAlign; // Add padding...
if (Reg >= X86::FP0 && Reg <= X86::FP6) {
DEBUG(std::cerr << "Register FP#" << Reg-X86::FP0 << " is dead!\n");
++I; // Insert fxch AFTER the instruction
- moveToTop(Reg-X86::FP0, I); // Insert fxch if neccesary
+ moveToTop(Reg-X86::FP0, I); // Insert fxch if necessary
--I; // Move to fxch or old instruction
popStackAfter(I); // Pop the top of the stack, killing value
}
unsigned Opcode = MI.getOpcode();
const TargetInstrDescriptor &Desc = II->get(Opcode);
- // Emit instruction prefixes if neccesary
+ // Emit instruction prefixes if necessary
if (Desc.TSFlags & X86II::OpSize) MCE.emitByte(0x66);// Operand size...
switch (Desc.TSFlags & X86II::Op0Mask) {
if (Reg >= X86::FP0 && Reg <= X86::FP6) {
DEBUG(std::cerr << "Register FP#" << Reg-X86::FP0 << " is dead!\n");
++I; // Insert fxch AFTER the instruction
- moveToTop(Reg-X86::FP0, I); // Insert fxch if neccesary
+ moveToTop(Reg-X86::FP0, I); // Insert fxch if necessary
--I; // Move to fxch or old instruction
popStackAfter(I); // Pop the top of the stack, killing value
}
}
// hasSPAdjust - Return true if this function has ESP adjustment instructions in
-// the prolog and epilog which allocate local stack space. This is neccesary
+// the prolog and epilog which allocate local stack space. This is necessary
// because we elide these instructions if there are no function calls in the
// current function (ie, this is a leaf function). In this case, we can refer
// beyond the stack pointer because we know that nothing will trample on that
if (CTMI != CTMap.end()) { // Operand #1 is in the table already?
// If so, check to see if it's Ty*, or, more importantly, if it is a
// pointer to a structure where the first element is a Ty... this code
- // is neccesary because we might be trying to change the source and
+ // is necessary because we might be trying to change the source and
// destination type of the store (they might be related) and the dest
// pointer type might be a pointer to structure. Below we allow pointer
// to structures where the 0th element is compatible with the value,
// Okay, at this point, we know that all of the arguments can be
// converted. We succeed if we can change the return type if
- // neccesary...
+ // necessary...
//
return ValueConvertibleToType(I, FTy->getReturnType(), CTMap, TD);
}
++NumRaised;
} else if (CI->getCalledValue() == FreeFunc) { // Replace call to free?
// If no prototype was provided for free, we may need to cast the
- // source pointer. This should be really uncommon, but it's neccesary
+ // source pointer. This should be really uncommon, but it's necessary
// just in case we are dealing with wierd code like this:
// free((long)ptr);
//
std::set<BasicBlock*> AliveBlocks;
// Process the work list of instructions that just became live... if they
- // became live, then that means that all of their operands are neccesary as
+ // became live, then that means that all of their operands are necessary as
// well... make them live as well.
//
while (!WorkList.empty()) {
// X = -(A+12+C+D) into X = -A + -12 + -C + -D = -12 + -A + -C + -D
// so that later, a: Y = 12+X could get reassociated with the -12 to eliminate
// the constants. We assume that instcombine will clean up the mess later if
- // we introduce tons of unneccesary negation instructions...
+ // we introduce tons of unnecessary negation instructions...
//
if (Instruction *I = dyn_cast<Instruction>(V))
if (I->getOpcode() == Instruction::Add && I->use_size() == 1) {
}
// getValueState - Return the InstVal object that corresponds to the value.
- // This function is neccesary because not all values should start out in the
+ // This function is necessary because not all values should start out in the
// underdefined state... Argument's should be overdefined, and
// constants should be marked as constants. If a value is not known to be an
// Instruction object, then use this accessor to get its value from the map.
std::string OldName = I.getName();
- // Delete the unneccesary instruction now...
+ // Delete the unnecessary instruction now...
BI = BIL.erase(BI);
// Make sure to propagate a name if there is one already...
// as store-sinking that is built into LICM.
//
// Note that the simplifycfg pass will clean up blocks which are split out but
-// end up being unneccesary, so usage of this pass does not neccesarily
+// end up being unnecessary, so usage of this pass does not neccesarily
// pessimize generated code.
//
//===----------------------------------------------------------------------===//
if (MI->getNumOperands() && Size == 1) {
MallocArg = MI->getOperand(0); // Operand * 1 = Operand
} else if (MI->getNumOperands()) {
- // Multiply it by the array size if neccesary...
+ // Multiply it by the array size if necessary...
MallocArg = BinaryOperator::create(Instruction::Mul, MI->getOperand(0),
MallocArg, "", I);
}
// correct number of entries for their predecessors.
Value *NullVal = Constant::getNullValue(PN->getType());
- // This is neccesary because adding incoming values to the PHI node adds uses
+ // This is necessary because adding incoming values to the PHI node adds uses
// to the basic blocks being used, which can invalidate the predecessor
// iterator!
std::vector<BasicBlock*> Preds(pred_begin(BB), pred_end(BB));
A("domset", "Dominator Set Construction", true);
// dominates - Return true if A dominates B. This performs the special checks
-// neccesary if A and B are in the same basic block.
+// necessary if A and B are in the same basic block.
//
bool DominatorSetBase::dominates(Instruction *A, Instruction *B) const {
BasicBlock *BBA = A->getParent(), *BBB = B->getParent();
}
// print - Print out the internal state of the pass. This is called by Analyse
-// to print out the contents of an analysis. Otherwise it is not neccesary to
+// to print out the contents of an analysis. Otherwise it is not necessary to
// implement this method.
//
void Pass::print(std::ostream &O) const {
"Function return type does not match operand "
"type of return inst!", &RI, F->getReturnType());
- // Check to make sure that the return value has neccesary properties for
+ // Check to make sure that the return value has necessary properties for
// terminators...
visitTerminatorInst(RI);
}
abort();
} else { // This class expects template arguments...
// Loop over all of the template arguments, setting them to the specified
- // value or leaving them as the default as neccesary.
+ // value or leaving them as the default as necessary.
for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
if (i < TemplateArgs.size()) { // A value is specified for this temp-arg?
// Set it now.
/* This triggered a problem in reload, fixed by disabling most of the
* steps of compilation in GCC. Before this change, the code went through
- * the entire backend of GCC, even though it was unneccesary for LLVM output
+ * the entire backend of GCC, even though it was unnecessary for LLVM output
* now it is skipped entirely, and since reload doesn't run, it can't cause
* a problem.
*/
std::cout << "\n*** Attempting to reduce testcase by deleting instruc"
<< "tions: Simplification Level #" << Simplification << "\n";
- // Now that we have deleted the functions that are unneccesary for the
- // program, try to remove instructions that are not neccesary to cause the
+ // Now that we have deleted the functions that are unnecessary for the
+ // program, try to remove instructions that are not necessary to cause the
// crash. To do this, we loop through all of the instructions in the
// remaining functions, deleting them (replacing any values produced with
// nulls), and then running ADCE and SimplifyCFG. If the transformed input
break;
case NoFailure:
// Otherwise the property doesn't hold. Some of the elements we removed
- // must be neccesary to maintain the property.
+ // must be necessary to maintain the property.
MidTop = Mid;
break;
}
miscompiles one function of a large benchmark), and so you want to just
cut the testcase down to the one function that is being a problem. In
this case, 'extract' eliminates all of the extraneous global variables,
-type information, and functions that aren't neccesary, giving you
+type information, and functions that aren't necessary, giving you
something simpler.
This is just an FYI, because I've found it useful and thought you guys
abort();
} else { // This class expects template arguments...
// Loop over all of the template arguments, setting them to the specified
- // value or leaving them as the default as neccesary.
+ // value or leaving them as the default as necessary.
for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
if (i < TemplateArgs.size()) { // A value is specified for this temp-arg?
// Set it now.
projects / oota-llvm.git / commitdiff