MEGAPATCH checkin.

[oota-llvm.git] / lib / Analysis / IPA / FindUnsafePointerTypes.cpp

diff --git a/lib/Analysis/IPA/FindUnsafePointerTypes.cpp b/lib/Analysis/IPA/FindUnsafePointerTypes.cpp
index 85b5da8ce2ef936911d1d614649302156d8b9a3e..8cad60d1787f55d8d2c20edc571384cfd0024b75 100644 (file)
--- a/lib/Analysis/IPA/FindUnsafePointerTypes.cpp
+++ b/lib/Analysis/IPA/FindUnsafePointerTypes.cpp
@@ -1,4 +1,4 @@
-//===- SafePointerAccess.cpp - Check pointer usage safety -------------------=//
+//===- FindUnsafePointerTypes.cpp - Check pointer usage safety --------------=//
 //
 // This file defines a pass that can be used to determine, interprocedurally, 
 // which pointer types are accessed unsafely in a program.  If there is an
@@ -19,8 +19,12 @@
 #include "llvm/Analysis/FindUnsafePointerTypes.h"
 #include "llvm/Assembly/CachedWriter.h"
 #include "llvm/Type.h"
+#include "llvm/Module.h"
+#include "llvm/Support/InstIterator.h"
 #include "Support/CommandLine.h"
 
+AnalysisID FindUnsafePointerTypes::ID(AnalysisID::create<FindUnsafePointerTypes>());
+
 // Provide a command line option to turn on printing of which instructions cause
 // a type to become invalid
 //
@@ -45,26 +49,23 @@ static inline bool isSafeInstruction(const Instruction *I) {
 }
 
 
-// runOnMethod - Inspect the operations that the specified method does on
-// values of various types.  If they are deemed to be 'unsafe' note that the
-// type is not safe to transform.
-//
-bool FindUnsafePointerTypes::runOnMethod(Method *Meth) {
-  const Method *M = Meth;  // We don't need/want write access
-  for (Method::const_inst_iterator I = M->inst_begin(), E = M->inst_end();
-       I != E; ++I) {
-    const Instruction *Inst = *I;
-    const Type *ITy = Inst->getType();
-    if (ITy->isPointerType() && !UnsafeTypes.count((PointerType*)ITy))
-      if (!isSafeInstruction(Inst)) {
-        UnsafeTypes.insert((PointerType*)ITy);
+bool FindUnsafePointerTypes::run(Module &Mod) {
+  for (Module::iterator FI = Mod.begin(), E = Mod.end();
+       FI != E; ++FI) {
+    const Function *F = FI;  // We don't need/want write access
+    for (const_inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I) {
+      const Type *ITy = I->getType();
+      if (isa<PointerType>(ITy) && !UnsafeTypes.count((PointerType*)ITy))
+        if (!isSafeInstruction(*I)) {
+          UnsafeTypes.insert((PointerType*)ITy);
 
-        if (PrintFailures) {
-          CachedWriter CW(M->getParent(), std::cerr);
-          CW << "FindUnsafePointerTypes: Type '" << ITy
-             << "' marked unsafe in '" << Meth->getName() << "' by:\n" << Inst;
+          if (PrintFailures) {
+            CachedWriter CW(F->getParent(), std::cerr);
+            CW << "FindUnsafePointerTypes: Type '" << ITy
+               << "' marked unsafe in '" << F->getName() << "' by:\n" << **I;
+          }
         }
-      }
+    }
   }
 
   return false;
@@ -74,7 +75,8 @@ bool FindUnsafePointerTypes::runOnMethod(Method *Meth) {
 // printResults - Loop over the results of the analysis, printing out unsafe
 // types.
 //
-void FindUnsafePointerTypes::printResults(const Module *M, std::ostream &o) {
+void FindUnsafePointerTypes::printResults(const Module *M,
+                                          std::ostream &o) const {
   if (UnsafeTypes.empty()) {
     o << "SafePointerAccess Analysis: No unsafe types found!\n";
     return;