Fix Transforms/DeadArgElim/2007-02-07-FuncRename.ll, fallout from PR411.

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

diff --git a/lib/Transforms/IPO/DeadTypeElimination.cpp b/lib/Transforms/IPO/DeadTypeElimination.cpp
index 9fd912a1adc9461dc289795f6fdcb1bea0bd023e..a72a48cc635f18ad81ee8f68fa2d31819fbf7110 100644 (file)
--- a/lib/Transforms/IPO/DeadTypeElimination.cpp
+++ b/lib/Transforms/IPO/DeadTypeElimination.cpp
@@ -1,67 +1,102 @@
-//===- CleanupGCCOutput.cpp - Cleanup GCC Output ----------------------------=//
+//===- DeadTypeElimination.cpp - Eliminate unused types for symbol table --===//
 //
-// This pass is used to cleanup the output of GCC.  GCC's output is
-// unneccessarily gross for a couple of reasons. This pass does the following
-// things to try to clean it up:
+//                     The LLVM Compiler Infrastructure
 //
-// Note:  This code produces dead declarations, it is a good idea to run DCE
-//        after this pass.
+// 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
+// that are unused in the entire translation unit, using the FindUsedTypes pass.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Transforms/CleanupGCCOutput.h"
-#include "llvm/SymbolTable.h"
+#define DEBUG_TYPE "deadtypeelim"
+#include "llvm/Transforms/IPO.h"
+#include "llvm/Analysis/FindUsedTypes.h"
+#include "llvm/Module.h"
+#include "llvm/TypeSymbolTable.h"
+#include "llvm/DerivedTypes.h"
+#include "llvm/ADT/Statistic.h"
+#include "llvm/Support/Compiler.h"
+using namespace llvm;
 
-static inline bool ShouldNukeSymtabEntry(const pair<string, Value*> &E) {
-  // Nuke all names for primitive types!
-  if (cast<Type>(E.second)->isPrimitiveType()) return true;
+STATISTIC(NumKilled, "Number of unused typenames removed from symtab");
 
-  // The only types that could contain .'s in the program are things generated
-  // by GCC itself, including "complex.float" and friends.  Nuke them too.
-  if (E.first.find('.') != string::npos) return true;
+namespace {
+  struct VISIBILITY_HIDDEN DTE : public ModulePass {
+    // 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 runOnModule(Module &M);
 
-  return false;
+    // getAnalysisUsage - This function needs FindUsedTypes to do its job...
+    //
+    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+      AU.addRequired<FindUsedTypes>();
+    }
+  };
+  RegisterPass<DTE> X("deadtypeelim", "Dead Type Elimination");
+}
+
+ModulePass *llvm::createDeadTypeEliminationPass() {
+  return new DTE();
 }
 
 
-// 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.
+// ShouldNukeSymtabEntry - Return true if this module level symbol table entry
+// should be eliminated.
 //
-bool CleanupGCCOutput::doPassInitialization(Module *M) {
-  bool Changed = false;
+static inline bool ShouldNukeSymtabEntry(const Type *Ty){
+  // Nuke all names for primitive types!
+  if (Ty->isPrimitiveType() || Ty->isInteger()) 
+    return true;
 
-  if (M->hasSymbolTable()) {
-    // Grab the type plane of the module...
-    SymbolTable *ST = M->getSymbolTable();
-    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
-          Changed = true;
-        } else {
-          ++PI;
-        }
-    }
-    
-  }
+  // Nuke all pointers to primitive types as well...
+  if (const PointerType *PT = dyn_cast<PointerType>(Ty))
+    if (PT->getElementType()->isPrimitiveType() ||
+        PT->getElementType()->isInteger()) 
+      return true;
 
-  return Changed;
+  return false;
 }
 
-
-// doPerMethodWork - This method simplifies the specified method hopefully.
+// run - 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 eliminate types that are never used
+// in the entire program as indicated by FindUsedTypes.
 //
-bool CleanupGCCOutput::doPerMethodWork(Method *M) {
+bool DTE::runOnModule(Module &M) {
   bool Changed = false;
 
+  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...
+  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