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
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>
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>
//
// 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);
//===-- 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.
//
//===----------------------------------------------------------------------===//
-//===-- 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.
//
//===----------------------------------------------------------------------===//
// 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.
/// 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.
///
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
}
/// 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;
-//===- 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
//-----------------------------------------------------------------------------
// 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).
-//===- 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
//-----------------------------------------------------------------------------
// 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).
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));
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.
//===- 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.
//
//===----------------------------------------------------------------------===//
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.
}
// 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 {
// 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())
OSDN Git Service
