Updates to work with recent Statistic's changes:

* Renamed StatisticReporter.h/cpp to Statistic.h/cpp
    * Broke constructor to take two const char * arguments instead of one, so
      that indendation can be taken care of automatically.
    * Sort the list by pass name when printing
    * Make sure to print all statistics as a group, instead of randomly when
      the statistics dtors are called.
    * Updated ProgrammersManual with new semantics.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4002 91177308-0d34-0410-b5e6-96231b3b80d8

lib/Bytecode/Writer/InstructionWriter.cpp

@@ -14,13 +14,13 @@
 #include "llvm/DerivedTypes.h"
 #include "llvm/iOther.h"
 #include "llvm/iTerminators.h"
-#include "Support/StatisticReporter.h"
+#include "Support/Statistic.h"
 #include <algorithm>
 
 static Statistic<> 
-NumOversized("bytecodewriter\t- Number of oversized instructions");
+NumOversized("bytecodewriter", "Number of oversized instructions");
 static Statistic<> 
-NumNormal("bytecodewriter\t- Number of normal instructions");
+NumNormal("bytecodewriter", "Number of normal instructions");
 
 typedef unsigned char uchar;
 

lib/Bytecode/Writer/Writer.cpp

@@ -25,14 +25,14 @@
 #include "llvm/SymbolTable.h"
 #include "llvm/DerivedTypes.h"
 #include "Support/STLExtras.h"
-#include "Support/StatisticReporter.h"
+#include "Support/Statistic.h"
 #include <string.h>
 #include <algorithm>
 
 static RegisterPass<WriteBytecodePass> X("emitbytecode", "Bytecode Writer");
 
 static Statistic<> 
-BytesWritten("bytecodewriter\t- Number of bytecode bytes written");
+BytesWritten("bytecodewriter", "Number of bytecode bytes written");
 
 
 BytecodeWriter::BytecodeWriter(std::deque<unsigned char> &o, const Module *M) 

lib/Transforms/IPO/ConstantMerge.cpp

@@ -14,7 +14,7 @@
 #include "llvm/Module.h"
 #include "llvm/Constants.h"
 #include "llvm/Pass.h"
-#include "Support/StatisticReporter.h"
+#include "Support/Statistic.h"
 
 namespace {
   struct ConstantMerge : public Pass {
@@ -28,7 +28,7 @@ namespace {
     void replaceConstantWith(Constant *Old, Constant *New);
   };
 
-  Statistic<> NumMerged("constmerge\t\t- Number of global constants merged");
+  Statistic<> NumMerged("constmerge", "Number of global constants merged");
   RegisterOpt<ConstantMerge> X("constmerge","Merge Duplicate Global Constants");
 }
 

lib/Transforms/IPO/DeadTypeElimination.cpp

@@ -10,7 +10,7 @@
 #include "llvm/Module.h"
 #include "llvm/SymbolTable.h"
 #include "llvm/DerivedTypes.h"
-#include "Support/StatisticReporter.h"
+#include "Support/Statistic.h"
 
 using std::vector;
 
@@ -31,7 +31,8 @@ namespace {
     }
   };
   RegisterOpt<DTE> X("deadtypeelim", "Dead Type Elimination");
