Skip to content

Commit

Permalink
Remove trailing whitespace
Browse files Browse the repository at this point in the history 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@168103 91177308-0d34-0410-b5e6-96231b3b80d8
  • Loading branch information
@milseman
milseman committed Nov 15, 2012
1 parent bac29d3 commit 407a616
Show file tree
Hide file tree
Showing 10 changed files with 205 additions and 205 deletions.
12 changes: 6 additions & 6 deletions include/llvm/Analysis/InstructionSimplify.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -57,7 +57,7 @@ namespace llvm {

/// SimplifyUDivInst - Given operands for a UDiv, see if we can
/// fold the result. If not, this returns null.
Value *SimplifyUDivInst(Value *LHS, Value *RHS, const DataLayout *TD = 0,
Value *SimplifyUDivInst(Value *LHS, Value *RHS, const DataLayout *TD = 0,
const TargetLibraryInfo *TLI = 0,
const DominatorTree *DT = 0);

Expand All @@ -69,7 +69,7 @@ namespace llvm {

/// SimplifySRemInst - Given operands for an SRem, see if we can
/// fold the result. If not, this returns null.
Value *SimplifySRemInst(Value *LHS, Value *RHS, const DataLayout *TD = 0,
Value *SimplifySRemInst(Value *LHS, Value *RHS, const DataLayout *TD = 0,
const TargetLibraryInfo *TLI = 0,
const DominatorTree *DT = 0);

Expand All @@ -88,7 +88,7 @@ namespace llvm {
/// SimplifyShlInst - Given operands for a Shl, see if we can
/// fold the result. If not, this returns null.
Value *SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
const DataLayout *TD = 0,
const DataLayout *TD = 0,
const TargetLibraryInfo *TLI = 0,
const DominatorTree *DT = 0);

Expand Down Expand Up @@ -127,14 +127,14 @@ namespace llvm {
/// SimplifyICmpInst - Given operands for an ICmpInst, see if we can
/// fold the result. If not, this returns null.
Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
const DataLayout *TD = 0,
const DataLayout *TD = 0,
const TargetLibraryInfo *TLI = 0,
const DominatorTree *DT = 0);

/// SimplifyFCmpInst - Given operands for an FCmpInst, see if we can
/// fold the result. If not, this returns null.
Value *SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
const DataLayout *TD = 0,
const DataLayout *TD = 0,
const TargetLibraryInfo *TLI = 0,
const DominatorTree *DT = 0);

Expand Down Expand Up @@ -178,7 +178,7 @@ namespace llvm {
/// SimplifyBinOp - Given operands for a BinaryOperator, see if we can
/// fold the result. If not, this returns null.
Value *SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS,
const DataLayout *TD = 0,
const DataLayout *TD = 0,
const TargetLibraryInfo *TLI = 0,
const DominatorTree *DT = 0);

Expand Down
16 changes: 8 additions & 8 deletions include/llvm/Bitcode/LLVMBitCodes.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -31,16 +31,16 @@ namespace bitc {
PARAMATTR_BLOCK_ID,

UNUSED_ID1,

CONSTANTS_BLOCK_ID,
FUNCTION_BLOCK_ID,

UNUSED_ID2,

VALUE_SYMTAB_BLOCK_ID,
METADATA_BLOCK_ID,
METADATA_ATTACHMENT_ID,

TYPE_BLOCK_ID_NEW,

USELIST_BLOCK_ID
Expand Down Expand Up @@ -93,9 +93,9 @@ namespace bitc {

TYPE_CODE_FUNCTION_OLD = 9, // FUNCTION: [vararg, attrid, retty,
// paramty x N]

TYPE_CODE_HALF = 10, // HALF

TYPE_CODE_ARRAY = 11, // ARRAY: [numelts, eltty]
TYPE_CODE_VECTOR = 12, // VECTOR: [numelts, eltty]

Expand All @@ -109,7 +109,7 @@ namespace bitc {
TYPE_CODE_METADATA = 16, // METADATA

TYPE_CODE_X86_MMX = 17, // X86 MMX

TYPE_CODE_STRUCT_ANON = 18, // STRUCT_ANON: [ispacked, eltty x N]
TYPE_CODE_STRUCT_NAME = 19, // STRUCT_NAME: [strchr x N]
TYPE_CODE_STRUCT_NAMED = 20,// STRUCT_NAMED: [ispacked, eltty x N]
Expand Down Expand Up @@ -234,7 +234,7 @@ namespace bitc {
OBO_NO_SIGNED_WRAP = 1
};

/// PossiblyExactOperatorOptionalFlags - Flags for serializing
/// PossiblyExactOperatorOptionalFlags - Flags for serializing
/// PossiblyExactOperator's SubclassOptionalData contents.
enum PossiblyExactOperatorOptionalFlags {
PEO_EXACT = 0
Expand Down
62 changes: 31 additions & 31 deletions include/llvm/Instruction.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -33,7 +33,7 @@ class Instruction : public User, public ilist_node<Instruction> {

BasicBlock *Parent;
DebugLoc DbgLoc; // 'dbg' Metadata cache.

enum {
/// HasMetadataBit - This is a bit stored in the SubClassData field which
/// indicates whether this instruction has metadata attached to it or not.
Expand All @@ -42,12 +42,12 @@ class Instruction : public User, public ilist_node<Instruction> {
public:
// Out of line virtual method, so the vtable, etc has a home.
~Instruction();

/// use_back - Specialize the methods defined in Value, as we know that an
/// instruction can only be used by other instructions.
Instruction *use_back() { return cast<Instruction>(*use_begin());}
const Instruction *use_back() const { return cast<Instruction>(*use_begin());}

inline const BasicBlock *getParent() const { return Parent; }
inline BasicBlock *getParent() { return Parent; }

Expand Down Expand Up @@ -77,16 +77,16 @@ class Instruction : public User, public ilist_node<Instruction> {
//===--------------------------------------------------------------------===//
// Subclass classification.
//===--------------------------------------------------------------------===//

/// getOpcode() returns a member of one of the enums like Instruction::Add.
unsigned getOpcode() const { return getValueID() - InstructionVal; }

const char *getOpcodeName() const { return getOpcodeName(getOpcode()); }
bool isTerminator() const { return isTerminator(getOpcode()); }
bool isBinaryOp() const { return isBinaryOp(getOpcode()); }
bool isShift() { return isShift(getOpcode()); }
bool isCast() const { return isCast(getOpcode()); }

static const char* getOpcodeName(unsigned OpCode);

static inline bool isTerminator(unsigned OpCode) {
Expand Down Expand Up @@ -121,49 +121,49 @@ class Instruction : public User, public ilist_node<Instruction> {
//===--------------------------------------------------------------------===//
// Metadata manipulation.
//===--------------------------------------------------------------------===//

/// hasMetadata() - Return true if this instruction has any metadata attached
/// to it.
bool hasMetadata() const {
return !DbgLoc.isUnknown() || hasMetadataHashEntry();
}

/// hasMetadataOtherThanDebugLoc - Return true if this instruction has
/// metadata attached to it other than a debug location.
bool hasMetadataOtherThanDebugLoc() const {
return hasMetadataHashEntry();
}

/// getMetadata - Get the metadata of given kind attached to this Instruction.
/// If the metadata is not found then return null.
MDNode *getMetadata(unsigned KindID) const {
if (!hasMetadata()) return 0;
return getMetadataImpl(KindID);
}

/// getMetadata - Get the metadata of given kind attached to this Instruction.
/// If the metadata is not found then return null.
MDNode *getMetadata(StringRef Kind) const {
if (!hasMetadata()) return 0;
return getMetadataImpl(Kind);
}

/// getAllMetadata - Get all metadata attached to this Instruction. The first
/// element of each pair returned is the KindID, the second element is the
/// metadata value. This list is returned sorted by the KindID.
void getAllMetadata(SmallVectorImpl<std::pair<unsigned, MDNode*> > &MDs)const{
if (hasMetadata())
getAllMetadataImpl(MDs);
}

/// getAllMetadataOtherThanDebugLoc - This does the same thing as
/// getAllMetadata, except that it filters out the debug location.
void getAllMetadataOtherThanDebugLoc(SmallVectorImpl<std::pair<unsigned,
MDNode*> > &MDs) const {
if (hasMetadataOtherThanDebugLoc())
getAllMetadataOtherThanDebugLocImpl(MDs);
}

/// setMetadata - Set the metadata of the specified kind to the specified
/// node. This updates/replaces metadata if already present, or removes it if
/// Node is null.
Expand All @@ -172,17 +172,17 @@ class Instruction : public User, public ilist_node<Instruction> {

/// setDebugLoc - Set the debug location information for this instruction.
void setDebugLoc(const DebugLoc &Loc) { DbgLoc = Loc; }

/// getDebugLoc - Return the debug location for this node as a DebugLoc.
const DebugLoc &getDebugLoc() const { return DbgLoc; }

private:
/// hasMetadataHashEntry - Return true if we have an entry in the on-the-side
/// metadata hash.
bool hasMetadataHashEntry() const {
return (getSubclassDataFromValue() & HasMetadataBit) != 0;
}

// These are all implemented in Metadata.cpp.
MDNode *getMetadataImpl(unsigned KindID) const;
MDNode *getMetadataImpl(StringRef Kind) const;
Expand All @@ -194,8 +194,8 @@ class Instruction : public User, public ilist_node<Instruction> {
//===--------------------------------------------------------------------===//
// Predicates and helper methods.
//===--------------------------------------------------------------------===//


/// isAssociative - Return true if the instruction is associative:
///
/// Associative operators satisfy: x op (y op z) === (x op y) op z
Expand Down Expand Up @@ -271,12 +271,12 @@ class Instruction : public User, public ilist_node<Instruction> {
/// * The instruction has no name
///
Instruction *clone() const;

/// isIdenticalTo - Return true if the specified instruction is exactly
/// identical to the current one. This means that all operands match and any
/// extra information (e.g. load is volatile) agree.
bool isIdenticalTo(const Instruction *I) const;

/// isIdenticalToWhenDefined - This is like isIdenticalTo, except that it
/// ignores the SubclassOptionalData flags, which specify conditions
/// under which the instruction's result is undefined.
Expand All @@ -291,7 +291,7 @@ class Instruction : public User, public ilist_node<Instruction> {
/// as equivalent.
CompareUsingScalarTypes = 1<<1
};

/// This function determines if the specified instruction executes the same
/// operation as the current one. This means that the opcodes, type, operand
/// types and any other factors affecting the operation must be the same. This
Expand All @@ -301,14 +301,14 @@ class Instruction : public User, public ilist_node<Instruction> {
/// the current one.
/// @brief Determine if one instruction is the same operation as another.
bool isSameOperationAs(const Instruction *I, unsigned flags = 0) const;

/// isUsedOutsideOfBlock - Return true if there are any uses of this
/// instruction in blocks other than the specified block. Note that PHI nodes
/// are considered to evaluate their operands in the corresponding predecessor
/// block.
bool isUsedOutsideOfBlock(const BasicBlock *BB) const;


/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const Value *V) {
return V->getValueID() >= Value::InstructionVal;
Expand Down Expand Up @@ -360,34 +360,34 @@ class Instruction : public User, public ilist_node<Instruction> {
unsigned short getSubclassDataFromValue() const {
return Value::getSubclassDataFromValue();
}

void setHasMetadataHashEntry(bool V) {
setValueSubclassData((getSubclassDataFromValue() & ~HasMetadataBit) |
(V ? HasMetadataBit : 0));
}

friend class SymbolTableListTraits<Instruction, BasicBlock>;
void setParent(BasicBlock *P);
protected:
// Instruction subclasses can stick up to 15 bits of stuff into the
// SubclassData field of instruction with these members.

// Verify that only the low 15 bits are used.
void setInstructionSubclassData(unsigned short D) {
assert((D & HasMetadataBit) == 0 && "Out of range value put into field");
setValueSubclassData((getSubclassDataFromValue() & HasMetadataBit) | D);
}

unsigned getSubclassDataFromInstruction() const {
return getSubclassDataFromValue() & ~HasMetadataBit;
}

Instruction(Type *Ty, unsigned iType, Use *Ops, unsigned NumOps,
Instruction *InsertBefore = 0);
Instruction(Type *Ty, unsigned iType, Use *Ops, unsigned NumOps,
BasicBlock *InsertAtEnd);
virtual Instruction *clone_impl() const = 0;

};

// Instruction* is only 4-byte aligned.
Expand All @@ -401,7 +401,7 @@ class PointerLikeTypeTraits<Instruction*> {
}
enum { NumLowBitsAvailable = 2 };
};

} // End llvm namespace

#endif
8 changes: 4 additions & 4 deletions include/llvm/Operator.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -131,21 +131,21 @@ class PossiblyExactOperator : public Operator {
enum {
IsExact = (1 << 0)
};

private:
friend class BinaryOperator;
friend class ConstantExpr;
void setIsExact(bool B) {
SubclassOptionalData = (SubclassOptionalData & ~IsExact) | (B * IsExact);
}

public:
/// isExact - Test whether this division is known to be exact, with
/// zero remainder.
bool isExact() const {
return SubclassOptionalData & IsExact;
}

static bool isPossiblyExactOpcode(unsigned OpC) {
return OpC == Instruction::SDiv ||
OpC == Instruction::UDiv ||
Expand Down Expand Up @@ -182,7 +182,7 @@ class FPMathOperator : public Operator {
}
};


/// ConcreteOperator - A helper template for defining operators for individual
/// opcodes.
template<typename SuperClass, unsigned Opc>
Expand Down
Loading

0 comments on commit 407a616

Please sign in to comment.