Fix batch of converting RegisterPass<> to INTIALIZE_PASS().

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

diff --git a/lib/Transforms/IPO/DeadTypeElimination.cpp b/lib/Transforms/IPO/DeadTypeElimination.cpp
index 3473f526dcd84d36d8acf0bfa5fdbf24cfbabab4..5ff80f72cf463c6de449ccfd02a3be94ce2b6190 100644 (file)
--- a/lib/Transforms/IPO/DeadTypeElimination.cpp
+++ b/lib/Transforms/IPO/DeadTypeElimination.cpp
@@ -1,55 +1,70 @@
 //===- DeadTypeElimination.cpp - Eliminate unused types for symbol table --===//
 //
+//                     The LLVM Compiler Infrastructure
+//
+// This file 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
 // that are unused in the entire translation unit, using the FindUsedTypes pass.
 //
 //===----------------------------------------------------------------------===//
 
+#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/StatisticReporter.h"
+#include "llvm/ADT/Statistic.h"
+using namespace llvm;
 
-using std::vector;
+STATISTIC(NumKilled, "Number of unused typenames removed from symtab");
 
 namespace {
-  struct DTE : public Pass {
+  struct DTE : public ModulePass {
+    static char ID; // Pass identification, replacement for typeid
+    DTE() : ModulePass(&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...
     //
     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
-      AU.addRequired(FindUsedTypes::ID);
+      AU.addRequired<FindUsedTypes>();
     }
   };
-  RegisterOpt<DTE> X("deadtypeelim", "Dead Type Elimination");
-  Statistic<> NumKilled("deadtypeelim\t- Number of unused typenames removed from symtab");
 }
 
-Pass *createDeadTypeEliminationPass() {
+char DTE::ID = 0;
+INITIALIZE_PASS(DTE, "deadtypeelim", "Dead Type Elimination", false, false);
+
+ModulePass *llvm::createDeadTypeEliminationPass() {
   return new DTE();
 }
 
 
-
-// ShouldNukSymtabEntry - Return true if this module level symbol table entry
+// ShouldNukeSymtabEntry - Return true if this module level symbol table entry
 // should be eliminated.
 //
-static inline bool ShouldNukeSymtabEntry(const std::pair<std::string,Value*>&E){
+static inline bool ShouldNukeSymtabEntry(const Type *Ty){
   // Nuke all names for primitive types!
-  if (cast<Type>(E.second)->isPrimitiveType()) return true;
+  if (Ty->isPrimitiveType() || Ty->isIntegerTy()) 
+    return true;
 
   // Nuke all pointers to primitive types as well...
-  if (const PointerType *PT = dyn_cast<PointerType>(E.second))
-    if (PT->getElementType()->isPrimitiveType()) return true;
+  if (const PointerType *PT = dyn_cast<PointerType>(Ty))
+    if (PT->getElementType()->isPrimitiveType() ||
+        PT->getElementType()->isIntegerTy()) 
+      return true;
 
   return false;
 }
@@ -59,44 +74,33 @@ static inline bool ShouldNukeSymtabEntry(const std::pair<std::string,Value*>&E){
 // 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;
 
-  if (SymbolTable *ST = M.getSymbolTable()) {
-    const std::set<const Type *> &UsedTypes =
-      getAnalysis<FindUsedTypes>().getTypes();
+  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::iterator STI = ST->find(Type::TypeTy);
-    if (STI != ST->end()) {
-      // Loop over all entries in the type plane...
-      SymbolTable::VarMap &Plane = STI->second;
-      for (SymbolTable::VarMap::iterator PI = Plane.begin(); PI != Plane.end();)
-        if (ShouldNukeSymtabEntry(*PI)) {    // Should we remove this entry?
-#if MAP_IS_NOT_BRAINDEAD
-          PI = Plane.erase(PI);     // STD C++ Map should support this!
-#else
-          Plane.erase(PI);          // Alas, GCC 2.95.3 doesn't  *SIGH*
-          PI = Plane.begin();
-#endif
-          ++NumKilled;
-          Changed = true;
-        } else if (!UsedTypes.count(cast<Type>(PI->second))) {
-#if MAP_IS_NOT_BRAINDEAD
-          PI = Plane.erase(PI);     // STD C++ Map should support this!
-#else
-          Plane.erase(PI);          // Alas, GCC 2.95.3 doesn't  *SIGH*
-          PI = Plane.begin();       // N^2 algorithms are fun.  :(
-#endif
-          ++NumKilled;
-          Changed = true;
-        } else {
-          ++PI;
-        }
+  // Check the symbol table for superfluous type entries...
+  //
+  // Grab the 'type' plane of the module symbol...
+  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)) {
+      ST.remove(TI++);
+      ++NumKilled;
+      Changed = true;
+    } else {
+      ++TI;
+      // We only need to leave one name for each type.
+      UsedTypes.erase(RHS);
     }
   }
 
   return Changed;
 }
+
+// vim: sw=2