-  Statistic<> NumKilled("deadtypeelim\t- Number of unused typenames removed from symtab");
+  Statistic<>
+  NumKilled("deadtypeelim", "Number of unused typenames removed from symtab");
 }
 
 Pass *createDeadTypeEliminationPass() {

lib/Transforms/IPO/FunctionResolution.cpp

@@ -18,7 +18,7 @@
 #include "llvm/Pass.h"
 #include "llvm/iOther.h"
 #include "llvm/Constant.h"
-#include "Support/StatisticReporter.h"
+#include "Support/Statistic.h"
 #include <algorithm>
 
 using std::vector;
@@ -26,7 +26,7 @@ using std::string;
 using std::cerr;
 
 namespace {
-  Statistic<>NumResolved("funcresolve\t- Number of varargs functions resolved");
+  Statistic<>NumResolved("funcresolve", "Number of varargs functions resolved");
 
   struct FunctionResolvingPass : public Pass {
     bool run(Module &M);

lib/Transforms/IPO/GlobalDCE.cpp

@@ -9,54 +9,53 @@
 #include "llvm/Module.h"
 #include "llvm/Constants.h"
 #include "llvm/DerivedTypes.h"
-#include "llvm/GlobalVariable.h"
 #include "llvm/Analysis/CallGraph.h"
 #include "Support/DepthFirstIterator.h"
-#include "Support/StatisticReporter.h"
+#include "Support/Statistic.h"
 #include <algorithm>
 
-static Statistic<> NumFunctions("globaldce\t- Number of functions removed");
-static Statistic<> NumVariables("globaldce\t- Number of global variables removed");
-static Statistic<> NumCPRs("globaldce\t- Number of const pointer refs removed");
-static Statistic<> NumConsts("globaldce\t- Number of init constants removed");
-
-static bool RemoveUnreachableFunctions(Module &M, CallGraph &CallGraph) {
-  // Calculate which functions are reachable from the external functions in the
-  // call graph.
-  //
-  std::set<CallGraphNode*> ReachableNodes(df_begin(&CallGraph),
-                                          df_end(&CallGraph));
-
-  // Loop over the functions in the module twice.  The first time is used to
-  // drop references that functions have to each other before they are deleted.
-  // The second pass removes the functions that need to be removed.
-  //
-  std::vector<CallGraphNode*> FunctionsToDelete;   // Track unused functions
-  for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
-    CallGraphNode *N = CallGraph[I];
-
-    if (!ReachableNodes.count(N)) {              // Not reachable??
-      I->dropAllReferences();
-      N->removeAllCalledFunctions();
-      FunctionsToDelete.push_back(N);
-      ++NumFunctions;
-    }
-  }
-
-  // Nothing to do if no unreachable functions have been found...
-  if (FunctionsToDelete.empty()) return false;
-
-  // Unreachables functions have been found and should have no references to
-  // them, delete them now.
-  //
-  for (std::vector<CallGraphNode*>::iterator I = FunctionsToDelete.begin(),
-	 E = FunctionsToDelete.end(); I != E; ++I)
-    delete CallGraph.removeFunctionFromModule(*I);
-
-  return true;
-}
-
 namespace {
+  Statistic<> NumFunctions("globaldce","Number of functions removed");
+  Statistic<> NumVariables("globaldce","Number of global variables removed");
+  Statistic<> NumCPRs("globaldce", "Number of const pointer refs removed");
+  Statistic<> NumConsts("globaldce", "Number of init constants removed");
+
+  bool RemoveUnreachableFunctions(Module &M, CallGraph &CallGraph) {
+    // Calculate which functions are reachable from the external functions in
+    // the call graph.
+    //
+    std::set<CallGraphNode*> ReachableNodes(df_begin(&CallGraph),
+                                            df_end(&CallGraph));
+
+    // Loop over the functions in the module twice.  The first time is used to
+    // drop references that functions have to each other before they are
+    // deleted.  The second pass removes the functions that need to be removed.
+    //
+    std::vector<CallGraphNode*> FunctionsToDelete;   // Track unused functions
+    for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
+      CallGraphNode *N = CallGraph[I];
+      
+      if (!ReachableNodes.count(N)) {              // Not reachable??
+        I->dropAllReferences();
+        N->removeAllCalledFunctions();
+        FunctionsToDelete.push_back(N);
+        ++NumFunctions;
+      }
+    }
+    
+    // Nothing to do if no unreachable functions have been found...
+    if (FunctionsToDelete.empty()) return false;
+    
+    // Unreachables functions have been found and should have no references to
+    // them, delete them now.
+    //
+    for (std::vector<CallGraphNode*>::iterator I = FunctionsToDelete.begin(),
+           E = FunctionsToDelete.end(); I != E; ++I)
+      delete CallGraph.removeFunctionFromModule(*I);
+    
+    return true;
+  }
+  
   struct GlobalDCE : public Pass {
     // run - Do the GlobalDCE pass on the specified module, optionally updating
     // the specified callgraph to reflect the changes.

lib/Transforms/IPO/Internalize.cpp

@@ -9,12 +9,11 @@
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Pass.h"
 #include "llvm/Module.h"
-#include "Support/StatisticReporter.h"
+#include "Support/Statistic.h"
 
 namespace {
-  Statistic<> NumFunctions("internalize\t- Number of functions internalized");
-  Statistic<> NumGlobals  ("internalize\t- Number of global vars internalized");
-
+  Statistic<> NumFunctions("internalize", "Number of functions internalized");
+  Statistic<> NumGlobals  ("internalize", "Number of global vars internalized");
 
   class InternalizePass : public Pass {
     virtual bool run(Module &M) {

lib/Transforms/IPO/MutateStructTypes.cpp

@@ -19,12 +19,11 @@
 #include "llvm/iMemory.h"
 #include "llvm/iTerminators.h"
 #include "llvm/iOther.h"
-#include "llvm/Argument.h"
 #include "llvm/Constants.h"
 #include "Support/STLExtras.h"
-#include "Support/StatisticReporter.h"
+#include "Support/Statistic.h"
 #include <algorithm>
-#include <iostream>
+
 using std::map;
 using std::vector;
 

lib/Transforms/IPO/RaiseAllocations.cpp

@@ -12,32 +12,31 @@
 #include "llvm/iMemory.h"
 #include "llvm/iOther.h"
 #include "llvm/Pass.h"
-#include "Support/StatisticReporter.h"
-
-static Statistic<> NumRaised("raiseallocs\t- Number of allocations raised");
+#include "Support/Statistic.h"
 
 namespace {
+  Statistic<> NumRaised("raiseallocs", "Number of allocations raised");
 
-// RaiseAllocations - Turn %malloc and %free calls into the appropriate
-// instruction.
-//
-class RaiseAllocations : public BasicBlockPass {
-  Function *MallocFunc;   // Functions in the module we are processing
-  Function *FreeFunc;     // Initialized by doPassInitializationVirt
-public:
-  RaiseAllocations() : MallocFunc(0), FreeFunc(0) {}
-
-  // doPassInitialization - For the raise allocations pass, this finds a
-  // declaration for malloc and free if they exist.
+  // RaiseAllocations - Turn %malloc and %free calls into the appropriate
+  // instruction.
   //
-  bool doInitialization(Module &M);
-
-  // runOnBasicBlock - This method does the actual work of converting
-  // instructions over, assuming that the pass has already been initialized.
-  //
-  bool runOnBasicBlock(BasicBlock &BB);
-};
-
+  class RaiseAllocations : public BasicBlockPass {
+    Function *MallocFunc;   // Functions in the module we are processing
+    Function *FreeFunc;     // Initialized by doPassInitializationVirt
+  public:
+    RaiseAllocations() : MallocFunc(0), FreeFunc(0) {}
+    
+    // doPassInitialization - For the raise allocations pass, this finds a
+    // declaration for malloc and free if they exist.
+    //
+    bool doInitialization(Module &M);
+    
+    // runOnBasicBlock - This method does the actual work of converting
+    // instructions over, assuming that the pass has already been initialized.
+    //
+    bool runOnBasicBlock(BasicBlock &BB);
+  };
+  
   RegisterOpt<RaiseAllocations>
   X("raiseallocs", "Raise allocations from calls to instructions");
 }  // end anonymous namespace

lib/Transforms/Scalar/ADCE.cpp

@@ -17,16 +17,14 @@
 #include "llvm/Support/CFG.h"
 #include "Support/STLExtras.h"
 #include "Support/DepthFirstIterator.h"
-#include "Support/StatisticReporter.h"
+#include "Support/Statistic.h"
 #include <algorithm>
-#include <iostream>
 using std::cerr;
 using std::vector;
 
-static Statistic<> NumBlockRemoved("adce\t\t- Number of basic blocks removed");
-static Statistic<> NumInstRemoved ("adce\t\t- Number of instructions removed");
-
 namespace {
+  Statistic<> NumBlockRemoved("adce", "Number of basic blocks removed");
+  Statistic<> NumInstRemoved ("adce", "Number of instructions removed");
 
 //===----------------------------------------------------------------------===//
 // ADCE Class

lib/Transforms/Scalar/BreakCriticalEdges.cpp

@@ -14,10 +14,10 @@
 #include "llvm/iTerminators.h"
 #include "llvm/iPHINode.h"
 #include "llvm/Support/CFG.h"
-#include "Support/StatisticReporter.h"
+#include "Support/Statistic.h"
 
 namespace {
-  Statistic<> NumBroken("break-crit-edges\t- Number of blocks inserted");
+  Statistic<> NumBroken("break-crit-edges", "Number of blocks inserted");
 
   struct BreakCriticalEdges : public FunctionPass {
     virtual bool runOnFunction(Function &F);

lib/Transforms/Scalar/ConstantProp.cpp

@@ -17,12 +17,12 @@
 #include "llvm/Instruction.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/InstIterator.h"
-#include "Support/StatisticReporter.h"
+#include "Support/Statistic.h"
 #include <set>
 
-static Statistic<> NumInstKilled("constprop - Number of instructions killed");
-
 namespace {
+  Statistic<> NumInstKilled("constprop", "Number of instructions killed");
+
   struct ConstantPropogation : public FunctionPass {
     bool runOnFunction(Function &F);
 

lib/Transforms/Scalar/CorrelatedExprs.cpp

@@ -32,13 +32,13 @@
 #include "llvm/Support/ConstantRange.h"
 #include "llvm/Support/CFG.h"
 #include "Support/PostOrderIterator.h"
-#include "Support/StatisticReporter.h"
+#include "Support/Statistic.h"
 #include <algorithm>
 
 namespace {
-  Statistic<>NumSetCCRemoved("cee\t\t- Number of setcc instruction eliminated");
-  Statistic<>NumOperandsCann("cee\t\t- Number of operands cannonicalized");
-  Statistic<>BranchRevectors("cee\t\t- Number of branches revectored");
+  Statistic<> NumSetCCRemoved("cee", "Number of setcc instruction eliminated");
+  Statistic<> NumOperandsCann("cee", "Number of operands cannonicalized");
+  Statistic<> BranchRevectors("cee", "Number of branches revectored");
 
   class ValueInfo;
   class Relation {

lib/Transforms/Scalar/DCE.cpp

@@ -14,17 +14,17 @@
 #include "llvm/Instruction.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/InstIterator.h"
-#include "Support/StatisticReporter.h"
+#include "Support/Statistic.h"
 #include <set>
 
-static Statistic<> DIEEliminated("die\t\t- Number of insts removed");
-static Statistic<> DCEEliminated("dce\t\t- Number of insts removed");
-
-//===----------------------------------------------------------------------===//
-// DeadInstElimination pass implementation
-//
-
 namespace {
+  Statistic<> DIEEliminated("die", "Number of insts removed");
+  Statistic<> DCEEliminated("dce", "Number of insts removed");
+
+  //===--------------------------------------------------------------------===//
+  // DeadInstElimination pass implementation
+  //
+
   struct DeadInstElimination : public BasicBlockPass {
     virtual bool runOnBasicBlock(BasicBlock &BB) {
       bool Changed = false;

lib/Transforms/Scalar/DecomposeMultiDimRefs.cpp

@@ -16,10 +16,10 @@
 #include "llvm/iOther.h"
 #include "llvm/BasicBlock.h"
 #include "llvm/Pass.h"
-#include "Support/StatisticReporter.h"
+#include "Support/Statistic.h"
 
 namespace {
-  Statistic<> NumAdded("lowerrefs\t\t- # of getelementptr instructions added");
+  Statistic<> NumAdded("lowerrefs", "# of getelementptr instructions added");
 
   struct DecomposePass : public BasicBlockPass {
     virtual bool runOnBasicBlock(BasicBlock &BB);

lib/Transforms/Scalar/GCSE.cpp

@@ -13,13 +13,13 @@
 #include "llvm/Analysis/Dominators.h"
 #include "llvm/Analysis/ValueNumbering.h"
 #include "llvm/Support/InstIterator.h"
-#include "Support/StatisticReporter.h"
+#include "Support/Statistic.h"
 #include <algorithm>
 
 namespace {
-  Statistic<> NumInstRemoved("gcse\t\t- Number of instructions removed");
-  Statistic<> NumLoadRemoved("gcse\t\t- Number of loads removed");
-  Statistic<> NumNonInsts   ("gcse\t\t- Number of instructions removed due "
+  Statistic<> NumInstRemoved("gcse", "Number of instructions removed");
+  Statistic<> NumLoadRemoved("gcse", "Number of loads removed");
+  Statistic<> NumNonInsts   ("gcse", "Number of instructions removed due "
                              "to non-instruction values");
 
   class GCSE : public FunctionPass {

lib/Transforms/Scalar/IndVarSimplify.cpp

@@ -14,11 +14,11 @@
 #include "llvm/Constants.h"
 #include "llvm/Support/CFG.h"
 #include "Support/STLExtras.h"
-#include "Support/StatisticReporter.h"
+#include "Support/Statistic.h"
 
 namespace {
-  Statistic<> NumRemoved ("indvars\t\t- Number of aux indvars removed");
-  Statistic<> NumInserted("indvars\t\t- Number of cannonical indvars added");
+  Statistic<> NumRemoved ("indvars", "Number of aux indvars removed");
+  Statistic<> NumInserted("indvars", "Number of cannonical indvars added");
 }
 
 // InsertCast - Cast Val to Ty, setting a useful name on the cast if Val has a

lib/Transforms/Scalar/InstructionCombining.cpp

@@ -25,14 +25,14 @@
 #include "llvm/Pass.h"
 #include "llvm/Support/InstIterator.h"
 #include "llvm/Support/InstVisitor.h"
-#include "Support/StatisticReporter.h"
+#include "Support/Statistic.h"
 #include <algorithm>
 
-static Statistic<> NumCombined ("instcombine\t- Number of insts combined");
-static Statistic<> NumConstProp("instcombine\t- Number of constant folds");
-static Statistic<> NumDeadInst ("instcombine\t- Number of dead inst eliminate");
-
 namespace {
+  Statistic<> NumCombined ("instcombine", "Number of insts combined");
+  Statistic<> NumConstProp("instcombine", "Number of constant folds");
+  Statistic<> NumDeadInst ("instcombine", "Number of dead inst eliminated");
+
   class InstCombiner : public FunctionPass,
                        public InstVisitor<InstCombiner, Instruction*> {
     // Worklist of all of the instructions that need to be simplified.

lib/Transforms/Scalar/LICM.cpp

@@ -13,14 +13,14 @@
 #include "llvm/iMemory.h"
 #include "llvm/Support/InstVisitor.h"
 #include "Support/STLExtras.h"
-#include "Support/StatisticReporter.h"
+#include "Support/Statistic.h"
 #include "llvm/Assembly/Writer.h"
 #include <algorithm>
 using std::string;
 
 namespace {
-  Statistic<>NumHoisted("licm\t\t- Number of instructions hoisted out of loop");
-  Statistic<> NumHoistedLoads("licm\t\t- Number of load insts hoisted");
+  Statistic<> NumHoisted("licm", "Number of instructions hoisted out of loop");
+  Statistic<> NumHoistedLoads("licm", "Number of load insts hoisted");
 
   struct LICM : public FunctionPass, public InstVisitor<LICM> {
     virtual bool runOnFunction(Function &F);

lib/Transforms/Scalar/PiNodeInsertion.cpp

@@ -29,16 +29,15 @@
 #include "llvm/Analysis/Dominators.h"
 #include "llvm/Pass.h"
 #include "llvm/Function.h"
-#include "llvm/BasicBlock.h"
 #include "llvm/iTerminators.h"
 #include "llvm/iOperators.h"
 #include "llvm/iPHINode.h"
 #include "llvm/Support/CFG.h"
-#include "Support/StatisticReporter.h"
-
-static Statistic<> NumInserted("pinodes\t\t- Number of Pi nodes inserted");
+#include "Support/Statistic.h"
 
 namespace {
+  Statistic<> NumInserted("pinodes", "Number of Pi nodes inserted");
+
   struct PiNodeInserter : public FunctionPass {
     virtual bool runOnFunction(Function &F);
     

lib/Transforms/Scalar/Reassociate.cpp

@@ -18,20 +18,19 @@
 
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Function.h"
-#include "llvm/BasicBlock.h"
 #include "llvm/iOperators.h"
 #include "llvm/Type.h"
 #include "llvm/Pass.h"
 #include "llvm/Constant.h"
 #include "llvm/Support/CFG.h"
 #include "Support/PostOrderIterator.h"
-#include "Support/StatisticReporter.h"
-
-static Statistic<> NumLinear ("reassociate\t- Number of insts linearized");
-static Statistic<> NumChanged("reassociate\t- Number of insts reassociated");
-static Statistic<> NumSwapped("reassociate\t- Number of insts with operands swapped");
+#include "Support/Statistic.h"
 
 namespace {
+  Statistic<> NumLinear ("reassociate","Number of insts linearized");
+  Statistic<> NumChanged("reassociate","Number of insts reassociated");
+  Statistic<> NumSwapped("reassociate","Number of insts with operands swapped");
+
   class Reassociate : public FunctionPass {
     std::map<BasicBlock*, unsigned> RankMap;
   public:

lib/Transforms/Scalar/SCCP.cpp

@@ -24,17 +24,17 @@
 #include "llvm/Pass.h"
 #include "llvm/Support/InstVisitor.h"
 #include "Support/STLExtras.h"
-#include "Support/StatisticReporter.h"
+#include "Support/Statistic.h"
 #include <algorithm>
 #include <set>
 using std::cerr;
 
-static Statistic<> NumInstRemoved("sccp\t\t- Number of instructions removed");
-
 // InstVal class - This class represents the different lattice values that an 
 // instruction may occupy.  It is a simple class with value semantics.
 //
 namespace {
+  Statistic<> NumInstRemoved("sccp", "Number of instructions removed");
+
 class InstVal {
   enum { 
     undefined,           // This instruction has no known value

lib/Transforms/Scalar/SimplifyCFG.cpp

@@ -16,12 +16,12 @@
 #include "llvm/Module.h"
 #include "llvm/Support/CFG.h"
 #include "llvm/Pass.h"
-#include "Support/StatisticReporter.h"
+#include "Support/Statistic.h"
 #include <set>
 
-static Statistic<> NumSimpl("cfgsimplify\t- Number of blocks simplified");
-
 namespace {
+  Statistic<> NumSimpl("cfgsimplify", "Number of blocks simplified");
+
   struct CFGSimplifyPass : public FunctionPass {
     virtual bool runOnFunction(Function &F);
   };

lib/Transforms/Utils/BreakCriticalEdges.cpp

@@ -14,10 +14,10 @@
 #include "llvm/iTerminators.h"
 #include "llvm/iPHINode.h"
 #include "llvm/Support/CFG.h"
-#include "Support/StatisticReporter.h"
+#include "Support/Statistic.h"
 
 namespace {
-  Statistic<> NumBroken("break-crit-edges\t- Number of blocks inserted");
+  Statistic<> NumBroken("break-crit-edges", "Number of blocks inserted");
 
   struct BreakCriticalEdges : public FunctionPass {
     virtual bool runOnFunction(Function &F);

lib/Transforms/Utils/LoopSimplify.cpp

@@ -13,10 +13,10 @@
 #include "llvm/iPHINode.h"
 #include "llvm/Constant.h"
 #include "llvm/Support/CFG.h"
-#include "Support/StatisticReporter.h"
+#include "Support/Statistic.h"
 
 namespace {
-  Statistic<> NumInserted("preheaders\t- Number of pre-header nodes inserted");
+  Statistic<> NumInserted("preheaders", "Number of pre-header nodes inserted");
 
   struct Preheaders : public FunctionPass {
     virtual bool runOnFunction(Function &F);

lib/Transforms/Utils/LowerAllocations.cpp

@@ -13,12 +13,12 @@
 #include "llvm/Constants.h"
 #include "llvm/Pass.h"
 #include "llvm/Target/TargetData.h"
-#include "Support/StatisticReporter.h"
+#include "Support/Statistic.h"
 
-static Statistic<> NumLowered("lowerallocs\t- Number of allocations lowered");
 using std::vector;
 
 namespace {
+  Statistic<> NumLowered("lowerallocs", "Number of allocations lowered");
 
   /// LowerAllocations - Turn malloc and free instructions into %malloc and
   /// %free calls.

lib/Transforms/Utils/PromoteMemoryToRegister.cpp

@@ -23,18 +23,17 @@
 #include "llvm/iPHINode.h"
 #include "llvm/iTerminators.h"
 #include "llvm/Function.h"
-#include "llvm/BasicBlock.h"
 #include "llvm/Constant.h"
 #include "llvm/Type.h"
-#include "Support/StatisticReporter.h"
-
-static Statistic<> NumPromoted("mem2reg\t\t- Number of alloca's promoted");
+#include "Support/Statistic.h"
 
 using std::vector;
 using std::map;
 using std::set;
 
 namespace {
+  Statistic<> NumPromoted("mem2reg", "Number of alloca's promoted");
+
   struct PromotePass : public FunctionPass {
     vector<AllocaInst*>          Allocas;      // the alloca instruction..
     map<Instruction*, unsigned>  AllocaLookup; // reverse mapping of above