Add std:: to sort calls.

[oota-llvm.git] / lib / Transforms / IPO / DeadTypeElimination.cpp

diff --git a/lib/Transforms/IPO/DeadTypeElimination.cpp b/lib/Transforms/IPO/DeadTypeElimination.cpp
index cad90f56729e13a424f75d1ee920a90a6a62b3a8..87b725ab1d57c795471f447bc0e25650fc98f99e 100644 (file)
--- a/lib/Transforms/IPO/DeadTypeElimination.cpp
+++ b/lib/Transforms/IPO/DeadTypeElimination.cpp
@@ -1,10 +1,10 @@
 //===- DeadTypeElimination.cpp - Eliminate unused types for symbol table --===//
-// 
+//
 //                     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 cleanup the output of GCC.  It eliminate names for types
@@ -12,23 +12,30 @@
 //
 //===----------------------------------------------------------------------===//
 
+#define DEBUG_TYPE "deadtypeelim"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Analysis/FindUsedTypes.h"
 #include "llvm/Module.h"
-#include "llvm/SymbolTable.h"
+#include "llvm/TypeSymbolTable.h"
 #include "llvm/DerivedTypes.h"
-#include "Support/Statistic.h"
+#include "llvm/ADT/Statistic.h"
+#include "llvm/Support/Compiler.h"
 using namespace llvm;
 
+STATISTIC(NumKilled, "Number of unused typenames removed from symtab");
+
 namespace {
-  struct DTE : public Pass {
+  struct VISIBILITY_HIDDEN DTE : public ModulePass {
+    static char ID; // Pass identification, replacement for typeid
+    DTE() : ModulePass((intptr_t)&ID) {}
+
     // doPassInitialization - For this pass, it removes global symbol table
     // entries for primitive types.  These are never used for linking in GCC and
     // they make the output uglier to look at, so we nuke them.
     //
     // Also, initialize instance variables.
     //
-    bool run(Module &M);
+    bool runOnModule(Module &M);
 
     // getAnalysisUsage - This function needs FindUsedTypes to do its job...
     //
@@ -36,12 +43,11 @@ namespace {
       AU.addRequired<FindUsedTypes>();
     }
   };
-  RegisterOpt<DTE> X("deadtypeelim", "Dead Type Elimination");
-  Statistic<>
-  NumKilled("deadtypeelim", "Number of unused typenames removed from symtab");
+  char DTE::ID = 0;
+  RegisterPass<DTE> X("deadtypeelim", "Dead Type Elimination");
 }
 
-Pass *llvm::createDeadTypeEliminationPass() {
+ModulePass *llvm::createDeadTypeEliminationPass() {
   return new DTE();
 }
 
@@ -51,11 +57,14 @@ Pass *llvm::createDeadTypeEliminationPass() {
 //
 static inline bool ShouldNukeSymtabEntry(const Type *Ty){
   // Nuke all names for primitive types!
-  if (Ty->isPrimitiveType()) return true;
+  if (Ty->isPrimitiveType() || Ty->isInteger()) 
+    return true;
 
   // Nuke all pointers to primitive types as well...
   if (const PointerType *PT = dyn_cast<PointerType>(Ty))
-    if (PT->getElementType()->isPrimitiveType()) return true;
+    if (PT->getElementType()->isPrimitiveType() ||
+        PT->getElementType()->isInteger()) 
+      return true;
 
   return false;
 }
@@ -65,23 +74,23 @@ static inline bool ShouldNukeSymtabEntry(const Type *Ty){
 // uglier to look at, so we nuke them.  Also eliminate types that are never used
 // in the entire program as indicated by FindUsedTypes.
 //
-bool DTE::run(Module &M) {
+bool DTE::runOnModule(Module &M) {
   bool Changed = false;
 
-  SymbolTable &ST = M.getSymbolTable();
+  TypeSymbolTable &ST = M.getTypeSymbolTable();
   std::set<const Type *> UsedTypes = getAnalysis<FindUsedTypes>().getTypes();
 
   // Check the symbol table for superfluous type entries...
   //
   // Grab the 'type' plane of the module symbol...
-  SymbolTable::type_iterator TI = ST.type_begin();
-  while ( TI != ST.type_end() ) {
+  TypeSymbolTable::iterator TI = ST.begin();
+  TypeSymbolTable::iterator TE = ST.end();
+  while ( TI != TE ) {
     // If this entry should be unconditionally removed, or if we detect that
     // the type is not used, remove it.
     const Type *RHS = TI->second;
     if (ShouldNukeSymtabEntry(RHS) || !UsedTypes.count(RHS)) {
-      SymbolTable::type_iterator ToRemove = TI++;
-      ST.remove(ToRemove->second);
+      ST.remove(TI++);
       ++NumKilled;
       Changed = true;
     } else {