lib/Analysis/IPA/FindUnsafePointerTypes.cpp

   1 //===- FindUnsafePointerTypes.cpp - Check pointer usage safety ------------===//
   2 //
   3 // This file defines a pass that can be used to determine, interprocedurally,
   4 // which pointer types are accessed unsafely in a program.  If there is an
   5 // "unsafe" access to a specific pointer type, transformations that depend on
   6 // type safety cannot be permitted.
   7 //
   8 // The result of running this analysis over a program is a set of unsafe pointer
   9 // types that cannot be transformed.  Safe pointer types are not tracked.
  10 //
  11 // Additionally, this analysis exports a hidden command line argument that (when
  12 // enabled) prints out the reasons a type was determined to be unsafe.
  13 //
  14 // Currently, the only allowed operations on pointer types are:
  15 //   alloca, malloc, free, getelementptr, load, and store
  16 //
  17 //===----------------------------------------------------------------------===//
  18
  19 #include "llvm/Analysis/FindUnsafePointerTypes.h"
  20 #include "llvm/Assembly/CachedWriter.h"
  21 #include "llvm/Type.h"
  22 #include "llvm/Module.h"
  23 #include "llvm/Support/InstIterator.h"
  24 #include "Support/CommandLine.h"
  25
  26 static RegisterAnalysis<FindUnsafePointerTypes>
  27 X("unsafepointertypes", "Find Unsafe Pointer Types");
  28
  29 // Provide a command line option to turn on printing of which instructions cause
  30 // a type to become invalid
  31 //
  32 static cl::opt<bool>
  33 PrintFailures("printunsafeptrinst", cl::Hidden,
  34               cl::desc("Print Unsafe Pointer Access Instructions"));
  35
  36 static inline bool isSafeInstruction(const Instruction *I) {
  37   switch (I->getOpcode()) {
  38   case Instruction::Alloca:
  39   case Instruction::Malloc:
  40   case Instruction::Free:
  41   case Instruction::Load:
  42   case Instruction::Store:
  43   case Instruction::GetElementPtr:
  44   case Instruction::Call:
  45   case Instruction::Invoke:
  46   case Instruction::PHI:
  47     return true;
  48   }
  49   return false;
  50 }
  51
  52
  53 bool FindUnsafePointerTypes::run(Module &Mod) {
  54   for (Module::iterator FI = Mod.begin(), E = Mod.end();
  55        FI != E; ++FI) {
  56     const Function *F = FI;  // We don't need/want write access
  57     for (const_inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I) {
  58       const Type *ITy = I->getType();
  59       if (isa<PointerType>(ITy) && !UnsafeTypes.count((PointerType*)ITy))
  60         if (!isSafeInstruction(*I)) {
  61           UnsafeTypes.insert((PointerType*)ITy);
  62
  63           if (PrintFailures) {
  64             CachedWriter CW(F->getParent(), std::cerr);
  65             CW << "FindUnsafePointerTypes: Type '" << ITy
  66                << "' marked unsafe in '" << F->getName() << "' by:\n" << **I;
  67           }
  68         }
  69     }
  70   }
  71
  72   return false;
  73 }
  74
  75
  76 // printResults - Loop over the results of the analysis, printing out unsafe
  77 // types.
  78 //
  79 void FindUnsafePointerTypes::print(std::ostream &o, const Module *M) const {
  80   if (UnsafeTypes.empty()) {
  81     o << "SafePointerAccess Analysis: No unsafe types found!\n";
  82     return;
  83   }
  84
  85   CachedWriter CW(M, o);
  86
  87   CW << "SafePointerAccess Analysis: Found these unsafe types:\n";
  88   unsigned Counter = 1;
  89   for (std::set<PointerType*>::const_iterator I = getUnsafeTypes().begin(),
  90          E = getUnsafeTypes().end(); I != E; ++I, ++Counter) {
  91
  92     CW << " #" << Counter << ". " << (Value*)*I << "\n";
  93   }
  94 }