[llvm-commits] CVS: llvm/include/llvm/Analysis/AliasAnalysis.h AliasSetTracker.h CallGraph.h CFGPrinter.h ConstantsScanner.h Dominators.h Expressions.h FindUnsafePointerTypes.h FindUsedTypes.h Interval.h IntervalIterator.h IntervalPartition.h LoadValueNumbering.h LoopInfo.h Passes.h PostDominators.h ProfileInfo.h ProfileInfoLoader.h ProfileInfoTypes.h ScalarEvolutionExpressions.h ScalarEvolution.h Trace.h ValueNumbering.h Verifier.h
Misha Brukman
brukman at cs.uiuc.edu
Thu Apr 21 13:16:43 PDT 2005
Changes in directory llvm/include/llvm/Analysis:
AliasAnalysis.h updated: 1.20 -> 1.21
AliasSetTracker.h updated: 1.24 -> 1.25
CallGraph.h updated: 1.42 -> 1.43
CFGPrinter.h updated: 1.1 -> 1.2
ConstantsScanner.h updated: 1.15 -> 1.16
Dominators.h updated: 1.48 -> 1.49
Expressions.h updated: 1.11 -> 1.12
FindUnsafePointerTypes.h updated: 1.17 -> 1.18
FindUsedTypes.h updated: 1.23 -> 1.24
Interval.h updated: 1.19 -> 1.20
IntervalIterator.h updated: 1.20 -> 1.21
IntervalPartition.h updated: 1.21 -> 1.22
LoadValueNumbering.h updated: 1.4 -> 1.5
LoopInfo.h updated: 1.44 -> 1.45
Passes.h updated: 1.5 -> 1.6
PostDominators.h updated: 1.8 -> 1.9
ProfileInfo.h updated: 1.4 -> 1.5
ProfileInfoLoader.h updated: 1.3 -> 1.4
ProfileInfoTypes.h updated: 1.1 -> 1.2
ScalarEvolutionExpressions.h updated: 1.5 -> 1.6
ScalarEvolution.h updated: 1.9 -> 1.10
Trace.h updated: 1.3 -> 1.4
ValueNumbering.h updated: 1.7 -> 1.8
Verifier.h updated: 1.13 -> 1.14
---
Log message:
Remove trailing whitespace
---
Diffs of the changes: (+143 -143)
AliasAnalysis.h | 36 +++++++++++++++---------------
AliasSetTracker.h | 18 +++++++--------
CFGPrinter.h | 4 +--
CallGraph.h | 6 ++---
ConstantsScanner.h | 8 +++---
Dominators.h | 16 ++++++-------
Expressions.h | 6 ++---
FindUnsafePointerTypes.h | 8 +++---
FindUsedTypes.h | 4 +--
Interval.h | 18 +++++++--------
IntervalIterator.h | 50 +++++++++++++++++++++----------------------
IntervalPartition.h | 4 +--
LoadValueNumbering.h | 4 +--
LoopInfo.h | 16 ++++++-------
Passes.h | 20 ++++++++---------
PostDominators.h | 4 +--
ProfileInfo.h | 6 ++---
ProfileInfoLoader.h | 4 +--
ProfileInfoTypes.h | 4 +--
ScalarEvolution.h | 16 ++++++-------
ScalarEvolutionExpressions.h | 12 +++++-----
Trace.h | 2 -
ValueNumbering.h | 4 +--
Verifier.h | 16 ++++++-------
24 files changed, 143 insertions(+), 143 deletions(-)
Index: llvm/include/llvm/Analysis/AliasAnalysis.h
diff -u llvm/include/llvm/Analysis/AliasAnalysis.h:1.20 llvm/include/llvm/Analysis/AliasAnalysis.h:1.21
--- llvm/include/llvm/Analysis/AliasAnalysis.h:1.20 Wed Mar 23 17:27:34 2005
+++ llvm/include/llvm/Analysis/AliasAnalysis.h Thu Apr 21 15:16:31 2005
@@ -1,10 +1,10 @@
//===- llvm/Analysis/AliasAnalysis.h - Alias Analysis 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.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file defines the generic AliasAnalysis interface, which is used as the
@@ -50,7 +50,7 @@
/// called multiple times.
///
void InitializeAliasAnalysis(Pass *P);
-
+
// getAnalysisUsage - All alias analysis implementations should invoke this
// directly (using AliasAnalysis::getAnalysisUsage(AU)) to make sure that
// TargetData is required by the pass.
@@ -108,8 +108,8 @@
/// bits which may be or'd together.
///
enum ModRefResult { NoModRef = 0, Ref = 1, Mod = 2, ModRef = 3 };
-
-
+
+
/// ModRefBehavior - Summary of how a function affects memory in the program.
/// Loads from constant globals are not considered memory accesses for this
/// interface. Also, functions may freely modify stack space local to their
@@ -120,14 +120,14 @@
//
// This property corresponds to the GCC 'const' attribute.
DoesNotAccessMemory,
-
+
// AccessesArguments - This function accesses function arguments in
// non-volatile and well known ways, but does not access any other memory.
//
// Clients may call getArgumentAccesses to get specific information about
// how pointer arguments are used.
AccessesArguments,
-
+
// AccessesArgumentsAndGlobals - This function has accesses function
// arguments and global variables in non-volatile and well-known ways, but
// does not access any other memory.
@@ -135,18 +135,18 @@
// Clients may call getArgumentAccesses to get specific information about
// how pointer arguments and globals are used.
AccessesArgumentsAndGlobals,
-
+
// OnlyReadsMemory - This function does not perform any non-local stores or
// volatile loads, but may read from any memory location.
//
// This property corresponds to the GCC 'pure' attribute.
OnlyReadsMemory,
-
+
// UnknownModRefBehavior - This indicates that the function could not be
// classified into one of the behaviors above.
UnknownModRefBehavior
};
-
+
/// PointerAccessInfo - This struct is used to return results for pointers,
/// globals, and the return value of a function.
struct PointerAccessInfo {
@@ -154,11 +154,11 @@
/// the function, a GlobalVariable, or null, corresponding to the return
/// value for the function.
Value *V;
-
+
/// ModRefInfo - Whether the pointer is loaded or stored to/from.
///
ModRefResult ModRefInfo;
-
+
/// AccessType - Specific fine-grained access information for the argument.
/// If none of these classifications is general enough, the
/// getModRefBehavior method should not return AccessesArguments*. If a
@@ -168,25 +168,25 @@
/// ScalarAccess - The pointer is dereferenced.
///
ScalarAccess,
-
+
/// ArrayAccess - The pointer is indexed through as an array of elements.
///
ArrayAccess,
-
+
/// ElementAccess ?? P->F only?
-
+
/// CallsThrough - Indirect calls are made through the specified function
/// pointer.
CallsThrough,
};
- };
-
+ };
+
/// getModRefBehavior - Return the behavior of the specified function if
/// called from the specified call site. The call site may be null in which
/// case the most generic behavior of this function should be returned.
virtual ModRefBehavior getModRefBehavior(Function *F, CallSite CS,
std::vector<PointerAccessInfo> *Info = 0);
-
+
/// doesNotAccessMemory - If the specified function is known to never read or
/// write memory, return true. If the function only reads from known-constant
/// memory, it is also legal to return true. Functions that unwind the stack
Index: llvm/include/llvm/Analysis/AliasSetTracker.h
diff -u llvm/include/llvm/Analysis/AliasSetTracker.h:1.24 llvm/include/llvm/Analysis/AliasSetTracker.h:1.25
--- llvm/include/llvm/Analysis/AliasSetTracker.h:1.24 Sat Nov 27 12:37:04 2004
+++ llvm/include/llvm/Analysis/AliasSetTracker.h Thu Apr 21 15:16:31 2005
@@ -1,17 +1,17 @@
//===- llvm/Analysis/AliasSetTracker.h - Build Alias Sets -------*- 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 two classes: AliasSetTracker and AliasSet. These interface
// are used to classify a collection of pointer references into a maximal number
// of disjoint sets. Each AliasSet object constructed by the AliasSetTracker
// object refers to memory disjoint from the other sets.
-//
+//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ANALYSIS_ALIASSETTRACKER_H
@@ -58,7 +58,7 @@
unsigned getSize() const { return Size; }
- AliasSet *getAliasSet(AliasSetTracker &AST) {
+ AliasSet *getAliasSet(AliasSetTracker &AST) {
assert(AS && "No AliasSet yet!");
if (AS->Forward) {
AliasSet *OldAS = AS;
@@ -163,7 +163,7 @@
HashNodePair *CurNode;
public:
iterator(HashNodePair *CN = 0) : CurNode(CN) {}
-
+
bool operator==(const iterator& x) const {
return CurNode == x.CurNode;
}
@@ -173,7 +173,7 @@
CurNode = I.CurNode;
return *this;
}
-
+
value_type &operator*() const {
assert(CurNode && "Dereferencing AliasSet.end()!");
return *CurNode;
@@ -182,14 +182,14 @@
Value *getPointer() const { return CurNode->first; }
unsigned getSize() const { return CurNode->second.getSize(); }
-
+
iterator& operator++() { // Preincrement
assert(CurNode && "Advancing past AliasSet.end()!");
CurNode = CurNode->second.getNext();
return *this;
}
iterator operator++(int) { // Postincrement
- iterator tmp = *this; ++*this; return tmp;
+ iterator tmp = *this; ++*this; return tmp;
}
};
@@ -306,7 +306,7 @@
AliasSet *getAliasSetForPointerIfExists(Value *P, unsigned Size) {
return findAliasSetForPointer(P, Size);
}
-
+
/// containsPointer - Return true if the specified location is represented by
/// this alias set, false otherwise. This does not modify the AST object or
/// alias sets.
Index: llvm/include/llvm/Analysis/CallGraph.h
diff -u llvm/include/llvm/Analysis/CallGraph.h:1.42 llvm/include/llvm/Analysis/CallGraph.h:1.43
--- llvm/include/llvm/Analysis/CallGraph.h:1.42 Sun Sep 19 23:42:22 2004
+++ llvm/include/llvm/Analysis/CallGraph.h Thu Apr 21 15:16:31 2005
@@ -1,13 +1,13 @@
//===- CallGraph.h - Build a Module's 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 interface is used to build and manipulate a call graph, which is a very
+// This interface is used to build and manipulate a call graph, which is a very
// useful tool for interprocedural optimization.
//
// Every function in a module is represented as a node in the call graph. The
Index: llvm/include/llvm/Analysis/CFGPrinter.h
diff -u llvm/include/llvm/Analysis/CFGPrinter.h:1.1 llvm/include/llvm/Analysis/CFGPrinter.h:1.2
--- llvm/include/llvm/Analysis/CFGPrinter.h:1.1 Mon Apr 26 11:27:53 2004
+++ llvm/include/llvm/Analysis/CFGPrinter.h Thu Apr 21 15:16:31 2005
@@ -1,10 +1,10 @@
//===-- CFGPrinter.h - CFG printer external 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.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file defines external functions that can be called to explicitly
Index: llvm/include/llvm/Analysis/ConstantsScanner.h
diff -u llvm/include/llvm/Analysis/ConstantsScanner.h:1.15 llvm/include/llvm/Analysis/ConstantsScanner.h:1.16
--- llvm/include/llvm/Analysis/ConstantsScanner.h:1.15 Wed Sep 1 17:55:34 2004
+++ llvm/include/llvm/Analysis/ConstantsScanner.h Thu Apr 21 15:16:31 2005
@@ -1,10 +1,10 @@
//==- llvm/Analysis/ConstantsScanner.h - Iterate over constants -*- 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 implements an iterator to walk through the constants referenced by
@@ -48,7 +48,7 @@
: InstI(inst_end(F)), OpIdx(0) {
}
- inline bool operator==(const _Self& x) const { return OpIdx == x.OpIdx &&
+ inline bool operator==(const _Self& x) const { return OpIdx == x.OpIdx &&
InstI == x.InstI; }
inline bool operator!=(const _Self& x) const { return !operator==(x); }
@@ -75,7 +75,7 @@
}
inline _Self operator++(int) { // Postincrement
- _Self tmp = *this; ++*this; return tmp;
+ _Self tmp = *this; ++*this; return tmp;
}
inline bool atEnd() const { return InstI.atEnd(); }
Index: llvm/include/llvm/Analysis/Dominators.h
diff -u llvm/include/llvm/Analysis/Dominators.h:1.48 llvm/include/llvm/Analysis/Dominators.h:1.49
--- llvm/include/llvm/Analysis/Dominators.h:1.48 Mon Dec 6 22:03:45 2004
+++ llvm/include/llvm/Analysis/Dominators.h Thu Apr 21 15:16:31 2005
@@ -1,10 +1,10 @@
//===- llvm/Analysis/Dominators.h - Dominator Info Calculation --*- 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 following classes:
@@ -13,13 +13,13 @@
// 2. DominatorSet: Calculates the [reverse] dominator set for a function
// 3. DominatorTree: Represent the ImmediateDominator as an explicit tree
// structure.
-// 4. DominanceFrontier: Calculate and hold the dominance frontier for a
+// 4. DominanceFrontier: Calculate and hold the dominance frontier for a
// function.
//
// These data structures are listed in increasing order of complexity. It
-// takes longer to calculate the dominator frontier, for example, than the
+// takes longer to calculate the dominator frontier, for example, than the
// ImmediateDominator mapping.
-//
+//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ANALYSIS_DOMINATORS_H
@@ -140,9 +140,9 @@
unsigned Semi;
unsigned Size;
BasicBlock *Label, *Parent, *Child, *Ancestor;
-
+
std::vector<BasicBlock*> Bucket;
-
+
InfoRec() : Semi(0), Size(0), Label(0), Parent(0), Child(0), Ancestor(0){}
};
@@ -306,7 +306,7 @@
inline Node *getIDom() const { return IDom; }
inline const std::vector<Node*> &getChildren() const { return Children; }
- /// dominates - Returns true iff this dominates N. Note that this is not a
+ /// dominates - Returns true iff this dominates N. Note that this is not a
/// constant time operation!
///
inline bool dominates(const Node *N) const {
Index: llvm/include/llvm/Analysis/Expressions.h
diff -u llvm/include/llvm/Analysis/Expressions.h:1.11 llvm/include/llvm/Analysis/Expressions.h:1.12
--- llvm/include/llvm/Analysis/Expressions.h:1.11 Thu Mar 11 17:08:20 2004
+++ llvm/include/llvm/Analysis/Expressions.h Thu Apr 21 15:16:31 2005
@@ -1,17 +1,17 @@
//===- llvm/Analysis/Expressions.h - Expression Analysis Utils --*- 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 package of expression analysis utilties:
//
// ClassifyExpr: Analyze an expression to determine the complexity of the
// expression, and which other variables it depends on.
-//
+//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ANALYSIS_EXPRESSIONS_H
Index: llvm/include/llvm/Analysis/FindUnsafePointerTypes.h
diff -u llvm/include/llvm/Analysis/FindUnsafePointerTypes.h:1.17 llvm/include/llvm/Analysis/FindUnsafePointerTypes.h:1.18
--- llvm/include/llvm/Analysis/FindUnsafePointerTypes.h:1.17 Sun Sep 19 23:42:22 2004
+++ llvm/include/llvm/Analysis/FindUnsafePointerTypes.h Thu Apr 21 15:16:31 2005
@@ -1,13 +1,13 @@
//===- llvm/Analysis/FindUnsafePointerTypes.h - Unsafe pointers -*- 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 pass that can be used to determine, interprocedurally,
+// This file defines a pass that can be used to determine, interprocedurally,
// which pointer types are accessed unsafely in a program. If there is an
// "unsafe" access to a specific pointer type, transformations that depend on
// type safety cannot be permitted.
@@ -18,7 +18,7 @@
// Additionally, this analysis exports a hidden command line argument that (when
// enabled) prints out the reasons a type was determined to be unsafe. Just add
// -printunsafeptrinst to the command line of the tool you want to get it.
-//
+//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ANALYSIS_UNSAFEPOINTERTYPES_H
Index: llvm/include/llvm/Analysis/FindUsedTypes.h
diff -u llvm/include/llvm/Analysis/FindUsedTypes.h:1.23 llvm/include/llvm/Analysis/FindUsedTypes.h:1.24
--- llvm/include/llvm/Analysis/FindUsedTypes.h:1.23 Sun Sep 19 23:42:22 2004
+++ llvm/include/llvm/Analysis/FindUsedTypes.h Thu Apr 21 15:16:31 2005
@@ -1,10 +1,10 @@
//===- llvm/Analysis/FindUsedTypes.h - Find all Types in use ----*- 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 pass is used to seek out all of the types in use by the program.
Index: llvm/include/llvm/Analysis/Interval.h
diff -u llvm/include/llvm/Analysis/Interval.h:1.19 llvm/include/llvm/Analysis/Interval.h:1.20
--- llvm/include/llvm/Analysis/Interval.h:1.19 Thu Apr 21 11:04:44 2005
+++ llvm/include/llvm/Analysis/Interval.h Thu Apr 21 15:16:31 2005
@@ -1,15 +1,15 @@
//===- llvm/Analysis/Interval.h - Interval Class Declaration ----*- 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 Interval class, which
// represents a set of CFG nodes and is a portion of an interval partition.
-//
+//
// Intervals have some interesting and useful properties, including the
// following:
// 1. The header node of an interval dominates all of the elements of the
@@ -86,9 +86,9 @@
//return find(Successors.begin(), Successors.end(), BB) != Successors.end();
}
- /// Equality operator. It is only valid to compare two intervals from the same
- /// partition, because of this, all we have to check is the header node for
- /// equality.
+ /// Equality operator. It is only valid to compare two intervals from the
+ /// same partition, because of this, all we have to check is the header node
+ /// for equality.
///
inline bool operator==(const Interval &I) const {
return HeaderNode == I.HeaderNode;
@@ -131,7 +131,7 @@
static inline ChildIteratorType child_begin(NodeType *N) {
return succ_begin(N);
}
- static inline ChildIteratorType child_end(NodeType *N) {
+ static inline ChildIteratorType child_end(NodeType *N) {
return succ_end(N);
}
};
@@ -140,10 +140,10 @@
typedef Interval NodeType;
typedef Interval::pred_iterator ChildIteratorType;
static NodeType *getEntryNode(Inverse<Interval *> G) { return G.Graph; }
- static inline ChildIteratorType child_begin(NodeType *N) {
+ static inline ChildIteratorType child_begin(NodeType *N) {
return pred_begin(N);
}
- static inline ChildIteratorType child_end(NodeType *N) {
+ static inline ChildIteratorType child_end(NodeType *N) {
return pred_end(N);
}
};
Index: llvm/include/llvm/Analysis/IntervalIterator.h
diff -u llvm/include/llvm/Analysis/IntervalIterator.h:1.20 llvm/include/llvm/Analysis/IntervalIterator.h:1.21
--- llvm/include/llvm/Analysis/IntervalIterator.h:1.20 Thu Oct 14 09:51:09 2004
+++ llvm/include/llvm/Analysis/IntervalIterator.h Thu Apr 21 15:16:32 2005
@@ -1,16 +1,16 @@
//===- IntervalIterator.h - Interval Iterator Declaration -------*- 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 an iterator that enumerates the intervals in a control flow
// graph of some sort. This iterator is parametric, allowing iterator over the
// following types of graphs:
-//
+//
// 1. A Function* object, composed of BasicBlock nodes.
// 2. An IntervalPartition& object, composed of Interval nodes.
//
@@ -18,9 +18,9 @@
// in depth first order. These intervals are completely filled in except for
// the predecessor fields (the successor information is filled in however).
//
-// By default, the intervals created by this iterator are deleted after they
+// By default, the intervals created by this iterator are deleted after they
// are no longer any use to the iterator. This behavior can be changed by
-// passing a false value into the intervals_begin() function. This causes the
+// passing a false value into the intervals_begin() function. This causes the
// IOwnMem member to be set, and the intervals to not be deleted.
//
// It is only safe to use this if all of the intervals are deleted by the caller
@@ -42,27 +42,27 @@
namespace llvm {
-// getNodeHeader - Given a source graph node and the source graph, return the
+// getNodeHeader - Given a source graph node and the source graph, return the
// BasicBlock that is the header node. This is the opposite of
// getSourceGraphNode.
//
inline BasicBlock *getNodeHeader(BasicBlock *BB) { return BB; }
inline BasicBlock *getNodeHeader(Interval *I) { return I->getHeaderNode(); }
-// getSourceGraphNode - Given a BasicBlock and the source graph, return the
+// getSourceGraphNode - Given a BasicBlock and the source graph, return the
// source graph node that corresponds to the BasicBlock. This is the opposite
// of getNodeHeader.
//
inline BasicBlock *getSourceGraphNode(Function *, BasicBlock *BB) {
- return BB;
+ return BB;
}
-inline Interval *getSourceGraphNode(IntervalPartition *IP, BasicBlock *BB) {
+inline Interval *getSourceGraphNode(IntervalPartition *IP, BasicBlock *BB) {
return IP->getBlockInterval(BB);
}
// addNodeToInterval - This method exists to assist the generic ProcessNode
-// with the task of adding a node to the new interval, depending on the
-// type of the source node. In the case of a CFG source graph (BasicBlock
+// with the task of adding a node to the new interval, depending on the
+// type of the source node. In the case of a CFG source graph (BasicBlock
// case), the BasicBlock itself is added to the interval.
//
inline void addNodeToInterval(Interval *Int, BasicBlock *BB) {
@@ -70,8 +70,8 @@
}
// addNodeToInterval - This method exists to assist the generic ProcessNode
-// with the task of adding a node to the new interval, depending on the
-// type of the source node. In the case of a CFG source graph (BasicBlock
+// with the task of adding a node to the new interval, depending on the
+// type of the source node. In the case of a CFG source graph (BasicBlock
// case), the BasicBlock itself is added to the interval. In the case of
// an IntervalPartition source graph (Interval case), all of the member
// BasicBlocks are added to the interval.
@@ -96,7 +96,7 @@
public:
typedef IntervalIterator<NodeTy, OrigContainer_t> _Self;
typedef std::forward_iterator_tag iterator_category;
-
+
IntervalIterator() {} // End iterator, empty stack
IntervalIterator(Function *M, bool OwnMemory) : IOwnMem(OwnMemory) {
OrigContainer = M;
@@ -148,14 +148,14 @@
IntStack.pop();
} while (!IntStack.empty());
- return *this;
+ return *this;
}
inline _Self operator++(int) { // Postincrement
- _Self tmp = *this; ++*this; return tmp;
+ _Self tmp = *this; ++*this; return tmp;
}
private:
- // ProcessInterval - This method is used during the construction of the
+ // ProcessInterval - This method is used during the construction of the
// interval graph. It walks through the source graph, recursively creating
// an interval per invokation until the entire graph is covered. This uses
// the ProcessNode method to add all of the nodes to the interval.
@@ -178,7 +178,7 @@
IntStack.push(std::make_pair(Int, succ_begin(Int)));
return true;
}
-
+
// ProcessNode - This method is called by ProcessInterval to add nodes to the
// interval being constructed, and it is also called recursively as it walks
// the source graph. A node is added to the current interval only if all of
@@ -191,7 +191,7 @@
void ProcessNode(Interval *Int, NodeTy *Node) {
assert(Int && "Null interval == bad!");
assert(Node && "Null Node == bad!");
-
+
BasicBlock *NodeHeader = getNodeHeader(Node);
if (Visited.count(NodeHeader)) { // Node already been visited?
@@ -202,7 +202,7 @@
Int->Successors.push_back(NodeHeader);
}
} else { // Otherwise, not in interval yet
- for (typename IGT::ChildIteratorType I = IGT::child_begin(Node),
+ for (typename IGT::ChildIteratorType I = IGT::child_begin(Node),
E = IGT::child_end(Node); I != E; ++I) {
if (!Int->contains(*I)) { // If pred not in interval, we can't be
if (!Int->isSuccessor(NodeHeader)) // Add only if not already in set
@@ -215,14 +215,14 @@
// already. In this case, we must add BB to the interval!
addNodeToInterval(Int, Node);
Visited.insert(NodeHeader); // The node has now been visited!
-
+
if (Int->isSuccessor(NodeHeader)) {
// If we were in the successor list from before... remove from succ list
Int->Successors.erase(std::remove(Int->Successors.begin(),
- Int->Successors.end(), NodeHeader),
+ Int->Successors.end(), NodeHeader),
Int->Successors.end());
}
-
+
// Now that we have discovered that Node is in the interval, perhaps some
// of its successors are as well?
for (typename GT::ChildIteratorType It = GT::child_begin(Node),
@@ -236,7 +236,7 @@
typedef IntervalIterator<Interval, IntervalPartition> interval_part_interval_iterator;
-inline function_interval_iterator intervals_begin(Function *F,
+inline function_interval_iterator intervals_begin(Function *F,
bool DeleteInts = true) {
return function_interval_iterator(F, DeleteInts);
}
@@ -244,7 +244,7 @@
return function_interval_iterator();
}
-inline interval_part_interval_iterator
+inline interval_part_interval_iterator
intervals_begin(IntervalPartition &IP, bool DeleteIntervals = true) {
return interval_part_interval_iterator(IP, DeleteIntervals);
}
Index: llvm/include/llvm/Analysis/IntervalPartition.h
diff -u llvm/include/llvm/Analysis/IntervalPartition.h:1.21 llvm/include/llvm/Analysis/IntervalPartition.h:1.22
--- llvm/include/llvm/Analysis/IntervalPartition.h:1.21 Mon Dec 6 22:03:45 2004
+++ llvm/include/llvm/Analysis/IntervalPartition.h Thu Apr 21 15:16:32 2005
@@ -1,10 +1,10 @@
//===- IntervalPartition.h - Interval partition Calculation -----*- 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 IntervalPartition class, which
Index: llvm/include/llvm/Analysis/LoadValueNumbering.h
diff -u llvm/include/llvm/Analysis/LoadValueNumbering.h:1.4 llvm/include/llvm/Analysis/LoadValueNumbering.h:1.5
--- llvm/include/llvm/Analysis/LoadValueNumbering.h:1.4 Tue Jul 27 12:43:20 2004
+++ llvm/include/llvm/Analysis/LoadValueNumbering.h Thu Apr 21 15:16:32 2005
@@ -1,10 +1,10 @@
//===- llvm/Analysis/LoadValueNumbering.h - Value # Load Insts --*- 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 value numbering pass that value #'s load instructions.
Index: llvm/include/llvm/Analysis/LoopInfo.h
diff -u llvm/include/llvm/Analysis/LoopInfo.h:1.44 llvm/include/llvm/Analysis/LoopInfo.h:1.45
--- llvm/include/llvm/Analysis/LoopInfo.h:1.44 Sun Mar 6 14:55:34 2005
+++ llvm/include/llvm/Analysis/LoopInfo.h Thu Apr 21 15:16:32 2005
@@ -1,10 +1,10 @@
//===- llvm/Analysis/LoopInfo.h - Natural Loop Calculator -------*- 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 LoopInfo class that is used to identify natural loops
@@ -41,8 +41,8 @@
class Instruction;
//===----------------------------------------------------------------------===//
-/// Loop class - Instances of this class are used to represent loops that are
-/// detected in the flow graph
+/// Loop class - Instances of this class are used to represent loops that are
+/// detected in the flow graph
///
class Loop {
Loop *ParentLoop;
@@ -307,10 +307,10 @@
typedef std::vector<Loop*>::const_iterator ChildIteratorType;
static NodeType *getEntryNode(const Loop *L) { return L; }
- static inline ChildIteratorType child_begin(NodeType *N) {
+ static inline ChildIteratorType child_begin(NodeType *N) {
return N->begin();
}
- static inline ChildIteratorType child_end(NodeType *N) {
+ static inline ChildIteratorType child_end(NodeType *N) {
return N->end();
}
};
@@ -320,10 +320,10 @@
typedef std::vector<Loop*>::const_iterator ChildIteratorType;
static NodeType *getEntryNode(Loop *L) { return L; }
- static inline ChildIteratorType child_begin(NodeType *N) {
+ static inline ChildIteratorType child_begin(NodeType *N) {
return N->begin();
}
- static inline ChildIteratorType child_end(NodeType *N) {
+ static inline ChildIteratorType child_end(NodeType *N) {
return N->end();
}
};
Index: llvm/include/llvm/Analysis/Passes.h
diff -u llvm/include/llvm/Analysis/Passes.h:1.5 llvm/include/llvm/Analysis/Passes.h:1.6
--- llvm/include/llvm/Analysis/Passes.h:1.5 Fri Jan 28 01:29:15 2005
+++ llvm/include/llvm/Analysis/Passes.h Thu Apr 21 15:16:32 2005
@@ -1,10 +1,10 @@
//===-- llvm/Analysis/Passes.h - Constructors for analyses ------*- 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 header file defines prototypes for accessor functions that expose passes
@@ -47,55 +47,55 @@
// createNoAAPass - This pass implements a "I don't know" alias analysis.
//
ImmutablePass *createNoAAPass();
-
+
//===--------------------------------------------------------------------===//
//
// createBasicAliasAnalysisPass - This pass implements the default alias
// analysis.
//
ImmutablePass *createBasicAliasAnalysisPass();
-
+
//===--------------------------------------------------------------------===//
//
// createAndersensPass - This pass implements Andersen's interprocedural alias
// analysis.
//
ModulePass *createAndersensPass();
-
+
//===--------------------------------------------------------------------===//
//
// createBasicVNPass - This pass walks SSA def-use chains to trivially
// identify lexically identical expressions.
//
ImmutablePass *createBasicVNPass();
-
+
//===--------------------------------------------------------------------===//
//
// createProfileLoaderPass - This pass loads information from a profile dump
// file.
//
ModulePass *createProfileLoaderPass();
-
+
//===--------------------------------------------------------------------===//
//
// createNoProfileInfoPass - This pass implements the default "no profile".
//
ImmutablePass *createNoProfileInfoPass();
-
+
//===--------------------------------------------------------------------===//
//
// createDSAAPass - This pass implements simple context sensitive alias
// analysis.
//
ModulePass *createDSAAPass();
-
+
//===--------------------------------------------------------------------===//
//
// createDSOptPass - This pass uses DSA to do a series of simple
// optimizations.
//
ModulePass *createDSOptPass();
-
+
//===--------------------------------------------------------------------===//
//
// createSteensgaardPass - This pass uses the data structure graphs to do a
Index: llvm/include/llvm/Analysis/PostDominators.h
diff -u llvm/include/llvm/Analysis/PostDominators.h:1.8 llvm/include/llvm/Analysis/PostDominators.h:1.9
--- llvm/include/llvm/Analysis/PostDominators.h:1.8 Sun Feb 29 17:55:11 2004
+++ llvm/include/llvm/Analysis/PostDominators.h Thu Apr 21 15:16:32 2005
@@ -1,10 +1,10 @@
//=- llvm/Analysis/PostDominators.h - Post Dominator Calculation-*- 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 interfaces to post dominance information.
Index: llvm/include/llvm/Analysis/ProfileInfo.h
diff -u llvm/include/llvm/Analysis/ProfileInfo.h:1.4 llvm/include/llvm/Analysis/ProfileInfo.h:1.5
--- llvm/include/llvm/Analysis/ProfileInfo.h:1.4 Mon Mar 8 16:03:45 2004
+++ llvm/include/llvm/Analysis/ProfileInfo.h Thu Apr 21 15:16:32 2005
@@ -1,10 +1,10 @@
//===- llvm/Analysis/ProfileInfo.h - Profile Info 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.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file defines the generic ProfileInfo interface, which is used as the
@@ -39,7 +39,7 @@
std::map<std::pair<BasicBlock*, BasicBlock*>, unsigned> EdgeCounts;
public:
virtual ~ProfileInfo(); // We want to be subclassed
-
+
//===------------------------------------------------------------------===//
/// Profile Information Queries
///
Index: llvm/include/llvm/Analysis/ProfileInfoLoader.h
diff -u llvm/include/llvm/Analysis/ProfileInfoLoader.h:1.3 llvm/include/llvm/Analysis/ProfileInfoLoader.h:1.4
--- llvm/include/llvm/Analysis/ProfileInfoLoader.h:1.3 Tue May 4 12:11:13 2004
+++ llvm/include/llvm/Analysis/ProfileInfoLoader.h Thu Apr 21 15:16:32 2005
@@ -1,10 +1,10 @@
//===- ProfileInfoLoader.h - Load & convert profile information -*- 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 ProfileInfoLoader class is used to load and represent profiling
Index: llvm/include/llvm/Analysis/ProfileInfoTypes.h
diff -u llvm/include/llvm/Analysis/ProfileInfoTypes.h:1.1 llvm/include/llvm/Analysis/ProfileInfoTypes.h:1.2
--- llvm/include/llvm/Analysis/ProfileInfoTypes.h:1.1 Tue May 4 11:57:57 2004
+++ llvm/include/llvm/Analysis/ProfileInfoTypes.h Thu Apr 21 15:16:32 2005
@@ -4,9 +4,9 @@
|*
|* 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 constants shared by the various different profiling
|* runtime libraries and the LLVM C++ profile info loader. It must be a
|* C header because, at present, the profiling runtimes are written in C.
Index: llvm/include/llvm/Analysis/ScalarEvolutionExpressions.h
diff -u llvm/include/llvm/Analysis/ScalarEvolutionExpressions.h:1.5 llvm/include/llvm/Analysis/ScalarEvolutionExpressions.h:1.6
--- llvm/include/llvm/Analysis/ScalarEvolutionExpressions.h:1.5 Sat Feb 26 12:40:02 2005
+++ llvm/include/llvm/Analysis/ScalarEvolutionExpressions.h Thu Apr 21 15:16:32 2005
@@ -1,14 +1,14 @@
//===- llvm/Analysis/ScalarEvolutionExpressions.h - SCEV Exprs --*- 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 classes used to represent and build scalar expressions.
-//
+//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ANALYSIS_SCALAREVOLUTION_EXPRESSIONS_H
@@ -33,7 +33,7 @@
class SCEVConstant : public SCEV {
ConstantInt *V;
SCEVConstant(ConstantInt *v) : SCEV(scConstant), V(v) {}
-
+
virtual ~SCEVConstant();
public:
/// get method - This just gets and returns a new SCEVConstant object.
@@ -86,7 +86,7 @@
const SCEVHandle &getOperand() const { return Op; }
virtual const Type *getType() const { return Ty; }
-
+
virtual bool isLoopInvariant(const Loop *L) const {
return Op->isLoopInvariant(L);
}
@@ -132,7 +132,7 @@
const SCEVHandle &getOperand() const { return Op; }
virtual const Type *getType() const { return Ty; }
-
+
virtual bool isLoopInvariant(const Loop *L) const {
return Op->isLoopInvariant(L);
}
Index: llvm/include/llvm/Analysis/ScalarEvolution.h
diff -u llvm/include/llvm/Analysis/ScalarEvolution.h:1.9 llvm/include/llvm/Analysis/ScalarEvolution.h:1.10
--- llvm/include/llvm/Analysis/ScalarEvolution.h:1.9 Tue Mar 8 23:34:23 2005
+++ llvm/include/llvm/Analysis/ScalarEvolution.h Thu Apr 21 15:16:32 2005
@@ -1,10 +1,10 @@
//===- llvm/Analysis/ScalarEvolution.h - Scalar Evolution -------*- 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 ScalarEvolution class is an LLVM pass which can be used to analyze and
@@ -15,7 +15,7 @@
//
// This analysis is primarily useful for induction variable substitution and
// strength reduction.
-//
+//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ANALYSIS_SCALAREVOLUTION_H
@@ -89,7 +89,7 @@
/// the same value, but which uses the concrete value Conc instead of the
/// symbolic value. If this SCEV does not use the symbolic value, it
/// returns itself.
- virtual SCEVHandle
+ virtual SCEVHandle
replaceSymbolicValuesWithConcrete(const SCEVHandle &Sym,
const SCEVHandle &Conc) const = 0;
@@ -102,7 +102,7 @@
///
void dump() const;
};
-
+
inline std::ostream &operator<<(std::ostream &OS, const SCEV &S) {
S.print(OS);
return OS;
@@ -121,7 +121,7 @@
virtual const Type *getType() const;
virtual bool hasComputableLoopEvolution(const Loop *L) const;
virtual void print(std::ostream &OS) const;
- virtual SCEVHandle
+ virtual SCEVHandle
replaceSymbolicValuesWithConcrete(const SCEVHandle &Sym,
const SCEVHandle &Conc) const;
@@ -141,7 +141,7 @@
S->addRef();
}
SCEVHandle(const SCEVHandle &RHS) : S(RHS.S) {
- S->addRef();
+ S->addRef();
}
~SCEVHandle() { S->dropRef(); }
@@ -190,7 +190,7 @@
void *Impl; // ScalarEvolution uses the pimpl pattern
public:
ScalarEvolution() : Impl(0) {}
-
+
/// getSCEV - Return a SCEV expression handle for the full generality of the
/// specified expression.
SCEVHandle getSCEV(Value *V) const;
Index: llvm/include/llvm/Analysis/Trace.h
diff -u llvm/include/llvm/Analysis/Trace.h:1.3 llvm/include/llvm/Analysis/Trace.h:1.4
--- llvm/include/llvm/Analysis/Trace.h:1.3 Mon May 17 16:17:21 2004
+++ llvm/include/llvm/Analysis/Trace.h Thu Apr 21 15:16:32 2005
@@ -22,7 +22,7 @@
#include <vector>
#include <cassert>
-namespace llvm {
+namespace llvm {
class BasicBlock;
class Function;
class Module;
Index: llvm/include/llvm/Analysis/ValueNumbering.h
diff -u llvm/include/llvm/Analysis/ValueNumbering.h:1.7 llvm/include/llvm/Analysis/ValueNumbering.h:1.8
--- llvm/include/llvm/Analysis/ValueNumbering.h:1.7 Sun May 23 16:11:17 2004
+++ llvm/include/llvm/Analysis/ValueNumbering.h Thu Apr 21 15:16:32 2005
@@ -1,10 +1,10 @@
//===- llvm/Analysis/ValueNumbering.h - Value #'ing 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.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file defines the abstract ValueNumbering interface, which is used as the
Index: llvm/include/llvm/Analysis/Verifier.h
diff -u llvm/include/llvm/Analysis/Verifier.h:1.13 llvm/include/llvm/Analysis/Verifier.h:1.14
--- llvm/include/llvm/Analysis/Verifier.h:1.13 Fri Apr 2 09:44:33 2004
+++ llvm/include/llvm/Analysis/Verifier.h Thu Apr 21 15:16:32 2005
@@ -1,10 +1,10 @@
//===-- llvm/Analysis/Verifier.h - Module Verifier --------------*- 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 function verifier interface, that can be used for some
@@ -28,12 +28,12 @@
class Function;
/// @brief An enumeration to specify the action to be taken if errors found.
-///
+///
/// This enumeration is used in the functions below to indicate what should
/// happen if the verifier finds errors. Each of the functions that uses
/// this enumeration as an argument provides a default value for it. The
/// actions are listed below.
-enum VerifierFailureAction {
+enum VerifierFailureAction {
AbortProcessAction, ///< verifyModule will print to stderr and abort()
ThrowExceptionAction, ///< verifyModule will throw errors as std::string
PrintMessageAction, ///< verifyModule will print to stderr and return true
@@ -45,15 +45,15 @@
/// Check a module or function for validity. When the pass is used, the
/// action indicated by the \p action argument will be used if errors are
/// found.
-FunctionPass *createVerifierPass(
+FunctionPass *createVerifierPass(
VerifierFailureAction action = AbortProcessAction ///< Action to take
);
-/// @brief Check a module for errors.
+/// @brief Check a module for errors.
///
-/// If there are no errors, the function returns false. If an error is found,
+/// If there are no errors, the function returns false. If an error is found,
/// the action taken depends on the \p action parameter.
-/// This should only be used for debugging, because it plays games with
+/// This should only be used for debugging, because it plays games with
/// PassManagers and stuff.
bool verifyModule(
More information about the llvm-commits
mailing list