[llvm-commits] CVS: llvm/include/llvm/AbstractTypeUser.h Argument.h BasicBlock.h CallGraphSCCPass.h Constant.h Constants.h DerivedTypes.h Function.h GlobalValue.h GlobalVariable.h InstrTypes.h Instruction.h Instructions.h IntrinsicInst.h Intrinsics.h Linker.h Module.h ModuleProvider.h PassAnalysisSupport.h Pass.h PassManager.h PassSupport.h SymbolTable.h SymbolTableListTraits.h Type.h Use.h User.h Value.h
Misha Brukman
brukman at cs.uiuc.edu
Thu Apr 21 13:12:04 PDT 2005
Changes in directory llvm/include/llvm:
AbstractTypeUser.h updated: 1.23 -> 1.24
Argument.h updated: 1.10 -> 1.11
BasicBlock.h updated: 1.52 -> 1.53
CallGraphSCCPass.h updated: 1.6 -> 1.7
Constant.h updated: 1.22 -> 1.23
Constants.h updated: 1.69 -> 1.70
DerivedTypes.h updated: 1.66 -> 1.67
Function.h updated: 1.63 -> 1.64
GlobalValue.h updated: 1.22 -> 1.23
GlobalVariable.h updated: 1.32 -> 1.33
InstrTypes.h updated: 1.42 -> 1.43
Instruction.h updated: 1.66 -> 1.67
Instructions.h updated: 1.15 -> 1.16
IntrinsicInst.h updated: 1.5 -> 1.6
Intrinsics.h updated: 1.29 -> 1.30
Linker.h updated: 1.14 -> 1.15
Module.h updated: 1.60 -> 1.61
ModuleProvider.h updated: 1.10 -> 1.11
PassAnalysisSupport.h updated: 1.18 -> 1.19
Pass.h updated: 1.50 -> 1.51
PassManager.h updated: 1.12 -> 1.13
PassSupport.h updated: 1.20 -> 1.21
SymbolTable.h updated: 1.49 -> 1.50
SymbolTableListTraits.h updated: 1.4 -> 1.5
Type.h updated: 1.74 -> 1.75
Use.h updated: 1.11 -> 1.12
User.h updated: 1.34 -> 1.35
Value.h updated: 1.75 -> 1.76
---
Log message:
Remove trailing whitespace
---
Diffs of the changes: (+297 -297)
AbstractTypeUser.h | 6 +-
Argument.h | 6 +-
BasicBlock.h | 14 +++---
CallGraphSCCPass.h | 4 -
Constant.h | 8 +--
Constants.h | 30 ++++++-------
DerivedTypes.h | 34 +++++++--------
Function.h | 14 +++---
GlobalValue.h | 10 ++--
GlobalVariable.h | 10 ++--
InstrTypes.h | 20 ++++-----
Instruction.h | 14 +++---
Instructions.h | 52 ++++++++++++------------
IntrinsicInst.h | 18 ++++----
Intrinsics.h | 4 -
Linker.h | 104 ++++++++++++++++++++++++------------------------
Module.h | 10 ++--
ModuleProvider.h | 12 ++---
Pass.h | 4 -
PassAnalysisSupport.h | 10 ++--
PassManager.h | 6 +-
PassSupport.h | 16 +++----
SymbolTable.h | 72 ++++++++++++++++-----------------
SymbolTableListTraits.h | 6 +-
Type.h | 54 ++++++++++++------------
Use.h | 12 ++---
User.h | 14 +++---
Value.h | 30 ++++++-------
28 files changed, 297 insertions(+), 297 deletions(-)
Index: llvm/include/llvm/AbstractTypeUser.h
diff -u llvm/include/llvm/AbstractTypeUser.h:1.23 llvm/include/llvm/AbstractTypeUser.h:1.24
--- llvm/include/llvm/AbstractTypeUser.h:1.23 Wed Oct 27 11:14:47 2004
+++ llvm/include/llvm/AbstractTypeUser.h Thu Apr 21 15:11:51 2005
@@ -1,10 +1,10 @@
//===-- llvm/AbstractTypeUser.h - AbstractTypeUser Interface ----*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// The AbstractTypeUser class is an interface to be implemented by classes who
@@ -79,7 +79,7 @@
void removeUser();
public:
// ctor - Add use to type if abstract. Note that Ty must not be null
- inline PATypeHandle(const Type *ty, AbstractTypeUser *user)
+ inline PATypeHandle(const Type *ty, AbstractTypeUser *user)
: Ty(ty), User(user) {
addUser();
}
Index: llvm/include/llvm/Argument.h
diff -u llvm/include/llvm/Argument.h:1.10 llvm/include/llvm/Argument.h:1.11
--- llvm/include/llvm/Argument.h:1.10 Sat Mar 5 13:51:20 2005
+++ llvm/include/llvm/Argument.h Thu Apr 21 15:11:51 2005
@@ -1,10 +1,10 @@
//===-- llvm/Argument.h - Definition of the Argument class ------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file defines the Argument class, which represents an incoming formal
@@ -41,7 +41,7 @@
inline const Function *getParent() const { return Parent; }
inline Function *getParent() { return Parent; }
-
+
// getNext/Prev - Return the next or previous argument in the list.
Argument *getNext() { return Next; }
const Argument *getNext() const { return Next; }
Index: llvm/include/llvm/BasicBlock.h
diff -u llvm/include/llvm/BasicBlock.h:1.52 llvm/include/llvm/BasicBlock.h:1.53
--- llvm/include/llvm/BasicBlock.h:1.52 Tue Apr 12 13:51:53 2005
+++ llvm/include/llvm/BasicBlock.h Thu Apr 21 15:11:51 2005
@@ -1,10 +1,10 @@
//===-- llvm/BasicBlock.h - Represent a basic block in the VM ---*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
//
@@ -16,7 +16,7 @@
//
///===---------------------------------------------------------------------===//
//
-// Note that well formed basic blocks are formed of a list of instructions
+// Note that well formed basic blocks are formed of a list of instructions
// followed by a single TerminatorInst instruction. TerminatorInst's may not
// occur in the middle of basic blocks, and must terminate the blocks.
//
@@ -91,7 +91,7 @@
///
TerminatorInst *getTerminator();
const TerminatorInst *const getTerminator() const;
-
+
/// removeFromParent - This method unlinks 'this' from the containing
/// function, but does not delete it.
///
@@ -144,14 +144,14 @@
/// '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
- /// valid on an object that has "dropped all references", except operator
+ /// valid on an object that has "dropped all references", except operator
/// delete.
///
void dropAllReferences();
/// removePredecessor - This method is used to notify a BasicBlock that the
/// specified Predecessor of the block is no longer able to reach it. This is
- /// actually not used to update the Predecessor list, but is actually used to
+ /// actually not used to update the Predecessor list, but is actually used to
/// update the PHI nodes that reside in the block. Note that this should be
/// called while the predecessor still refers to this block.
///
@@ -164,7 +164,7 @@
/// new BB, including the old terminator. The newly formed BasicBlock is
/// returned. This function invalidates the specified iterator.
///
- /// Note that this only works on well formed basic blocks (must have a
+ /// Note that this only works on well formed basic blocks (must have a
/// terminator), and 'I' must not be the end of instruction list (which would
/// cause a degenerate basic block to be formed, having a terminator inside of
/// the basic block).
Index: llvm/include/llvm/CallGraphSCCPass.h
diff -u llvm/include/llvm/CallGraphSCCPass.h:1.6 llvm/include/llvm/CallGraphSCCPass.h:1.7
--- llvm/include/llvm/CallGraphSCCPass.h:1.6 Sun Sep 19 23:42:18 2004
+++ llvm/include/llvm/CallGraphSCCPass.h Thu Apr 21 15:11:51 2005
@@ -1,10 +1,10 @@
//===- CallGraphSCCPass.h - Pass that operates BU on call graph -*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file defines the CallGraphSCCPass class, which is used for passes which
Index: llvm/include/llvm/Constant.h
diff -u llvm/include/llvm/Constant.h:1.22 llvm/include/llvm/Constant.h:1.23
--- llvm/include/llvm/Constant.h:1.22 Sat Mar 5 13:51:20 2005
+++ llvm/include/llvm/Constant.h Thu Apr 21 15:11:51 2005
@@ -1,10 +1,10 @@
//===-- llvm/Constant.h - Constant class definition -------------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file contains the declaration of the Constant class.
@@ -38,7 +38,7 @@
// Specialize get/setOperand for Constant's as their operands are always
// constants as well.
- Constant *getOperand(unsigned i) {
+ Constant *getOperand(unsigned i) {
return static_cast<Constant*>(User::getOperand(i));
}
const Constant *getOperand(unsigned i) const {
@@ -56,7 +56,7 @@
/// destroyConstantImpl as the last thing they do, to destroy all users and
/// delete this.
virtual void destroyConstant() { assert(0 && "Not reached!"); }
-
+
//// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const Constant *) { return true; }
static inline bool classof(const GlobalValue *) { return true; }
Index: llvm/include/llvm/Constants.h
diff -u llvm/include/llvm/Constants.h:1.69 llvm/include/llvm/Constants.h:1.70
--- llvm/include/llvm/Constants.h:1.69 Sat Mar 19 05:40:31 2005
+++ llvm/include/llvm/Constants.h Thu Apr 21 15:11:51 2005
@@ -1,10 +1,10 @@
//===-- llvm/Constants.h - Constant class subclass definitions --*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file contains the declarations for the subclasses of Constant, which
@@ -356,7 +356,7 @@
/// get() - Static factory methods - Return objects of the specified value
static Constant *get(const ArrayType *T, const std::vector<Constant*> &);
static Constant *get(const std::string &Initializer);
-
+
/// getType - Specialize the getType() method to always return an ArrayType,
/// which reduces the amount of casting needed in parts of the compiler.
///
@@ -423,7 +423,7 @@
virtual void destroyConstant();
virtual void replaceUsesOfWithOnConstant(Value *From, Value *To,
bool DisableChecking = false);
-
+
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const ConstantStruct *) { return true; }
static bool classof(const Value *V) {
@@ -446,7 +446,7 @@
/// get() - Static factory methods - Return objects of the specified value
static Constant *get(const PackedType *T, const std::vector<Constant*> &);
static Constant *get(const std::vector<Constant*> &V);
-
+
/// getType - Specialize the getType() method to always return an PackedType,
/// which reduces the amount of casting needed in parts of the compiler.
///
@@ -519,12 +519,12 @@
friend struct ConstantCreator<ConstantExpr,Type,
std::pair<unsigned, std::vector<Constant*> > >;
friend struct ConvertConstantType<ConstantExpr, Type>;
-
+
protected:
ConstantExpr(const Type *Ty, unsigned Opcode, Use *Ops, unsigned NumOps)
: Constant(Ty, ConstantExprVal, Ops, NumOps) {
// Operation type (an Instruction opcode) is stored as the SubclassData.
- SubclassData = Opcode;
+ SubclassData = Opcode;
}
// These private methods are used by the type resolution code to create
@@ -537,13 +537,13 @@
Constant *C1, Constant *C2, Constant *C3);
static Constant *getGetElementPtrTy(const Type *Ty, Constant *C,
const std::vector<Value*> &IdxList);
-
+
public:
// Static methods to construct a ConstantExpr of different kinds. Note that
// these methods may return a object that is not an instance of the
// ConstantExpr class, because they will attempt to fold the constant
// expression into something simpler if possible.
-
+
/// Cast constant expr
///
static Constant *getCast(Constant *C, const Type *Ty);
@@ -603,29 +603,29 @@
const std::vector<Constant*> &IdxList);
static Constant *getGetElementPtr(Constant *C,
const std::vector<Value*> &IdxList);
-
+
/// isNullValue - Return true if this is the value that would be returned by
/// getNullValue.
virtual bool isNullValue() const { return false; }
-
+
/// getOpcode - Return the opcode at the root of this constant expression
unsigned getOpcode() const { return SubclassData; }
/// getOpcodeName - Return a string representation for an opcode.
const char *getOpcodeName() const;
-
+
virtual void destroyConstant();
virtual void replaceUsesOfWithOnConstant(Value *From, Value *To,
bool DisableChecking = false);
-
+
/// Override methods to provide more type information...
- inline Constant *getOperand(unsigned i) {
+ inline Constant *getOperand(unsigned i) {
return cast<Constant>(User::getOperand(i));
}
inline Constant *getOperand(unsigned i) const {
return const_cast<Constant*>(cast<Constant>(User::getOperand(i)));
}
-
+
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const ConstantExpr *) { return true; }
Index: llvm/include/llvm/DerivedTypes.h
diff -u llvm/include/llvm/DerivedTypes.h:1.66 llvm/include/llvm/DerivedTypes.h:1.67
--- llvm/include/llvm/DerivedTypes.h:1.66 Sat Jan 8 16:44:06 2005
+++ llvm/include/llvm/DerivedTypes.h Thu Apr 21 15:11:51 2005
@@ -1,13 +1,13 @@
//===-- llvm/DerivedTypes.h - Classes for handling data types ---*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
-// This file contains the declarations of classes that represent "derived
+// This file contains the declarations of classes that represent "derived
// types". These are things like "arrays of x" or "structure of x, y, z" or
// "method returning x taking (y,z) as parameters", etc...
//
@@ -61,7 +61,7 @@
delete this;
}
-
+
public:
//===--------------------------------------------------------------------===//
@@ -112,12 +112,12 @@
const FunctionType &operator=(const FunctionType &); // Do not implement
protected:
/// This should really be private, but it squelches a bogus warning
- /// from GCC to make them protected: warning: `class FunctionType' only
+ /// from GCC to make them protected: warning: `class FunctionType' only
/// defines private constructors and has no friends
///
/// Private ctor - Only can be created by a static member...
///
- FunctionType(const Type *Result, const std::vector<const Type*> &Params,
+ FunctionType(const Type *Result, const std::vector<const Type*> &Params,
bool IsVarArgs);
public:
@@ -146,7 +146,7 @@
// Implement the AbstractTypeUser interface.
virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy);
virtual void typeBecameConcrete(const DerivedType *AbsTy);
-
+
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const FunctionType *T) { return true; }
static inline bool classof(const Type *T) {
@@ -171,7 +171,7 @@
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const CompositeType *T) { return true; }
static inline bool classof(const Type *T) {
- return T->getTypeID() == ArrayTyID ||
+ return T->getTypeID() == ArrayTyID ||
T->getTypeID() == StructTyID ||
T->getTypeID() == PointerTyID ||
T->getTypeID() == PackedTyID;
@@ -188,7 +188,7 @@
protected:
/// This should really be private, but it squelches a bogus warning
- /// from GCC to make them protected: warning: `class StructType' only
+ /// from GCC to make them protected: warning: `class StructType' only
/// defines private constructors and has no friends
///
/// Private ctor - Only can be created by a static member...
@@ -231,12 +231,12 @@
};
-/// SequentialType - This is the superclass of the array, pointer and packed
+/// SequentialType - This is the superclass of the array, pointer and packed
/// type classes. All of these represent "arrays" in memory. The array type
/// represents a specifically sized array, pointer types are unsized/unknown
-/// size arrays, packed types represent specifically sized arrays that
-/// allow for use of SIMD instructions. SequentialType holds the common
-/// features of all, which stem from the fact that all three lay their
+/// size arrays, packed types represent specifically sized arrays that
+/// allow for use of SIMD instructions. SequentialType holds the common
+/// features of all, which stem from the fact that all three lay their
/// components out in memory identically.
///
class SequentialType : public CompositeType {
@@ -280,7 +280,7 @@
const ArrayType &operator=(const ArrayType &); // Do not implement
protected:
/// This should really be private, but it squelches a bogus warning
- /// from GCC to make them protected: warning: `class ArrayType' only
+ /// from GCC to make them protected: warning: `class ArrayType' only
/// defines private constructors and has no friends
///
/// Private ctor - Only can be created by a static member...
@@ -316,7 +316,7 @@
const PackedType &operator=(const PackedType &); // Do not implement
protected:
/// This should really be private, but it squelches a bogus warning
- /// from GCC to make them protected: warning: `class PackedType' only
+ /// from GCC to make them protected: warning: `class PackedType' only
/// defines private constructors and has no friends
///
/// Private ctor - Only can be created by a static member...
@@ -351,7 +351,7 @@
const PointerType &operator=(const PointerType &); // Do not implement
protected:
// This should really be private, but it squelches a bogus warning
- // from GCC to make them protected: warning: `class PointerType' only
+ // from GCC to make them protected: warning: `class PointerType' only
// defines private constructors and has no friends
// Private ctor - Only can be created by a static member...
@@ -380,7 +380,7 @@
const OpaqueType &operator=(const OpaqueType &); // DO NOT IMPLEMENT
protected:
/// This should really be private, but it squelches a bogus warning
- /// from GCC to make them protected: warning: `class OpaqueType' only
+ /// from GCC to make them protected: warning: `class OpaqueType' only
/// defines private constructors and has no friends
///
/// Private ctor - Only can be created by a static member...
Index: llvm/include/llvm/Function.h
diff -u llvm/include/llvm/Function.h:1.63 llvm/include/llvm/Function.h:1.64
--- llvm/include/llvm/Function.h:1.63 Mon Mar 14 23:13:47 2005
+++ llvm/include/llvm/Function.h Thu Apr 21 15:11:51 2005
@@ -1,13 +1,13 @@
//===-- llvm/Function.h - Class to represent a single function --*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
-// This file contains the declaration of the Function class, which represents a
+// This file contains the declaration of the Function class, which represents a
// single function/procedure in LLVM.
//
// A function basically consists of a list of basic blocks, a list of arguments,
@@ -66,7 +66,7 @@
ArgumentListType ArgumentList; // The formal arguments
SymbolTable *SymTab;
-
+
friend class SymbolTableListTraits<Function, Module, Module>;
void setParent(Module *parent);
@@ -161,7 +161,7 @@
inline SymbolTable &getSymbolTable() { return *SymTab; }
inline const SymbolTable &getSymbolTable() const { return *SymTab; }
-
+
//===--------------------------------------------------------------------===//
// BasicBlock iterator forwarding functions
//
@@ -209,7 +209,7 @@
/// in your path.
///
void viewCFG() const;
-
+
/// viewCFGOnly - This function is meant for use from the debugger. It works
/// just like viewCFG, but it does not include the contents of basic blocks
/// into the nodes, just the label. If you are only interested in the CFG
@@ -228,7 +228,7 @@
/// '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 deleted for real. Note that no operations are
- /// valid on an object that has "dropped all references", except operator
+ /// valid on an object that has "dropped all references", except operator
/// delete.
///
/// Since no other object in the module can have references into the body of a
Index: llvm/include/llvm/GlobalValue.h
diff -u llvm/include/llvm/GlobalValue.h:1.22 llvm/include/llvm/GlobalValue.h:1.23
--- llvm/include/llvm/GlobalValue.h:1.22 Thu Apr 21 11:10:03 2005
+++ llvm/include/llvm/GlobalValue.h Thu Apr 21 15:11:51 2005
@@ -1,10 +1,10 @@
//===-- llvm/GlobalValue.h - Class to represent a global value --*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file is a common base class of all globally definable objects. As such,
@@ -48,9 +48,9 @@
}
/// If the usage is empty (except transitively dead constants), then this
- /// global value can can be safely deleted since the destructor will
+ /// global value can can be safely deleted since the destructor will
/// delete the dead constants as well.
- /// @brief Determine if the usage of this global value is empty except
+ /// @brief Determine if the usage of this global value is empty except
/// for transitively dead constants.
bool use_empty_except_constants();
@@ -103,7 +103,7 @@
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const GlobalValue *T) { return true; }
static inline bool classof(const Value *V) {
- return V->getValueType() == Value::FunctionVal ||
+ return V->getValueType() == Value::FunctionVal ||
V->getValueType() == Value::GlobalVariableVal;
}
};
Index: llvm/include/llvm/GlobalVariable.h
diff -u llvm/include/llvm/GlobalVariable.h:1.32 llvm/include/llvm/GlobalVariable.h:1.33
--- llvm/include/llvm/GlobalVariable.h:1.32 Sat Mar 5 13:51:20 2005
+++ llvm/include/llvm/GlobalVariable.h Thu Apr 21 15:11:51 2005
@@ -1,10 +1,10 @@
//===-- llvm/GlobalVariable.h - GlobalVariable class ------------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file contains the declaration of the GlobalVariable class, which
@@ -110,12 +110,12 @@
/// and deletes it.
///
void eraseFromParent();
-
- /// Override Constant's implementation of this method so we can
+
+ /// Override Constant's implementation of this method so we can
/// replace constant initializers.
virtual void replaceUsesOfWithOnConstant(Value *From, Value *To,
bool DisableChecking = false);
-
+
virtual void print(std::ostream &OS) const;
// Methods for support type inquiry through isa, cast, and dyn_cast:
Index: llvm/include/llvm/InstrTypes.h
diff -u llvm/include/llvm/InstrTypes.h:1.42 llvm/include/llvm/InstrTypes.h:1.43
--- llvm/include/llvm/InstrTypes.h:1.42 Fri Jan 28 18:32:51 2005
+++ llvm/include/llvm/InstrTypes.h Thu Apr 21 15:11:51 2005
@@ -1,14 +1,14 @@
//===-- llvm/InstrTypes.h - Important Instruction subclasses ----*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file defines various meta classes of instructions that exist in the VM
-// representation. Specific concrete subclasses of these may be found in the
+// representation. Specific concrete subclasses of these may be found in the
// i*.h files...
//
//===----------------------------------------------------------------------===//
@@ -24,7 +24,7 @@
// TerminatorInst Class
//===----------------------------------------------------------------------===//
-/// TerminatorInst - Subclasses of this class are all able to terminate a basic
+/// TerminatorInst - Subclasses of this class are all able to terminate a basic
/// block. Thus, these are all the flow control type of operations.
///
class TerminatorInst : public Instruction {
@@ -153,7 +153,7 @@
static BinaryOperator *create(BinaryOps Op, Value *S1, Value *S2,
const std::string &Name = "",
Instruction *InsertBefore = 0);
-
+
/// create() - Construct a binary instruction, given the opcode and the two
/// operands. Also automatically insert this instruction to the end of the
/// BasicBlock specified.
@@ -183,11 +183,11 @@
return create(Instruction::OPC, V1, V2, Name, I);\
}
#include "llvm/Instruction.def"
-
+
/// Helper functions to construct and inspect unary operations (NEG and NOT)
/// via binary operators SUB and XOR:
- ///
+ ///
/// createNeg, createNot - Create the NEG and NOT
/// instructions out of SUB and XOR instructions.
///
@@ -207,13 +207,13 @@
/// getNegArgument, getNotArgument - Helper functions to extract the
/// unary argument of a NEG or NOT operation implemented via Sub or Xor.
- ///
+ ///
static const Value* getNegArgument(const BinaryOperator* Bop);
static Value* getNegArgument( BinaryOperator* Bop);
static const Value* getNotArgument(const BinaryOperator* Bop);
static Value* getNotArgument( BinaryOperator* Bop);
- BinaryOps getOpcode() const {
+ BinaryOps getOpcode() const {
return static_cast<BinaryOps>(Instruction::getOpcode());
}
@@ -231,7 +231,7 @@
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const BinaryOperator *) { return true; }
static inline bool classof(const Instruction *I) {
- return I->getOpcode() >= BinaryOpsBegin && I->getOpcode() < BinaryOpsEnd;
+ return I->getOpcode() >= BinaryOpsBegin && I->getOpcode() < BinaryOpsEnd;
}
static inline bool classof(const Value *V) {
return isa<Instruction>(V) && classof(cast<Instruction>(V));
Index: llvm/include/llvm/Instruction.h
diff -u llvm/include/llvm/Instruction.h:1.66 llvm/include/llvm/Instruction.h:1.67
--- llvm/include/llvm/Instruction.h:1.66 Mon Mar 7 14:35:45 2005
+++ llvm/include/llvm/Instruction.h Thu Apr 21 15:11:51 2005
@@ -1,10 +1,10 @@
//===-- llvm/Instruction.h - Instruction class definition -------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file contains the declaration of the Instruction class, which is the
@@ -70,7 +70,7 @@
/// extra information (e.g. load is volatile) agree.
bool isIdenticalTo(Instruction *I) const;
-
+
// Accessor methods...
//
inline const BasicBlock *getParent() const { return Parent; }
@@ -94,7 +94,7 @@
void eraseFromParent();
// ---------------------------------------------------------------------------
- /// Subclass classification... getOpcode() returns a member of
+ /// Subclass classification... getOpcode() returns a member of
/// one of the enums that is coming soon (down below)...
///
unsigned getOpcode() const { return getValueType() - InstructionVal; }
@@ -144,10 +144,10 @@
/// isTrappingInstruction - Return true if the instruction may trap.
///
bool isTrapping() const {
- return isTrapping(getOpcode());
+ return isTrapping(getOpcode());
}
static bool isTrapping(unsigned op);
-
+
virtual void print(std::ostream &OS) const { print(OS, 0); }
void print(std::ostream &OS, AssemblyAnnotationWriter *AAW) const;
@@ -156,7 +156,7 @@
static inline bool classof(const Value *V) {
return V->getValueType() >= Value::InstructionVal;
}
-
+
//----------------------------------------------------------------------
// Exported enumerations...
//
Index: llvm/include/llvm/Instructions.h
diff -u llvm/include/llvm/Instructions.h:1.15 llvm/include/llvm/Instructions.h:1.16
--- llvm/include/llvm/Instructions.h:1.15 Tue Mar 15 21:46:55 2005
+++ llvm/include/llvm/Instructions.h Thu Apr 21 15:11:51 2005
@@ -1,10 +1,10 @@
//===-- llvm/Instructions.h - Instruction subclass definitions --*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file exposes the class definitions of all of the subclasses of the
@@ -34,9 +34,9 @@
///
class AllocationInst : public UnaryInstruction {
protected:
- AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy,
+ AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy,
const std::string &Name = "", Instruction *InsertBefore = 0);
- AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy,
+ AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy,
const std::string &Name, BasicBlock *InsertAtEnd);
public:
@@ -55,7 +55,7 @@
/// getType - Overload to return most specific pointer type
///
inline const PointerType *getType() const {
- return reinterpret_cast<const PointerType*>(Instruction::getType());
+ return reinterpret_cast<const PointerType*>(Instruction::getType());
}
/// getAllocatedType - Return the type that is being allocated by the
@@ -175,7 +175,7 @@
LoadInst(const LoadInst &LI)
: UnaryInstruction(LI.getType(), Load, LI.getOperand(0)) {
setVolatile(LI.isVolatile());
-
+
#ifndef NDEBUG
AssertOK();
#endif
@@ -221,7 +221,7 @@
// StoreInst Class
//===----------------------------------------------------------------------===//
-/// StoreInst - an instruction for storing to memory
+/// StoreInst - an instruction for storing to memory
///
class StoreInst : public Instruction {
Use Ops[2];
@@ -252,7 +252,7 @@
void setVolatile(bool V) { SubclassData = V; }
/// Transparently provide more efficient getOperand methods.
- Value *getOperand(unsigned i) const {
+ Value *getOperand(unsigned i) const {
assert(i < 2 && "getOperand() out of range!");
return Ops[i];
}
@@ -319,7 +319,7 @@
~GetElementPtrInst();
virtual GetElementPtrInst *clone() const;
-
+
// getType - Overload to return most specific pointer type...
inline const PointerType *getType() const {
return reinterpret_cast<const PointerType*>(Instruction::getType());
@@ -328,15 +328,15 @@
/// getIndexedType - Returns the type of the element that would be loaded with
/// a load instruction with the specified parameters.
///
- /// A null type is returned if the indices are invalid for the specified
+ /// A null type is returned if the indices are invalid for the specified
/// pointer type.
///
- static const Type *getIndexedType(const Type *Ptr,
+ static const Type *getIndexedType(const Type *Ptr,
const std::vector<Value*> &Indices,
bool AllowStructLeaf = false);
static const Type *getIndexedType(const Type *Ptr, Value *Idx0, Value *Idx1,
bool AllowStructLeaf = false);
-
+
inline op_iterator idx_begin() { return op_begin()+1; }
inline const_op_iterator idx_begin() const { return op_begin()+1; }
inline op_iterator idx_end() { return op_end(); }
@@ -355,7 +355,7 @@
inline unsigned getNumIndices() const { // Note: always non-negative
return getNumOperands() - 1;
}
-
+
inline bool hasIndices() const {
return getNumOperands() > 1;
}
@@ -430,7 +430,7 @@
/// the instruction (i->getType()).
///
class CastInst : public UnaryInstruction {
- CastInst(const CastInst &CI)
+ CastInst(const CastInst &CI)
: UnaryInstruction(CI.getType(), Cast, CI.getOperand(0)) {
}
public:
@@ -486,9 +486,9 @@
Instruction *InsertBefore = 0);
CallInst(Value *F, Value *Actual, const std::string& Name,
BasicBlock *InsertAtEnd);
- explicit CallInst(Value *F, const std::string &Name = "",
+ explicit CallInst(Value *F, const std::string &Name = "",
Instruction *InsertBefore = 0);
- explicit CallInst(Value *F, const std::string &Name,
+ explicit CallInst(Value *F, const std::string &Name,
BasicBlock *InsertAtEnd);
~CallInst();
@@ -509,7 +509,7 @@
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const CallInst *) { return true; }
static inline bool classof(const Instruction *I) {
- return I->getOpcode() == Instruction::Call;
+ return I->getOpcode() == Instruction::Call;
}
static inline bool classof(const Value *V) {
return isa<Instruction>(V) && classof(cast<Instruction>(V));
@@ -568,7 +568,7 @@
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const ShiftInst *) { return true; }
static inline bool classof(const Instruction *I) {
- return (I->getOpcode() == Instruction::Shr) |
+ return (I->getOpcode() == Instruction::Shr) |
(I->getOpcode() == Instruction::Shl);
}
static inline bool classof(const Value *V) {
@@ -772,7 +772,7 @@
/// getIncomingBlock - Return incoming basic block #x
///
- BasicBlock *getIncomingBlock(unsigned i) const {
+ BasicBlock *getIncomingBlock(unsigned i) const {
return reinterpret_cast<BasicBlock*>(getOperand(i*2+1));
}
void setIncomingBlock(unsigned i, BasicBlock *BB) {
@@ -795,7 +795,7 @@
OperandList[OpNo].init(V, this);
OperandList[OpNo+1].init(reinterpret_cast<Value*>(BB), this);
}
-
+
/// removeIncomingValue - Remove an incoming value. This is useful if a
/// predecessor basic block is deleted. The value removed is returned.
///
@@ -812,12 +812,12 @@
return removeIncomingValue(Idx, DeletePHIIfEmpty);
}
- /// getBasicBlockIndex - Return the first index of the specified basic
+ /// getBasicBlockIndex - Return the first index of the specified basic
/// block in the value list for this PHI. Returns -1 if no instance.
///
int getBasicBlockIndex(const BasicBlock *BB) const {
Use *OL = OperandList;
- for (unsigned i = 0, e = getNumOperands(); i != e; i += 2)
+ for (unsigned i = 0, e = getNumOperands(); i != e; i += 2)
if (OL[i+1] == reinterpret_cast<const Value*>(BB)) return i/2;
return -1;
}
@@ -829,7 +829,7 @@
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const PHINode *) { return true; }
static inline bool classof(const Instruction *I) {
- return I->getOpcode() == Instruction::PHI;
+ return I->getOpcode() == Instruction::PHI;
}
static inline bool classof(const Value *V) {
return isa<Instruction>(V) && classof(cast<Instruction>(V));
@@ -1007,7 +1007,7 @@
BasicBlock *getSuccessor(unsigned i) const {
assert(i < getNumSuccessors() && "Successor # out of range for Branch!");
- return (i == 0) ? cast<BasicBlock>(getOperand(0)) :
+ return (i == 0) ? cast<BasicBlock>(getOperand(0)) :
cast<BasicBlock>(getOperand(1));
}
@@ -1052,7 +1052,7 @@
/// be specified here to make memory allocation more efficient. This
/// constructor can also autoinsert before another instruction.
SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
- Instruction *InsertBefore = 0)
+ Instruction *InsertBefore = 0)
: TerminatorInst(Instruction::Switch, 0, 0, InsertBefore) {
init(Value, Default, NumCases);
}
@@ -1062,7 +1062,7 @@
/// be specified here to make memory allocation more efficient. This
/// constructor also autoinserts at the end of the specified BasicBlock.
SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
- BasicBlock *InsertAtEnd)
+ BasicBlock *InsertAtEnd)
: TerminatorInst(Instruction::Switch, 0, 0, InsertAtEnd) {
init(Value, Default, NumCases);
}
Index: llvm/include/llvm/IntrinsicInst.h
diff -u llvm/include/llvm/IntrinsicInst.h:1.5 llvm/include/llvm/IntrinsicInst.h:1.6
--- llvm/include/llvm/IntrinsicInst.h:1.5 Sat Jan 1 12:58:23 2005
+++ llvm/include/llvm/IntrinsicInst.h Thu Apr 21 15:11:51 2005
@@ -1,10 +1,10 @@
//===-- llvm/InstrinsicInst.h - Intrinsic Instruction Wrappers --*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file defines classes that make it really easy to deal with intrinsic
@@ -53,11 +53,11 @@
static inline bool classof(const CallInst *I) {
if (const Function *CF = I->getCalledFunction())
switch (CF->getIntrinsicID()) {
- case Intrinsic::dbg_stoppoint:
- case Intrinsic::dbg_region_start:
- case Intrinsic::dbg_region_end:
- case Intrinsic::dbg_func_start:
- case Intrinsic::dbg_declare:
+ case Intrinsic::dbg_stoppoint:
+ case Intrinsic::dbg_region_start:
+ case Intrinsic::dbg_region_end:
+ case Intrinsic::dbg_func_start:
+ case Intrinsic::dbg_declare:
return true;
default: break;
}
@@ -81,7 +81,7 @@
}
Value *getContext() const { return const_cast<Value*>(getOperand(4)); }
-
+
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const DbgStopPointInst *) { return true; }
static inline bool classof(const CallInst *I) {
@@ -159,7 +159,7 @@
/// value is guaranteed to be a pointer.
Value *getSource() const { return StripPointerCasts(getRawSource()); }
-
+
void setSource(Value *Ptr) {
assert(getRawSource()->getType() == Ptr->getType() &&
"setSource called with pointer of wrong type!");
Index: llvm/include/llvm/Intrinsics.h
diff -u llvm/include/llvm/Intrinsics.h:1.29 llvm/include/llvm/Intrinsics.h:1.30
--- llvm/include/llvm/Intrinsics.h:1.29 Mon Mar 28 14:05:49 2005
+++ llvm/include/llvm/Intrinsics.h Thu Apr 21 15:11:51 2005
@@ -1,10 +1,10 @@
//===-- llvm/Instrinsics.h - LLVM Intrinsic Function Handling ---*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file defines a set of enums which allow processing of intrinsic
Index: llvm/include/llvm/Linker.h
diff -u llvm/include/llvm/Linker.h:1.14 llvm/include/llvm/Linker.h:1.15
--- llvm/include/llvm/Linker.h:1.14 Sun Dec 12 20:58:05 2004
+++ llvm/include/llvm/Linker.h Thu Apr 21 15:11:51 2005
@@ -1,10 +1,10 @@
//===- llvm/Linker.h - Module Linker Interface ------------------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
-// This file was developed by Reid Spencer and is distributed under the
+// This file was developed by Reid Spencer and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file defines the interface to the module/file/archive linker.
@@ -22,15 +22,15 @@
class Module;
/// This class provides the core functionality of linking in LLVM. It retains a
-/// Module object which is the composite of the modules and libraries linked
-/// into it. The composite Module can be retrieved via the getModule() method.
-/// In this case the Linker still retains ownership of the Module. If the
-/// releaseModule() method is used, the ownership of the Module is transferred
+/// Module object which is the composite of the modules and libraries linked
+/// into it. The composite Module can be retrieved via the getModule() method.
+/// In this case the Linker still retains ownership of the Module. If the
+/// releaseModule() method is used, the ownership of the Module is transferred
/// to the caller and the Linker object is only suitable for destruction.
-/// The Linker can link Modules from memory, bytecode files, or bytecode
-/// archives. It retains a set of search paths in which to find any libraries
-/// presented to it. By default, the linker will generate error and warning
-/// messages to std::cerr but this capability can be turned off with the
+/// The Linker can link Modules from memory, bytecode files, or bytecode
+/// archives. It retains a set of search paths in which to find any libraries
+/// presented to it. By default, the linker will generate error and warning
+/// messages to std::cerr but this capability can be turned off with the
/// QuietWarnings and QuietErrors flags. It can also be instructed to verbosely
/// print out the linking actions it is taking with the Verbose flag.
/// @brief The LLVM Linker.
@@ -41,14 +41,14 @@
public:
/// This type is used to pass the linkage items (libraries and files) to
/// the LinkItems function. It is composed of string/bool pairs. The string
- /// provides the name of the file or library (as with the -l option). The
- /// bool should be true for libraries and false for files, signifying
+ /// provides the name of the file or library (as with the -l option). The
+ /// bool should be true for libraries and false for files, signifying
/// "isLibrary".
/// @brief A list of linkage items
typedef std::vector<std::pair<std::string,bool> > ItemList;
/// This enumeration is used to control various optional features of the
- /// linker.
+ /// linker.
enum ControlFlags {
Verbose = 1, ///< Print to std::cerr what steps the linker is taking
QuietWarnings = 2, ///< Don't print errors and warnings to std::cerr.
@@ -78,33 +78,33 @@
/// @{
public:
/// This method gets the composite module into which linking is being
- /// done. The Composite module starts out empty and accumulates modules
+ /// done. The Composite module starts out empty and accumulates modules
/// linked into it via the various LinkIn* methods. This method does not
/// release the Module to the caller. The Linker retains ownership and will
- /// destruct the Module when the Linker is destructed.
+ /// destruct the Module when the Linker is destructed.
/// @see releaseModule
/// @brief Get the linked/composite module.
Module* getModule() const { return Composite; }
/// This method releases the composite Module into which linking is being
/// done. Ownership of the composite Module is transferred to the caller who
- /// must arrange for its destruct. After this method is called, the Linker
- /// terminates the linking session for the returned Module. It will no
- /// longer utilize the returned Module but instead resets itself for
- /// subsequent linking as if the constructor had been called. The Linker's
- /// LibPaths and flags to be reset, and memory will be released.
- /// @brief Release the linked/composite module.
+ /// must arrange for its destruct. After this method is called, the Linker
+ /// terminates the linking session for the returned Module. It will no
+ /// longer utilize the returned Module but instead resets itself for
+ /// subsequent linking as if the constructor had been called. The Linker's
+ /// LibPaths and flags to be reset, and memory will be released.
+ /// @brief Release the linked/composite module.
Module* releaseModule();
/// This method gets the list of libraries that form the path that the
- /// Linker will search when it is presented with a library name.
+ /// Linker will search when it is presented with a library name.
/// @brief Get the Linkers library path
const std::vector<sys::Path>& getLibPaths() const { return LibPaths; }
/// This method returns an error string suitable for printing to the user.
/// The return value will be empty unless an error occurred in one of the
/// LinkIn* methods. In those cases, the LinkIn* methods will have returned
- /// true, indicating an error occurred. At most one error is retained so
+ /// true, indicating an error occurred. At most one error is retained so
/// this function always returns the last error that occurred. Note that if
/// the Quiet control flag is not set, the error string will have already
/// been printed to std::cerr.
@@ -124,7 +124,7 @@
void addPath(const sys::Path& path);
/// Add a set of paths to the list of paths that the linker will search. The
- /// Linker accumulates the set of libraries added. The \p paths will be
+ /// Linker accumulates the set of libraries added. The \p paths will be
/// added to the end of the Linker's list. Order will be retained.
/// @brief Add a set of paths.
void addPaths(const std::vector<std::string>& paths);
@@ -140,14 +140,14 @@
/// @brief Set control flags.
void setFlags(unsigned flags) { Flags = flags; }
- /// This method is the main interface to the linker. It can be used to
+ /// This method is the main interface to the linker. It can be used to
/// link a set of linkage items into a module. A linkage item is either a
/// file name with fully qualified path, or a library for which the Linker's
/// LibraryPath will be utilized to locate the library. The bool value in
- /// the LinkItemKind should be set to true for libraries. This function
- /// allows linking to preserve the order of specification associated with
- /// the command line, or for other purposes. Each item will be linked in
- /// turn as it occurs in \p Items.
+ /// the LinkItemKind should be set to true for libraries. This function
+ /// allows linking to preserve the order of specification associated with
+ /// the command line, or for other purposes. Each item will be linked in
+ /// turn as it occurs in \p Items.
/// @returns true if an error occurred, false otherwise
/// @see LinkItemKind
/// @see getLastError
@@ -156,11 +156,11 @@
const ItemList& Items // Set of libraries/files to link in
);
- /// This function links the bytecode \p Files into the composite module.
- /// Note that this does not do any linking of unresolved symbols. The \p
- /// Files are all completely linked into \p HeadModule regardless of
- /// unresolved symbols. This function just loads each bytecode file and
- /// calls LinkInModule on them.
+ /// This function links the bytecode \p Files into the composite module.
+ /// Note that this does not do any linking of unresolved symbols. The \p
+ /// Files are all completely linked into \p HeadModule regardless of
+ /// unresolved symbols. This function just loads each bytecode file and
+ /// calls LinkInModule on them.
/// @returns true if an error occurs, false otherwise
/// @see getLastError
/// @brief Link in multiple files.
@@ -179,11 +179,11 @@
const sys::Path& File ///< File to link in.
);
- /// This function provides a way to selectively link in a set of modules,
- /// found in libraries, based on the unresolved symbols in the composite
+ /// This function provides a way to selectively link in a set of modules,
+ /// found in libraries, based on the unresolved symbols in the composite
/// module. Each item in \p Libraries should be the base name of a library,
/// as if given with the -l option of a linker tool. The Linker's LibPaths
- /// are searched for the \p Libraries and any found will be linked in with
+ /// are searched for the \p Libraries and any found will be linked in with
/// LinkInArchive. If an error occurs, the Linker's error string is set.
/// @see LinkInArchive
/// @see getLastError
@@ -193,9 +193,9 @@
const std::vector<std::string> & Libraries ///< Libraries to link in
);
- /// This function provides a way to selectively link in a set of modules,
+ /// This function provides a way to selectively link in a set of modules,
/// found in one library, based on the unresolved symbols in the composite
- /// module.The \p Library should be the base name of a library, as if given
+ /// module.The \p Library should be the base name of a library, as if given
/// with the -l option of a linker tool. The Linker's LibPaths are searched
/// for the \P Library and if found, it will be linked in with via the
/// LinkInArchive method. If an error occurs, the Linker's error string is
@@ -209,25 +209,25 @@
);
/// This function links one bytecode archive, \p Filename, into the module.
- /// The archive is searched to resolve outstanding symbols. Any modules in
- /// the archive that resolve outstanding symbols will be linked in. The
- /// library is searched repeatedly until no more modules that resolve
+ /// The archive is searched to resolve outstanding symbols. Any modules in
+ /// the archive that resolve outstanding symbols will be linked in. The
+ /// library is searched repeatedly until no more modules that resolve
/// symbols can be found. If an error occurs, the error string is set.
- /// To speed up this function, ensure the the archive has been processed
+ /// To speed up this function, ensure the the archive has been processed
/// llvm-ranlib or the S option was given to llvm-ar when the archive was
/// created. These tools add a symbol table to the archive which makes the
/// search for undefined symbols much faster.
/// @see getLastError
- /// @returns true if an error occurs, otherwise false.
+ /// @returns true if an error occurs, otherwise false.
/// @brief Link in one archive.
- bool LinkInArchive(
+ bool LinkInArchive(
const sys::Path& Filename ///< Filename of the archive to link
);
/// This method links the \p Src module into the Linker's Composite module
- /// by calling LinkModules. All the other LinkIn* methods eventually
- /// result in calling this method to link a Module into the Linker's
- /// composite.
+ /// by calling LinkModules. All the other LinkIn* methods eventually
+ /// result in calling this method to link a Module into the Linker's
+ /// composite.
/// @see LinkModules
/// @returns True if an error occurs, false otherwise.
/// @brief Link in a module.
@@ -235,11 +235,11 @@
Module* Src ///< Module linked into \p Dest
) { return LinkModules(Composite, Src, &Error); }
- /// This is the heart of the linker. This method will take unconditional
+ /// This is the heart of the linker. This method will take unconditional
/// control of the \p Src module and link it into the \p Dest module. The
/// \p Src module will be destructed or subsumed by this method. In either
/// case it is not usable by the caller after this method is invoked. Only
- /// the \p Dest module will remain. The \p Src module is linked into the
+ /// the \p Dest module will remain. The \p Src module is linked into the
/// Linker's composite module such that types, global variables, functions,
/// and etc. are matched and resolved. If an error occurs, this function
/// returns true and ErrorMsg is set to a descriptive message about the
@@ -277,7 +277,7 @@
std::string Error; ///< Text of error that occurred.
std::string ProgramName; ///< Name of the program being linked
/// @}
-
+
};
} // End llvm namespace
Index: llvm/include/llvm/Module.h
diff -u llvm/include/llvm/Module.h:1.60 llvm/include/llvm/Module.h:1.61
--- llvm/include/llvm/Module.h:1.60 Mon Mar 14 23:13:47 2005
+++ llvm/include/llvm/Module.h Thu Apr 21 15:11:51 2005
@@ -1,13 +1,13 @@
//===-- llvm/Module.h - C++ class to represent a VM module ------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
-// This file contains the declarations for the Module class that is used to
+// This file contains the declarations for the Module class that is used to
// maintain all the information related to a VM module.
//
// A module also maintains a GlobalValRefMap object that is used to hold all
@@ -229,7 +229,7 @@
/// @brief Remove a library from the list of dependent libraries
inline void removeLibrary(const std::string& Lib) { LibraryList.remove(Lib); }
- /// @brief Get all the libraries
+ /// @brief Get all the libraries
inline const LibraryListType& getLibraries() const { return LibraryList; }
//===--------------------------------------------------------------------===//
@@ -245,7 +245,7 @@
/// '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
- /// valid on an object that has "dropped all references", except operator
+ /// valid on an object that has "dropped all references", except operator
/// delete.
///
void dropAllReferences();
Index: llvm/include/llvm/ModuleProvider.h
diff -u llvm/include/llvm/ModuleProvider.h:1.10 llvm/include/llvm/ModuleProvider.h:1.11
--- llvm/include/llvm/ModuleProvider.h:1.10 Sat Jan 31 18:32:48 2004
+++ llvm/include/llvm/ModuleProvider.h Thu Apr 21 15:11:51 2005
@@ -1,10 +1,10 @@
//===-- llvm/ModuleProvider.h - Interface for module providers --*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file provides an abstract interface for loading a module from some
@@ -48,12 +48,12 @@
/// releaseModule - no longer delete the Module* when provider is destroyed.
/// Note that this can throw an exception if the module is corrupt!
///
- virtual Module* releaseModule() {
+ virtual Module* releaseModule() {
// Since we're losing control of this Module, we must hand it back complete
materializeModule();
- Module *tempM = TheModule;
- TheModule = 0;
- return tempM;
+ Module *tempM = TheModule;
+ TheModule = 0;
+ return tempM;
}
};
Index: llvm/include/llvm/PassAnalysisSupport.h
diff -u llvm/include/llvm/PassAnalysisSupport.h:1.18 llvm/include/llvm/PassAnalysisSupport.h:1.19
--- llvm/include/llvm/PassAnalysisSupport.h:1.18 Fri Mar 12 00:13:15 2004
+++ llvm/include/llvm/PassAnalysisSupport.h Thu Apr 21 15:11:51 2005
@@ -1,10 +1,10 @@
//===- llvm/PassAnalysisSupport.h - Analysis Pass Support code --*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file defines stuff that is used to define and "use" Analysis Passes.
@@ -25,10 +25,10 @@
//===----------------------------------------------------------------------===//
// AnalysisUsage - Represent the analysis usage information of a pass. This
-// tracks analyses that the pass REQUIRES (must be available when the pass
+// tracks analyses that the pass REQUIRES (must be available when the pass
// runs), REQUIRES TRANSITIVE (must be available throughout the lifetime of the
// pass), and analyses that the pass PRESERVES (the pass does not invalidate the
-// results of these analyses). This information is provided by a pass to the
+// results of these analyses). This information is provided by a pass to the
// Pass infrastructure through the getAnalysisUsage virtual function.
//
class AnalysisUsage {
@@ -37,7 +37,7 @@
bool PreservesAll;
public:
AnalysisUsage() : PreservesAll(false) {}
-
+
// addRequired - Add the specified ID to the required set of the usage info
// for a pass.
//
Index: llvm/include/llvm/Pass.h
diff -u llvm/include/llvm/Pass.h:1.50 llvm/include/llvm/Pass.h:1.51
--- llvm/include/llvm/Pass.h:1.50 Tue Mar 15 21:54:50 2005
+++ llvm/include/llvm/Pass.h Thu Apr 21 15:11:51 2005
@@ -1,10 +1,10 @@
//===- llvm/Pass.h - Base class for Passes ----------------------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file defines a base class that indicates that a specified class is a
Index: llvm/include/llvm/PassManager.h
diff -u llvm/include/llvm/PassManager.h:1.12 llvm/include/llvm/PassManager.h:1.13
--- llvm/include/llvm/PassManager.h:1.12 Sun Sep 19 23:42:19 2004
+++ llvm/include/llvm/PassManager.h Thu Apr 21 15:11:51 2005
@@ -1,10 +1,10 @@
//===- llvm/PassManager.h - Container for Passes ----------------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file defines the PassManager class. This class is used to hold,
@@ -63,7 +63,7 @@
///
void add(FunctionPass *P);
- /// add - ImmutablePasses are not FunctionPasses, so we have a
+ /// add - ImmutablePasses are not FunctionPasses, so we have a
/// special hack to get them into a FunctionPassManager.
///
void add(ImmutablePass *IP);
Index: llvm/include/llvm/PassSupport.h
diff -u llvm/include/llvm/PassSupport.h:1.20 llvm/include/llvm/PassSupport.h:1.21
--- llvm/include/llvm/PassSupport.h:1.20 Fri Jun 4 15:39:05 2004
+++ llvm/include/llvm/PassSupport.h Thu Apr 21 15:11:51 2005
@@ -1,10 +1,10 @@
//===- llvm/PassSupport.h - Pass Support code -------------------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file defines stuff that is used to define and "use" Passes. This file
@@ -55,7 +55,7 @@
/// PassInfo ctor - Do not call this directly, this should only be invoked
/// through RegisterPass.
- PassInfo(const char *name, const char *arg, const std::type_info &ti,
+ PassInfo(const char *name, const char *arg, const std::type_info &ti,
unsigned char pt, Pass *(*normal)() = 0,
Pass *(*targetctor)(TargetMachine &) = 0)
: PassName(name), PassArgument(arg), TypeInfo(ti), PassType(pt),
@@ -86,7 +86,7 @@
/// getNormalCtor - Return a pointer to a function, that when called, creates
/// an instance of the pass and returns it. This pointer may be null if there
/// is no default constructor for the pass.
- ///
+ ///
Pass *(*getNormalCtor() const)() {
return NormalCtor;
}
@@ -135,7 +135,7 @@
/// for example will not be able to see the pass and attempts to create the pass
/// will fail. This template is used in the follow manner (at global scope, in
/// your .cpp file):
-///
+///
/// static RegisterPass<YourPassClassName> tmp("passopt", "My Pass Name");
///
/// This statement will cause your pass to be created by calling the default
@@ -145,7 +145,7 @@
///
/// Pass *createMyPass(foo &opt) { return new MyPass(opt); }
/// static RegisterPass<PassClassName> tmp("passopt", "My Name", createMyPass);
-///
+///
struct RegisterPassBase {
/// getPassInfo - Get the pass info for the registered class...
///
@@ -172,7 +172,7 @@
template<typename PassName>
struct RegisterPass : public RegisterPassBase {
-
+
// Register Pass using default constructor...
RegisterPass(const char *PassArg, const char *Name, unsigned char PassTy = 0){
registerPass(new PassInfo(Name, PassArg, typeid(PassName), PassTy,
@@ -226,7 +226,7 @@
RegisterOpt(const char *PassArg, const char *Name, FunctionPass *(*ctor)(),
bool CFGOnly = false) {
registerPass(new PassInfo(Name, PassArg, typeid(PassName),
- PassInfo::Optimization,
+ PassInfo::Optimization,
static_cast<Pass*(*)()>(ctor)));
if (CFGOnly) setOnlyUsesCFG();
}
Index: llvm/include/llvm/SymbolTable.h
diff -u llvm/include/llvm/SymbolTable.h:1.49 llvm/include/llvm/SymbolTable.h:1.50
--- llvm/include/llvm/SymbolTable.h:1.49 Sun Mar 6 00:03:44 2005
+++ llvm/include/llvm/SymbolTable.h Thu Apr 21 15:11:51 2005
@@ -1,11 +1,11 @@
//===-- llvm/SymbolTable.h - Implement a type plane'd symtab ----*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and re-written by Reid
-// Spencer. It is distributed under the University of Illinois Open Source
+// Spencer. It is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file implements the main symbol table for LLVM.
@@ -21,23 +21,23 @@
namespace llvm {
/// This class provides a symbol table of name/value pairs that is broken
-/// up by type. For each Type* there is a "plane" of name/value pairs in
-/// the symbol table. Identical types may have overlapping symbol names as
-/// long as they are distinct. The SymbolTable also tracks, separately, a
-/// map of name/type pairs. This allows types to be named. Types are treated
+/// up by type. For each Type* there is a "plane" of name/value pairs in
+/// the symbol table. Identical types may have overlapping symbol names as
+/// long as they are distinct. The SymbolTable also tracks, separately, a
+/// map of name/type pairs. This allows types to be named. Types are treated
/// distinctly from Values.
-///
+///
/// The SymbolTable provides several utility functions for answering common
/// questions about its contents as well as an iterator interface for
-/// directly iterating over the contents. To reduce confusion, the terms
+/// directly iterating over the contents. To reduce confusion, the terms
/// "type", "value", and "plane" are used consistently. For example,
-/// There is a TypeMap typedef that is the mapping of names to Types.
-/// Similarly there is a ValueMap typedef that is the mapping of
+/// There is a TypeMap typedef that is the mapping of names to Types.
+/// Similarly there is a ValueMap typedef that is the mapping of
/// names to Values. Finally, there is a PlaneMap typedef that is the
/// mapping of types to planes of ValueMap. This is the basic structure
/// of the symbol table. When you call type_begin() you're asking
/// for an iterator at the start of the TypeMap. When you call
-/// plane_begin(), you're asking for an iterator at the start of
+/// plane_begin(), you're asking for an iterator at the start of
/// the PlaneMap. Finally, when you call value_begin(), you're asking
/// for an iterator at the start of a ValueMap for a specific type
/// plane.
@@ -102,7 +102,7 @@
/// @brief Lookup a type by name.
Type* lookupType(const std::string& name) const;
- /// @returns true iff the type map and the type plane are both not
+ /// @returns true iff the type map and the type plane are both not
/// empty.
/// @brief Determine if the symbol table is empty
inline bool isEmpty() const { return pmap.empty() && tmap.empty(); }
@@ -110,17 +110,17 @@
/// @brief The number of name/type pairs is returned.
inline unsigned num_types() const { return (unsigned)tmap.size(); }
- /// Given a base name, return a string that is either equal to it or
- /// derived from it that does not already occur in the symbol table
+ /// Given a base name, return a string that is either equal to it or
+ /// derived from it that does not already occur in the symbol table
/// for the specified type.
/// @brief Get a name unique to this symbol table
- std::string getUniqueName(const Type *Ty,
+ std::string getUniqueName(const Type *Ty,
const std::string &BaseName) const;
/// This function can be used from the debugger to display the
/// content of the symbol table while debugging.
/// @brief Print out symbol table on stderr
- void dump() const;
+ void dump() const;
/// @}
/// @name Iteration
@@ -129,12 +129,12 @@
/// Get an iterator that starts at the beginning of the type planes.
/// The iterator will iterate over the Type/ValueMap pairs in the
- /// type planes.
+ /// type planes.
inline plane_iterator plane_begin() { return pmap.begin(); }
- /// Get a const_iterator that starts at the beginning of the type
- /// planes. The iterator will iterate over the Type/ValueMap pairs
- /// in the type planes.
+ /// Get a const_iterator that starts at the beginning of the type
+ /// planes. The iterator will iterate over the Type/ValueMap pairs
+ /// in the type planes.
inline plane_const_iterator plane_begin() const { return pmap.begin(); }
/// Get an iterator at the end of the type planes. This serves as
@@ -148,9 +148,9 @@
/// Get an iterator that starts at the beginning of a type plane.
/// The iterator will iterate over the name/value pairs in the type plane.
/// @note The type plane must already exist before using this.
- inline value_iterator value_begin(const Type *Typ) {
+ inline value_iterator value_begin(const Type *Typ) {
assert(Typ && "Can't get value iterator with null type!");
- return pmap.find(Typ)->second.begin();
+ return pmap.find(Typ)->second.begin();
}
/// Get a const_iterator that starts at the beginning of a type plane.
@@ -158,23 +158,23 @@
/// @note The type plane must already exist before using this.
inline value_const_iterator value_begin(const Type *Typ) const {
assert(Typ && "Can't get value iterator with null type!");
- return pmap.find(Typ)->second.begin();
+ return pmap.find(Typ)->second.begin();
}
/// Get an iterator to the end of a type plane. This serves as the marker
/// for end of iteration of the type plane.
/// @note The type plane must already exist before using this.
- inline value_iterator value_end(const Type *Typ) {
+ inline value_iterator value_end(const Type *Typ) {
assert(Typ && "Can't get value iterator with null type!");
- return pmap.find(Typ)->second.end();
+ return pmap.find(Typ)->second.end();
}
/// Get a const_iterator to the end of a type plane. This serves as the
/// marker for end of iteration of the type plane.
/// @note The type plane must already exist before using this.
- inline value_const_iterator value_end(const Type *Typ) const {
+ inline value_const_iterator value_end(const Type *Typ) const {
assert(Typ && "Can't get value iterator with null type!");
- return pmap.find(Typ)->second.end();
+ return pmap.find(Typ)->second.end();
}
/// Get an iterator to the start of the name/Type map.
@@ -187,7 +187,7 @@
/// marker for end of iteration of the types.
inline type_iterator type_end() { return tmap.end(); }
- /// Get a const-iterator to the end of the name/Type map. This serves
+ /// Get a const-iterator to the end of the name/Type map. This serves
/// as the marker for end of iteration of the types.
inline type_const_iterator type_end() const { return tmap.end(); }
@@ -202,9 +202,9 @@
/// This method returns a plane_iterator for iteration over the
/// type planes starting at a specific plane, given by \p Ty.
/// @brief Find a type plane.
- inline plane_iterator find(const Type* Typ) {
+ inline plane_iterator find(const Type* Typ) {
assert(Typ && "Can't find type plane with null type!");
- return pmap.find(Typ);
+ return pmap.find(Typ);
}
@@ -265,7 +265,7 @@
/// @brief Insert a value into the symbol table with the specified name.
void insertEntry(const std::string &Name, const Type *Ty, Value *V);
- /// This function is called when one of the types in the type plane
+ /// This function is called when one of the types in the type plane
/// is refined.
virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy);
@@ -273,20 +273,20 @@
virtual void typeBecameConcrete(const DerivedType *AbsTy);
/// @}
-/// @name Internal Data
+/// @name Internal Data
/// @{
private:
/// This is the main content of the symbol table. It provides
/// separate type planes for named values. That is, each named
- /// value is organized into a separate dictionary based on
+ /// value is organized into a separate dictionary based on
/// Type. This means that the same name can be used for different
- /// types without conflict.
+ /// types without conflict.
/// @brief The mapping of types to names to values.
PlaneMap pmap;
/// This is the type plane. It is separated from the pmap
- /// because the elements of the map are name/Type pairs not
+ /// because the elements of the map are name/Type pairs not
/// name/Value pairs and Type is not a Value.
TypeMap tmap;
Index: llvm/include/llvm/SymbolTableListTraits.h
diff -u llvm/include/llvm/SymbolTableListTraits.h:1.4 llvm/include/llvm/SymbolTableListTraits.h:1.5
--- llvm/include/llvm/SymbolTableListTraits.h:1.4 Tue Nov 11 16:41:30 2003
+++ llvm/include/llvm/SymbolTableListTraits.h Thu Apr 21 15:11:51 2005
@@ -1,10 +1,10 @@
//===-- llvm/SymbolTableListTraits.h - Traits for iplist --------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file defines a generic class that is used to implement the automatic
@@ -64,7 +64,7 @@
void addNodeToList(ValueSubClass *V);
void removeNodeFromList(ValueSubClass *V);
- void transferNodesFromList(iplist<ValueSubClass,
+ void transferNodesFromList(iplist<ValueSubClass,
ilist_traits<ValueSubClass> > &L2,
ilist_iterator<ValueSubClass> first,
ilist_iterator<ValueSubClass> last);
Index: llvm/include/llvm/Type.h
diff -u llvm/include/llvm/Type.h:1.74 llvm/include/llvm/Type.h:1.75
--- llvm/include/llvm/Type.h:1.74 Mon Mar 7 14:35:45 2005
+++ llvm/include/llvm/Type.h Thu Apr 21 15:11:51 2005
@@ -1,18 +1,18 @@
//===-- llvm/Type.h - Classes for handling data types -----------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file contains the declaration of the Type class. For more "Type" type
// stuff, look in DerivedTypes.h.
//
// Note that instances of the Type class are immutable: once they are created,
-// they are never changed. Also note that only one instance of a particular
-// type is ever created. Thus seeing if two types are equal is a matter of
+// they are never changed. Also note that only one instance of a particular
+// type is ever created. Thus seeing if two types are equal is a matter of
// doing a trivial pointer comparison.
//
// Types, once allocated, are never free'd, unless they are an abstract type
@@ -20,7 +20,7 @@
//
// Opaque types are simple derived types with no state. There may be many
// different Opaque type objects floating around, but two are only considered
-// identical if they are pointer equals of each other. This allows us to have
+// identical if they are pointer equals of each other. This allows us to have
// two opaque types that end up resolving to different concrete types later.
//
// Opaque types are also kinda weird and scary and different because they have
@@ -55,7 +55,7 @@
///===-------------------------------------------------------------------===//
/// Definitions of all of the base types for the Type system. Based on this
/// value, you can cast to a "DerivedType" subclass (see DerivedTypes.h)
- /// Note: If you add an element to this, you need to add an element to the
+ /// Note: If you add an element to this, you need to add an element to the
/// Type::getPrimitiveType function, or else things will break!
///
enum TypeID {
@@ -66,14 +66,14 @@
UIntTyID , IntTyID, // 6, 7: 32 bit types...
ULongTyID , LongTyID, // 8, 9: 64 bit types...
FloatTyID , DoubleTyID, // 10,11: Floating point types...
- LabelTyID , // 12 : Labels...
+ LabelTyID , // 12 : Labels...
// Derived types... see DerivedTypes.h file...
// Make sure FirstDerivedTyID stays up to date!!!
FunctionTyID , StructTyID, // Functions... Structs...
ArrayTyID , PointerTyID, // Array... pointer...
OpaqueTyID, // Opaque type instances...
- PackedTyID, // SIMD 'packed' format...
+ PackedTyID, // SIMD 'packed' format...
//...
NumTypeIDs, // Must remain as last defined ID
@@ -145,18 +145,18 @@
/// Float and Double.
///
bool isSigned() const {
- return ID == SByteTyID || ID == ShortTyID ||
- ID == IntTyID || ID == LongTyID;
+ return ID == SByteTyID || ID == ShortTyID ||
+ ID == IntTyID || ID == LongTyID;
}
-
+
/// isUnsigned - Return whether a numeric type is unsigned. This is not quite
/// the complement of isSigned... nonnumeric types return false as they do
/// with isSigned. This returns true for UByteTy, UShortTy, UIntTy, and
/// ULongTy
- ///
+ ///
bool isUnsigned() const {
- return ID == UByteTyID || ID == UShortTyID ||
- ID == UIntTyID || ID == ULongTyID;
+ return ID == UByteTyID || ID == UShortTyID ||
+ ID == UIntTyID || ID == ULongTyID;
}
/// isInteger - Equivalent to isSigned() || isUnsigned()
@@ -173,7 +173,7 @@
bool isFloatingPoint() const { return ID == FloatTyID || ID == DoubleTyID; }
/// isAbstract - True if the type is either an Opaque type, or is a derived
- /// type that includes an opaque type somewhere in it.
+ /// type that includes an opaque type somewhere in it.
///
inline bool isAbstract() const { return Abstract; }
@@ -192,7 +192,7 @@
/// isFirstClassType - Return true if the value is holdable in a register.
///
inline bool isFirstClassType() const {
- return (ID != VoidTyID && ID <= LastPrimitiveTyID) ||
+ return (ID != VoidTyID && ID <= LastPrimitiveTyID) ||
ID == PointerTyID || ID == PackedTyID;
}
@@ -271,7 +271,7 @@
static Type *VoidTy , *BoolTy;
static Type *SByteTy, *UByteTy,
*ShortTy, *UShortTy,
- *IntTy , *UIntTy,
+ *IntTy , *UIntTy,
*LongTy , *ULongTy;
static Type *FloatTy, *DoubleTy;
@@ -295,7 +295,7 @@
assert(isAbstract() && "Cannot add a reference to a non-abstract type!");
++RefCount;
}
-
+
void dropRef() const {
assert(isAbstract() && "Cannot drop a reference to a non-abstract type!");
assert(RefCount && "No objects are currently referencing this object!");
@@ -325,7 +325,7 @@
//===----------------------------------------------------------------------===//
// Define some inline methods for the AbstractTypeUser.h:PATypeHandle class.
-// These are defined here because they MUST be inlined, yet are dependent 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.
@@ -375,7 +375,7 @@
//===----------------------------------------------------------------------===//
-// Provide specializations of GraphTraits to be able to treat a type as a
+// Provide specializations of GraphTraits to be able to treat a type as a
// graph of sub types...
template <> struct GraphTraits<Type*> {
@@ -383,10 +383,10 @@
typedef Type::subtype_iterator ChildIteratorType;
static inline NodeType *getEntryNode(Type *T) { return T; }
- static inline ChildIteratorType child_begin(NodeType *N) {
- return N->subtype_begin();
+ static inline ChildIteratorType child_begin(NodeType *N) {
+ return N->subtype_begin();
}
- static inline ChildIteratorType child_end(NodeType *N) {
+ static inline ChildIteratorType child_end(NodeType *N) {
return N->subtype_end();
}
};
@@ -396,15 +396,15 @@
typedef Type::subtype_iterator ChildIteratorType;
static inline NodeType *getEntryNode(const Type *T) { return T; }
- static inline ChildIteratorType child_begin(NodeType *N) {
- return N->subtype_begin();
+ static inline ChildIteratorType child_begin(NodeType *N) {
+ return N->subtype_begin();
}
- static inline ChildIteratorType child_end(NodeType *N) {
+ static inline ChildIteratorType child_end(NodeType *N) {
return N->subtype_end();
}
};
-template <> inline bool isa_impl<PointerType, Type>(const Type &Ty) {
+template <> inline bool isa_impl<PointerType, Type>(const Type &Ty) {
return Ty.getTypeID() == Type::PointerTyID;
}
Index: llvm/include/llvm/Use.h
diff -u llvm/include/llvm/Use.h:1.11 llvm/include/llvm/Use.h:1.12
--- llvm/include/llvm/Use.h:1.11 Mon Jan 31 19:21:51 2005
+++ llvm/include/llvm/Use.h Thu Apr 21 15:11:51 2005
@@ -1,10 +1,10 @@
//===-- llvm/Use.h - Definition of the Use class ----------------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This defines the Use class. The Use class represents the operand of an
@@ -114,7 +114,7 @@
value_use_iterator(const _Self &I) : U(I.U) {}
value_use_iterator() {}
- bool operator==(const _Self &x) const {
+ bool operator==(const _Self &x) const {
return U == x.U;
}
bool operator!=(const _Self &x) const {
@@ -125,14 +125,14 @@
_Self &operator++() { // Preincrement
assert(U && "Cannot increment end iterator!");
U = U->getNext();
- return *this;
+ return *this;
}
_Self operator++(int) { // Postincrement
- _Self tmp = *this; ++*this; return tmp;
+ _Self tmp = *this; ++*this; return tmp;
}
// Retrieve a reference to the current SCC
- UserTy *operator*() const {
+ UserTy *operator*() const {
assert(U && "Cannot increment end iterator!");
return U->getUser();
}
Index: llvm/include/llvm/User.h
diff -u llvm/include/llvm/User.h:1.34 llvm/include/llvm/User.h:1.35
--- llvm/include/llvm/User.h:1.34 Sun Feb 27 00:15:09 2005
+++ llvm/include/llvm/User.h Thu Apr 21 15:11:51 2005
@@ -1,10 +1,10 @@
//===-- llvm/User.h - User class definition ---------------------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This class defines the interface that one who 'use's a Value must implement.
@@ -39,11 +39,11 @@
unsigned NumOperands;
public:
- User(const Type *Ty, unsigned vty, Use *OpList, unsigned NumOps,
+ User(const Type *Ty, unsigned vty, Use *OpList, unsigned NumOps,
const std::string &name = "")
: Value(Ty, vty, name), OperandList(OpList), NumOperands(NumOps) {}
- Value *getOperand(unsigned i) const {
+ Value *getOperand(unsigned i) const {
assert(i < NumOperands && "getOperand() out of range!");
return OperandList[i];
}
@@ -69,7 +69,7 @@
// '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
- // valid on an object that has "dropped all references", except operator
+ // valid on an object that has "dropped all references", except operator
// delete.
//
void dropAllReferences() {
@@ -92,7 +92,7 @@
template<> struct simplify_type<User::op_iterator> {
typedef Value* SimpleType;
-
+
static SimpleType getSimplifiedValue(const User::op_iterator &Val) {
return static_cast<SimpleType>(Val->get());
}
@@ -103,7 +103,7 @@
template<> struct simplify_type<User::const_op_iterator> {
typedef Value* SimpleType;
-
+
static SimpleType getSimplifiedValue(const User::const_op_iterator &Val) {
return static_cast<SimpleType>(Val->get());
}
Index: llvm/include/llvm/Value.h
diff -u llvm/include/llvm/Value.h:1.75 llvm/include/llvm/Value.h:1.76
--- llvm/include/llvm/Value.h:1.75 Tue Mar 15 21:46:55 2005
+++ llvm/include/llvm/Value.h Thu Apr 21 15:11:51 2005
@@ -1,10 +1,10 @@
//===-- llvm/Value.h - Definition of the Value class ------------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file defines the very important Value class. This is subclassed by a
@@ -60,7 +60,7 @@
public:
Value(const Type *Ty, unsigned scid, const std::string &name = "");
virtual ~Value();
-
+
/// dump - Support for debugging, callable in GDB: V->dump()
//
virtual void dump() const;
@@ -68,19 +68,19 @@
/// print - Implement operator<< on Value...
///
virtual void print(std::ostream &O) const = 0;
-
+
/// All values are typed, get the type of this value.
///
inline const Type *getType() const { return Ty; }
-
+
// All values can potentially be named...
inline bool hasName() const { return !Name.empty(); }
inline const std::string &getName() const { return Name; }
void setName(const std::string &name);
-
+
/// replaceAllUsesWith - Go through the uses list for this definition and make
- /// each use point to "V" instead of "this". After this completes, 'this's
+ /// each use point to "V" instead of "this". After this completes, 'this's
/// use list is guaranteed to be empty.
///
void replaceAllUsesWith(Value *V);
@@ -184,7 +184,7 @@
if (Val) removeFromList();
}
-void Use::set(Value *V) {
+void Use::set(Value *V) {
if (Val) removeFromList();
Val = V;
if (V) V->addUse(*this);
@@ -194,7 +194,7 @@
// isa - Provide some specializations of isa so that we don't have to include
// the subtype header files to test to see if the value is a subclass...
//
-template <> inline bool isa_impl<Constant, Value>(const Value &Val) {
+template <> inline bool isa_impl<Constant, Value>(const Value &Val) {
return Val.getValueType() == Value::SimpleConstantVal ||
Val.getValueType() == Value::FunctionVal ||
Val.getValueType() == Value::GlobalVariableVal ||
@@ -202,22 +202,22 @@
Val.getValueType() == Value::ConstantAggregateZeroVal ||
Val.getValueType() == Value::UndefValueVal;
}
-template <> inline bool isa_impl<Argument, Value>(const Value &Val) {
+template <> inline bool isa_impl<Argument, Value>(const Value &Val) {
return Val.getValueType() == Value::ArgumentVal;
}
-template <> inline bool isa_impl<Instruction, Value>(const Value &Val) {
+template <> inline bool isa_impl<Instruction, Value>(const Value &Val) {
return Val.getValueType() >= Value::InstructionVal;
}
-template <> inline bool isa_impl<BasicBlock, Value>(const Value &Val) {
+template <> inline bool isa_impl<BasicBlock, Value>(const Value &Val) {
return Val.getValueType() == Value::BasicBlockVal;
}
-template <> inline bool isa_impl<Function, Value>(const Value &Val) {
+template <> inline bool isa_impl<Function, Value>(const Value &Val) {
return Val.getValueType() == Value::FunctionVal;
}
-template <> inline bool isa_impl<GlobalVariable, Value>(const Value &Val) {
+template <> inline bool isa_impl<GlobalVariable, Value>(const Value &Val) {
return Val.getValueType() == Value::GlobalVariableVal;
}
-template <> inline bool isa_impl<GlobalValue, Value>(const Value &Val) {
+template <> inline bool isa_impl<GlobalValue, Value>(const Value &Val) {
return isa<GlobalVariable>(Val) || isa<Function>(Val);
}
More information about the llvm-commits
mailing list