Reformat partially.

llvm-svn: 247557

llvm/include/llvm/Analysis/CallGraphSCCPass.h

@@ -87,7 +87,7 @@ class CallGraphSCC {
 public:
   CallGraphSCC(void *context) : Context(context) {}
 
-  void initialize(CallGraphNode*const*I, CallGraphNode*const*E) {
+  void initialize(CallGraphNode *const *I, CallGraphNode *const *E) {
     Nodes.assign(I, E);
   }
 
@@ -98,7 +98,7 @@ public:
   /// Old node has been deleted, and New is to be used in its place.
   void ReplaceNode(CallGraphNode *Old, CallGraphNode *New);
 
-  typedef std::vector<CallGraphNode*>::const_iterator iterator;
+  typedef std::vector<CallGraphNode *>::const_iterator iterator;
   iterator begin() const { return Nodes.begin(); }
   iterator end() const { return Nodes.end(); }
 };

llvm/include/llvm/Analysis/DependenceAnalysis.h

@@ -185,27 +185,19 @@ namespace llvm {
 
     /// getNextPredecessor - Returns the value of the NextPredecessor
     /// field.
-    const Dependence *getNextPredecessor() const {
-      return NextPredecessor;
-    }
+    const Dependence *getNextPredecessor() const { return NextPredecessor; }
 
     /// getNextSuccessor - Returns the value of the NextSuccessor
     /// field.
-    const Dependence *getNextSuccessor() const {
-      return NextSuccessor;
-    }
+    const Dependence *getNextSuccessor() const { return NextSuccessor; }
 
     /// setNextPredecessor - Sets the value of the NextPredecessor
     /// field.
-    void setNextPredecessor(const Dependence *pred) {
-      NextPredecessor = pred;
-    }
+    void setNextPredecessor(const Dependence *pred) { NextPredecessor = pred; }
 
     /// setNextSuccessor - Sets the value of the NextSuccessor
     /// field.
-    void setNextSuccessor(const Dependence *succ) {
-      NextSuccessor = succ;
-    }
+    void setNextSuccessor(const Dependence *succ) { NextSuccessor = succ; }
 
     /// dump - For debugging purposes, dumps a dependence to OS.
     ///

llvm/include/llvm/Analysis/PHITransAddr.h

@@ -91,7 +91,7 @@ public:
   ///
   Value *PHITranslateWithInsertion(BasicBlock *CurBB, BasicBlock *PredBB,
                                    const DominatorTree &DT,
-                                   SmallVectorImpl<Instruction*> &NewInsts);
+                                   SmallVectorImpl<Instruction *> &NewInsts);
 
   void dump() const;
 
@@ -111,7 +111,7 @@ private:
   ///
   Value *InsertPHITranslatedSubExpr(Value *InVal, BasicBlock *CurBB,
                                     BasicBlock *PredBB, const DominatorTree &DT,
-                                    SmallVectorImpl<Instruction*> &NewInsts);
+                                    SmallVectorImpl<Instruction *> &NewInsts);
 
   /// AddAsInput - If the specified value is an instruction, add it as an input.
   Value *AddAsInput(Value *V) {

llvm/include/llvm/Analysis/SparsePropagation.h

@@ -21,18 +21,18 @@
 #include <vector>
 
 namespace llvm {
-  class Value;
-  class Constant;
-  class Argument;
-  class Instruction;
-  class PHINode;
-  class TerminatorInst;
-  class BasicBlock;
-  class Function;
-  class SparseSolver;
-  class raw_ostream;
+class Value;
+class Constant;
+class Argument;
+class Instruction;
+class PHINode;
+class TerminatorInst;
+class BasicBlock;
+class Function;
+class SparseSolver;
+class raw_ostream;
 
-  template<typename T> class SmallVectorImpl;
+template <typename T> class SmallVectorImpl;
 
 /// AbstractLatticeFunction - This class is implemented by the dataflow instance
 /// to specify what the lattice values are and how they handle merges etc.
@@ -64,9 +64,7 @@ public:
   /// IsUntrackedValue - If the specified Value is something that is obviously
   /// uninteresting to the analysis (and would always return UntrackedVal),
   /// this function can return true to avoid pointless work.
-  virtual bool IsUntrackedValue(Value *V) {
-    return false;
-  }
+  virtual bool IsUntrackedValue(Value *V) { return false; }
 
   /// ComputeConstant - Given a constant value, compute and return a lattice
   /// value corresponding to the specified constant.
@@ -76,9 +74,7 @@ public:
 
   /// IsSpecialCasedPHI - Given a PHI node, determine whether this PHI node is
   /// one that the we want to handle through ComputeInstructionState.
-  virtual bool IsSpecialCasedPHI(PHINode *PN) {
-    return false;
-  }
+  virtual bool IsSpecialCasedPHI(PHINode *PN) { return false; }
 
   /// GetConstant - If the specified lattice value is representable as an LLVM
   /// constant value, return it.  Otherwise return null.  The returned value
@@ -120,12 +116,12 @@ class SparseSolver {
   /// compute transfer functions.
   AbstractLatticeFunction *LatticeFunc;
 
-  DenseMap<Value*, LatticeVal> ValueState;  // The state each value is in.
-  SmallPtrSet<BasicBlock*, 16> BBExecutable;   // The bbs that are executable.
+  DenseMap<Value *, LatticeVal> ValueState;   // The state each value is in.
+  SmallPtrSet<BasicBlock *, 16> BBExecutable; // The bbs that are executable.
 
-  std::vector<Instruction*> InstWorkList;   // Worklist of insts to process.
+  std::vector<Instruction *> InstWorkList; // Worklist of insts to process.
 
-  std::vector<BasicBlock*> BBWorkList;  // The BasicBlock work list
+  std::vector<BasicBlock *> BBWorkList; // The BasicBlock work list
 
   /// KnownFeasibleEdges - Entries in this set are edges which have already had
   /// PHI nodes retriggered.
@@ -137,10 +133,8 @@ class SparseSolver {
 
 public:
   explicit SparseSolver(AbstractLatticeFunction *Lattice)
-    : LatticeFunc(Lattice) {}
-  ~SparseSolver() {
-    delete LatticeFunc;
-  }
+      : LatticeFunc(Lattice) {}
+  ~SparseSolver() { delete LatticeFunc; }
 
   /// Solve - Solve for constants and executable blocks.
   ///