Add support for variable argument functions!

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

diff --git a/lib/Analysis/IPA/FindUnsafePointerTypes.cpp b/lib/Analysis/IPA/FindUnsafePointerTypes.cpp
index bc092920907e1ddfef89a2e907f936ff999e9e47..5d9745cd7a4778142ef9ecab90f3743c69919fb5 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,19 +19,19 @@
 #include "llvm/Analysis/FindUnsafePointerTypes.h"
 #include "llvm/Assembly/CachedWriter.h"
 #include "llvm/Type.h"
-#include "llvm/Instruction.h"
-#include "llvm/Method.h"
 #include "llvm/Module.h"
+#include "llvm/Support/InstIterator.h"
 #include "Support/CommandLine.h"
 
-AnalysisID FindUnsafePointerTypes::ID(AnalysisID::create<FindUnsafePointerTypes>());
+static RegisterAnalysis<FindUnsafePointerTypes>
+X("unsafepointertypes", "Find Unsafe Pointer Types");
 
 // Provide a command line option to turn on printing of which instructions cause
 // a type to become invalid
 //
-static cl::Flag 
-PrintFailures("printunsafeptrinst", "Print Unsafe Pointer Access Instructions",
-              cl::Hidden, false);
+static cl::opt<bool> 
+PrintFailures("printunsafeptrinst", cl::Hidden,
+              cl::desc("Print Unsafe Pointer Access Instructions"));
 
 static inline bool isSafeInstruction(const Instruction *I) {
   switch (I->getOpcode()) {
@@ -50,26 +50,20 @@ 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::run(Module *Mod) {
-  for (Module::iterator MI = Mod->begin(), ME = Mod->end();
-       MI != ME; ++MI) {
-    const Method *M = *MI;  // 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)) {
+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);
+            CachedWriter CW(F->getParent(), std::cerr);
             CW << "FindUnsafePointerTypes: Type '" << ITy
-               << "' marked unsafe in '" << M->getName() << "' by:\n" << Inst;
+               << "' marked unsafe in '" << F->getName() << "' by:\n" << **I;
           }
         }
     }
@@ -82,8 +76,7 @@ bool FindUnsafePointerTypes::run(Module *Mod) {
 // printResults - Loop over the results of the analysis, printing out unsafe
 // types.
 //
-void FindUnsafePointerTypes::printResults(const Module *M,
-                                          std::ostream &o) const {
+void FindUnsafePointerTypes::print(std::ostream &o, const Module *M) const {
   if (UnsafeTypes.empty()) {
     o << "SafePointerAccess Analysis: No unsafe types found!\n";
     return;
@@ -99,11 +92,3 @@ void FindUnsafePointerTypes::printResults(const Module *M,
     CW << " #" << Counter << ". " << (Value*)*I << "\n";
   }
 }
-
-// getAnalysisUsageInfo - Of course, we provide ourself...
-//
-void FindUnsafePointerTypes::getAnalysisUsageInfo(Pass::AnalysisSet &Required,
-                                                  Pass::AnalysisSet &Destroyed,
-                                                  Pass::AnalysisSet &Provided) {
-  Provided.push_back(FindUnsafePointerTypes::ID);
-}