FIx poolalloc compilation with trunk llvm

[matekm]

Summary

Poolalloc isn't compiling with trunk version of LLVM and I need it to compile SAFECode.

This patch align code of the poolalloc, so it compile with current trunk version. Most of the changes are cosmetic ones:

• remove DataStructureCallGraph - as it was not used by poolalloc and SAFECode
• changing include statements to properly include various LLVM headers
• changing name of various analysis passes
• changing calls to methods returning user iterators

[kevinstreit]

LGTM
Verified against LLVM and poolalloc trunk. Note though that I am just a user of this as well and I do not have any commit rights.

[matekm]

Do You know who would be best to push this code to trunk?

[dtzWill]

Great start, thanks!

Missing a number of use_{begin,end} => user_{begin,end} updates that until fixed cause many lit test failures.

On that, the lit cfg files need updating, I'll commit all this shortly.

[dtzWill]

Should be good to go now, let me know if you have any further issues!

Thanks for putting this together! :)

Apologies for not submitting through phabricator, never used it before. Does this need to be 'closed' now?

[matekm]

Done and commited -r206408!

include/assistDS/DataStructureCallGraph.h

-//===- DataStructureCallGraph.h - Provide a CallGraph using DSA -----------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file declares the DataStructureCallGraph implementation of the
-// CallGraph analysis. Based on llvm/lib/Analysis/IPA/CallGraph.cpp.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _DATA_STRUCTURE_CALLGRAPH_H
-#define _DATA_STRUCTURE_CALLGRAPH_H
-
-#include "dsa/CallTargets.h"
-#include "dsa/DataStructure.h"
-
-#include "llvm/IR/Module.h"
-#include "llvm/Analysis/CallGraph.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/raw_ostream.h"
-
-namespace llvm {
-
-class DataStructureCallGraph : public ModulePass, public CallGraph {
-  // Root is root of the call graph, or the external node if a 'main' function
-  // couldn't be found.
-  CallGraphNode *Root;
-
-  // ExternalCallingNode - This node has edges to all external functions and
-  // those internal functions that have their address taken.
-  CallGraphNode *ExternalCallingNode;
-
-  // CallsExternalNode - This node has edges to it from all functions making
-  // indirect calls or calling an external function.
-  CallGraphNode *CallsExternalNode;
-
-  typedef dsa::CallTargetFinder<TDDataStructures> CallTargetFinderTy;
-
-public:
-  static char ID;
-  DataStructureCallGraph() :
-    ModulePass(ID), Root(0), ExternalCallingNode(0), CallsExternalNode(0) { }
-
-  virtual bool runOnModule(Module &M);
-
-  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
-    AU.addRequired<TDDataStructures>();
-    AU.addRequired<CallTargetFinderTy>();
-    AU.setPreservesAll();
-  }
-
-  virtual void print(raw_ostream &OS, const Module *) const {
-    OS << "CallGraph Root is: ";
-    if (Function *F = getRoot()->getFunction())
-      OS << F->getName() << "\n";
-    else {
-      OS << "<<null function: 0x" << getRoot() << ">>\n";
-    }
-    
-    CallGraph::print(OS, 0);
-  }
-
-  virtual void releaseMemory() {
-    destroy();
-  }
-  
-  // getAdjustedAnalysisPointer - This method is used when a pass implements an
-  // analysis interface through multiple inheritance. If needed, it should
-  // override this to adjust the this pointer as needed for the specified pass
-  // info.
-  virtual void *getAdjustedAnalysisPointer(AnalysisID PI) {
-    if (PI == &CallGraph::ID)
-      return (CallGraph*)this;
-    return this;
-  }
-  
-  CallGraphNode* getExternalCallingNode() const { return ExternalCallingNode; }
-  CallGraphNode* getCallsExternalNode()   const { return CallsExternalNode; }
-
-  // getRoot - Return the root of the call graph, which is either main, or if
-  // main cannot be found, the external node.
-  CallGraphNode *getRoot()             { return Root; }
-  const CallGraphNode *getRoot() const { return Root; }
-
-private:
-  // addToCallGraph - Add a function to the call graph, and link the node to all
-  // of the functions that it calls.
-  void addToCallGraph(Function *F);
-
-  // destroy - Release memory for the call graph
-  virtual void destroy() {
-    // CallsExternalNode is not in the function map, delete it explicitly.
-    if (CallsExternalNode) {
-      CallsExternalNode->allReferencesDropped();
-      delete CallsExternalNode;
-      CallsExternalNode = 0;
-    }
-    CallGraph::destroy();
-  }
-};
-
-}
-
-#endif // _DATA_STRUCTURE_CALLGRAPH_H

include/assistDS/Devirt.h

 #include "llvm/IR/Function.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/DerivedTypes.h"
-#include "llvm/InstVisitor.h"
+#include "llvm/IR/InstVisitor.h"
 #include "llvm/IR/DataLayout.h"
 
 using namespace llvm;

       dsa::CallTargetFinder<EQTDDataStructures> *CTF;
 
       // Access to the target data analysis pass
-      DataLayout * TD;
+      const DataLayout * TD;
 
       // Worklist of call sites to transform
       std::vector<Instruction *> Worklist;

 
       virtual void getAnalysisUsage(AnalysisUsage &AU) const {
         AU.addRequired<dsa::CallTargetFinder<EQTDDataStructures> >();
-        AU.addRequired<DataLayout>();
+        AU.addRequired<DataLayoutPass>();
       }
 
       // Visitor methods for analyzing instructions

include/assistDS/Int2PtrCmp.h

   //
   class Int2PtrCmp : public ModulePass {
   private:
-    DataLayout * TD;
+    const DataLayout * TD;
   public:
     static char ID;
     Int2PtrCmp() : ModulePass(ID) {}
     virtual bool runOnModule(Module& M);
     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
-      AU.addRequired<DataLayout>();
+      AU.addRequired<DataLayoutPass>();
     }
 
   };

include/assistDS/SimplifyGEP.h

   //
   class SimplifyGEP : public ModulePass {
   private:
-    DataLayout * TD;
+    const DataLayout * TD;
   public:
     static char ID;
     SimplifyGEP() : ModulePass(ID) {}
     virtual bool runOnModule(Module& M);
     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
-      AU.addRequired<DataLayout>();
+      AU.addRequired<DataLayoutPass>();
     }
   };
 }

include/assistDS/TypeChecks.h

 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Function.h"
 #include "llvm/Pass.h"
-#include "llvm/Support/CallSite.h"
-#include "llvm/Analysis/Dominators.h"
+#include "llvm/IR/CallSite.h"
+#include "llvm/IR/Dominators.h"
 #include "llvm/Analysis/LoopInfo.h"
 
 #include <map>

   std::map<BitCastInst*, Instruction*> BitCast_MD_Map;
 
   // Analysis from other passes.
-  DataLayout *TD;
+  const DataLayout *TD;
   AddressTakenAnalysis* addrAnalysis;
   
   unsigned int getTypeMarker(Type*);

   virtual void print(raw_ostream &OS, const Module *M) const;
 
   virtual void getAnalysisUsage(AnalysisUsage &AU) const {
-    AU.addRequired<DataLayout>();
-    AU.addRequired<DominatorTree>();
+    AU.addRequired<DataLayoutPass>();
+    AU.addRequired<DominatorTreeWrapperPass>();
     AU.addRequired<LoopInfo>();
     AU.addRequired<AddressTakenAnalysis>();
   }

include/assistDS/TypeChecksOpt.h

 #include "llvm/Pass.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Instructions.h"
-#include "llvm/Support/CallSite.h"
+#include "llvm/IR/CallSite.h"
 
 #include <list>
 

include/dsa/CallTargets.h

 #define LLVM_ANALYSIS_CALLTARGETS_H
 
 #include "llvm/Pass.h"
-#include "llvm/Support/CallSite.h"
+#include "llvm/IR/CallSite.h"
 #include "dsa/DataStructure.h"
 
 #include <set>

include/dsa/DSCallGraph.h

 
 #include <cstddef>
 #include "llvm/ADT/EquivalenceClasses.h"
-#include "llvm/Support/CallSite.h"
+#include "llvm/IR/CallSite.h"
 
 #include <cassert>
 #include <map>

include/dsa/DSSupport.h

 #include <set>
 
 #include "llvm/ADT/DenseSet.h"
-#include "llvm/Support/CallSite.h"
+#include "llvm/IR/CallSite.h"
 
 namespace llvm {
 

include/dsa/DataStructure.h

 
 #include "llvm/Pass.h"
 #include "llvm/IR/DataLayout.h"
-#include "llvm/Support/CallSite.h"
+#include "llvm/IR/CallSite.h"
 #include "llvm/ADT/EquivalenceClasses.h"
 #include "llvm/ADT/DenseSet.h"
 

   typedef std::map<const Function*, DSGraph*> DSInfoTy;
 
   /// DataLayout, comes in handy
-  DataLayout* TD;
+  const DataLayout* TD;
 
   /// Pass to get Graphs from
   DataStructures* GraphSource;

   std::vector<const Function*> GlobalFunctionList; 
 
   void init(DataStructures* D, bool clone, bool useAuxCalls, bool copyGlobalAuxCalls, bool resetAux);
-  void init(DataLayout* T);
+  void init(const DataLayout* T);
 
   void formGlobalECs();
   

 
   EquivalenceClasses<const GlobalValue*> &getGlobalECs() { return GlobalECs; }
 
-  DataLayout& getDataLayout() const { return *TD; }
+  const DataLayout& getDataLayout() const { return *TD; }
 
   const DSCallGraph& getCallGraph() const { return callgraph; }
 

   /// getAnalysisUsage - This obviously provides a data structure graph.
   ///
   virtual void getAnalysisUsage(AnalysisUsage &AU) const {
-    AU.addRequired<DataLayout>();
+    AU.addRequired<DataLayoutPass>();
     AU.setPreservesAll();
   }
 };

   /// getAnalysisUsage - This obviously provides a data structure graph.
   ///
   virtual void getAnalysisUsage(AnalysisUsage &AU) const {
-    AU.addRequired<DataLayout>();
+    AU.addRequired<DataLayoutPass>();
     AU.addRequired<AddressTakenAnalysis>();
     AU.setPreservesAll();
   }

include/dsa/TypeSafety.h

     bool typeFieldsOverlap (const DSNode * N);
 
     // Pointers to prerequisite passes
-    DataLayout * TD;
+    const DataLayout * TD;
     dsa * dsaPass;
 
     // Data structures

     }
 
     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
-      AU.addRequired<DataLayout>();
+      AU.addRequired<DataLayoutPass>();
       AU.addRequired<dsa>();
       AU.setPreservesAll();
     }

include/poolalloc/PoolAllocate.h

 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/Pass.h"
-#include "llvm/Support/CallSite.h"
+#include "llvm/IR/CallSite.h"
 #include "llvm/ADT/EquivalenceClasses.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"

   bool runOnModule(Module &M);
   GlobalVariable *CreateGlobalPool(unsigned RecSize, unsigned Align,
                                    Module& M);
-  void ProcessFunctionBodySimple(Function& F, DataLayout & TD);
+  void ProcessFunctionBodySimple(Function& F, const DataLayout & TD);
 
 
   virtual DSGraph* getDSGraph (const Function & F) const {

 
 // FIXME: Is this used?  Should it be removed?
 class PoolAllocateMultipleGlobalPool : public PoolAllocate {
-  void ProcessFunctionBodySimple(Function& F, DataLayout & TD);
+  void ProcessFunctionBodySimple(Function& F, const DataLayout & TD);
   /// Mapping between DSNodes and Pool descriptors. For this pass, it is a
   /// one-to-one relationship.
   typedef DenseMap<const DSNode *, GlobalVariable *> PoolMapTy;

include/poolalloc/RunTimeAssociate.h

 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/Pass.h"
-#include "llvm/Support/CallSite.h"
+#include "llvm/IR/CallSite.h"
 #include "llvm/ADT/EquivalenceClasses.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/CommandLine.h"

include/rdsa/CallTargets.h

 #define LLVM_ANALYSIS_CALLTARGETS_H
 
 #include "llvm/Pass.h"
-#include "llvm/Support/CallSite.h"
+#include "llvm/IR/CallSite.h"
 
 #include <set>
 #include <list>

include/rdsa/DSSupport.h

 #define LLVM_ANALYSIS_DSSUPPORT_H
 
 #include <functional>
-#include "llvm/Support/CallSite.h"
+#include "llvm/IR/CallSite.h"
 #include "poolalloc/ADT/HashExtras.h"
 
 namespace llvm {

include/rdsa/DataStructure.h

 
 #include "llvm/Pass.h"
 #include "llvm/DataLayout.h"
-#include "llvm/Support/CallSite.h"
+#include "llvm/IR/CallSite.h"
 #include "llvm/ADT/EquivalenceClasses.h"
 
 #include "poolalloc/ADT/HashExtras.h"

   /// getAnalysisUsage - This obviously provides a data structure graph.
   ///
   virtual void getAnalysisUsage(AnalysisUsage &AU) const {
-    AU.addRequired<DataLayout>();
+    AU.addRequired<DataLayoutPass>();
     AU.setPreservesAll();
   }
 };

   virtual void releaseMemory();
 
   virtual void getAnalysisUsage(AnalysisUsage &AU) const {
-    AU.addRequired<DataLayout>();
+    AU.addRequired<DataLayoutPass>();
     AU.addRequired<StdLibDataStructures>();
     AU.setPreservesAll();
   }

lib/AssistDS/CMakeLists.txt

   ArgCast.cpp
   ArgSimplify.cpp
   DSNodeEquivs.cpp
-  DataStructureCallGraph.cpp
   Devirt.cpp
   DynCount.cpp
   FuncSimplify.cpp

lib/AssistDS/DSNodeEquivs.cpp

 
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Module.h"
-#include "llvm/Support/InstIterator.h"
+#include "llvm/IR/InstIterator.h"
 #include "llvm/ADT/SmallSet.h"
 
 #include <deque>

     std::deque<const User *> WL;
     SmallSet<const User *, 8> Visited;
 
-    WL.insert(WL.end(), V->use_begin(), V->use_end());
+    WL.insert(WL.end(), V->user_begin(), V->user_end());
     do {
       const User *TheUser = WL.front();
       WL.pop_front();

         //
         // If this use is of some other nature, look at the users of this use.
         //
-        WL.insert(WL.end(), TheUser->use_begin(), TheUser->use_end());
+        WL.insert(WL.end(), TheUser->user_begin(), TheUser->user_end());
       }
     } while (!WL.empty());
   }

lib/AssistDS/DataStructureCallGraph.cpp

-//===- DataStructureCallGraph.cpp - Provide a CallGraph using DSA ---------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains the DataStructureCallGraph implementation of the
-// CallGraph analysis. Based on llvm/lib/Analysis/IPA/CallGraph.cpp.
-//
-//===----------------------------------------------------------------------===//
-
-#include "assistDS/DataStructureCallGraph.h"
-#include "dsa/DSGraph.h"
-#include "dsa/DSNode.h"
-
-#include "llvm/ADT/SmallPtrSet.h"
-#include "llvm/IR/Instructions.h"
-#include "llvm/IR/IntrinsicInst.h"
-#include "llvm/Support/CallSite.h"
-#include "llvm/Support/InstIterator.h"
-
-using namespace llvm;
-
-char DataStructureCallGraph::ID;
-
-namespace {
-
-static RegisterPass<DataStructureCallGraph>
-X("dsa-cg", "DSA-based CallGraph implementation");
-
-RegisterAnalysisGroup<CallGraph> Y(X); 
-
-}
-
-bool DataStructureCallGraph::runOnModule(Module &M) {
-  CallGraph::initialize(M);
-
-  ExternalCallingNode = getOrInsertFunction(0);
-  CallsExternalNode = new CallGraphNode(0);
-  Root = 0;
-
-  // Add every function to the call graph.
-  for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
-    addToCallGraph(I);
-
-  // If we didn't find a main function, use the external call graph node
-  if (Root == 0) Root = ExternalCallingNode;
-  
-  return false;
-}
-
-// Add a function to the call graph, and link the node to all of the functions
-// that it calls.
-void DataStructureCallGraph::addToCallGraph(Function *F) {
-  CallGraphNode *Node = getOrInsertFunction(F);
-
-  if (!F->hasLocalLinkage()) {
-    ExternalCallingNode->addCalledFunction(CallSite(), Node);
-
-    // Found the entry point?
-    if (F->getName() == "main") {
-      if (Root)    // Found multiple external mains?  Don't pick one.
-        Root = ExternalCallingNode;
-      else
-        Root = Node; // Found a main, keep track of it!
-    }
-  }
-
-  // If this function is not defined in this translation unit, it could call
-  // anything.
-  if (F->isDeclaration() && !F->isIntrinsic()) {
-    Node->addCalledFunction(CallSite(), CallsExternalNode);
-    return;
-  }
-
-  TDDataStructures &DS = getAnalysis<TDDataStructures>();
-  DSGraph &GG = *DS.getGlobalsGraph();
-  CallTargetFinderTy &CTF = getAnalysis<CallTargetFinderTy>();
-
-  // Determine if the function can be called by external code by looking up
-  // its DSNode in the globals graph. A node marked External, Unknown, or
-  // Incomplete has the possibility of being called from external code.
-  DSNode *N = GG.getNodeForValue(F).getNode();
-
-  if (N &&
-      (N->isExternalNode() ||
-       N->isUnknownNode() ||
-       N->isIncompleteNode())) {
-    ExternalCallingNode->addCalledFunction(CallSite(), Node);
-  }
-
-  // Go over the instructions in the function and determine the call targets
-  // for each call site.
-  for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I) {
-    CallSite CS(&*I);
-
-    // Only look through valid call sites that are not calls to intrinsics.
-    if (!CS || isa<IntrinsicInst>(&*I))
-      continue;
-
-    if (const Function *F = 
-        dyn_cast<Function>(CS.getCalledValue()->stripPointerCasts())) {
-      // Direct call: Don't use DSA, just add the function we discovered as
-      // the call target.
-
-      Node->addCalledFunction(CS, getOrInsertFunction(F));
-    } else {
-      // Indirect call: Use CallTargetFinder to determine the set of targets to
-      // the indirect call site. Be conservative about incomplete call sites.
-
-      if (!CTF.isComplete(CS)) {
-        // Add CallsExternalNode as a target of incomplete call sites.
-        Node->addCalledFunction(CS, CallsExternalNode);
-      }
-
-      SmallPtrSet<const Function *, 16> Targets(CTF.begin(CS), CTF.end(CS));
-
-      for (SmallPtrSet<const Function *, 16>::const_iterator
-           TI = Targets.begin(), TE = Targets.end(); TI != TE; ++TI) {
-        Node->addCalledFunction(CS, getOrInsertFunction(*TI));
-      }
-    }
-  }
-}

lib/AssistDS/Devirt.cpp

   // Get information on the target system.
   //
   //
-  TD = &getAnalysis<DataLayout>();
+  TD = &getAnalysis<DataLayoutPass>().getDataLayout();
 
   // Visit all of the call instructions in this function and record those that
   // are indirect function calls.

lib/AssistDS/DynCount.cpp

   }
   virtual bool runOnModule (Module & M);
   virtual void getAnalysisUsage(AnalysisUsage &AU) const {
-    AU.addRequired<DataLayout>();
+    AU.addRequired<DataLayoutPass>();
     AU.addRequired<dsa::TypeSafety<TDDataStructures> >();
   }
 };

lib/AssistDS/FuncSpec.cpp

         } 
       }
       // Now find all call sites that it is called from
-      for(Value::use_iterator ui = I->use_begin(), ue = I->use_end();
+      for(Value::user_iterator ui = I->user_begin(), ue = I->user_end();
           ui != ue; ++ui) {
         if (CallInst* CI = dyn_cast<CallInst>(*ui)) {
           // Check that it is the called value (and not an argument)

lib/AssistDS/GEPExprArgs.cpp

 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/Use.h"
-#include "llvm/Support/GetElementPtrTypeIterator.h"
+#include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/ADT/Statistic.h"
-#include "llvm/ADT/ValueMap.h"
+#include "llvm/IR/ValueMap.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/Debug.h"
 #include <vector>

lib/AssistDS/IndCloner.cpp

     // function by the linker.
     //
     if (!I->isDeclaration() && !I->mayBeOverridden()) {
-      for (Value::use_iterator ui = I->use_begin(), ue = I->use_end();
+      for (Value::user_iterator ui = I->user_begin(), ue = I->user_end();
           ui != ue; ++ui) {
         if (!isa<CallInst>(*ui) && !isa<InvokeInst>(*ui)) {
           if(!ui->use_empty())

lib/AssistDS/Int2PtrCmp.cpp

 #include "llvm/ADT/Statistic.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/Debug.h"
-#include "llvm/Support/PatternMatch.h"
+#include "llvm/IR/PatternMatch.h"
 
 #include <set>
 #include <map>

 //  false - The module was not modified.
 //
 bool Int2PtrCmp::runOnModule(Module& M) {
-  TD = &getAnalysis<DataLayout>();
+  TD = &getAnalysis<DataLayoutPass>().getDataLayout();
   for (Module::iterator F = M.begin(); F != M.end(); ++F) {
     for (Function::iterator B = F->begin(), FE = F->end(); B != FE; ++B) {      
       for (BasicBlock::iterator I = B->begin(), BE = B->end(); I != BE;) {

lib/AssistDS/LoadArgs.cpp

 #include "assistDS/LoadArgs.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Use.h"
-#include "llvm/Support/GetElementPtrTypeIterator.h"
+#include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/ADT/Statistic.h"
-#include "llvm/ADT/ValueMap.h"
+#include "llvm/IR/ValueMap.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/Debug.h"
 #include <vector>

lib/AssistDS/MergeGEP.cpp

 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/Module.h"
-#include "llvm/Support/GetElementPtrTypeIterator.h"
+#include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Support/FormattedStream.h"

lib/AssistDS/SimplifyExtractValue.cpp

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/Debug.h"
-#include "llvm/Support/PatternMatch.h"
+#include "llvm/IR/PatternMatch.h"
 #include "llvm/IR/DataLayout.h"
 
 #include <set>

lib/AssistDS/SimplifyGEP.cpp

 #define DEBUG_TYPE "simplify-gep"
 
 #include "assistDS/SimplifyGEP.h"
-#include "llvm/Support/GetElementPtrTypeIterator.h"
+#include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/IR/Constants.h"

 //  false - The module was not modified.
 //
 bool SimplifyGEP::runOnModule(Module& M) {
-  TD = &getAnalysis<DataLayout>();
+  TD = &getAnalysis<DataLayoutPass>().getDataLayout();
   preprocess(M);
   for (Module::iterator F = M.begin(); F != M.end(); ++F){
     for (Function::iterator B = F->begin(), FE = F->end(); B != FE; ++B) {      

lib/AssistDS/SimplifyInsertValue.cpp

 #include "llvm/ADT/Statistic.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/Debug.h"
-#include "llvm/Support/PatternMatch.h"
+#include "llvm/IR/PatternMatch.h"
 #include "llvm/IR/DataLayout.h"
 
 #include <set>

lib/AssistDS/SimplifyLoad.cpp

 #include "llvm/ADT/Statistic.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/Debug.h"
-#include "llvm/Support/PatternMatch.h"
+#include "llvm/IR/PatternMatch.h"
 #include "llvm/IR/DataLayout.h"
 
 #include <set>

lib/AssistDS/StructReturnToPointer.cpp

 #include "llvm/IR/Attributes.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/ADT/Statistic.h"
-#include "llvm/ADT/ValueMap.h"
+#include "llvm/IR/ValueMap.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/Debug.h"
 

lib/AssistDS/TypeChecks.cpp

 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Module.h"
-#include "llvm/Assembly/Writer.h"
 #include "llvm/Support/Debug.h"
-#include "llvm/Support/InstIterator.h"
+#include "llvm/IR/InstIterator.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/Support/CommandLine.h"

   bool modified = false; // Flags whether we modified the module.
   bool transformIndirectCalls = true;
 
-  TD = &getAnalysis<DataLayout>();
+  TD = &getAnalysis<DataLayoutPass>().getDataLayout();
   addrAnalysis = &getAnalysis<AddressTakenAnalysis>();
 
   // Create the necessary prototypes

     Function &F = *MI;
     if(F.isDeclaration())
       continue;
-    DominatorTree & DT = getAnalysis<DominatorTree>(F);
+    DominatorTree & DT = getAnalysis<DominatorTreeWrapperPass>(F).getDomTree();
     std::deque<DomTreeNode *> Worklist;
     Worklist.push_back (DT.getRootNode());
     while(Worklist.size()) {

     Constant *CNew = ConstantExpr::getBitCast(FI->second, F->getType());
 
     std::set<User *> toReplace;
-    for(Function::use_iterator User = F->use_begin();
-        User != F->use_end();++User) {
+    for(Function::user_iterator User = F->user_begin();
+        User != F->user_end();++User) {
       toReplace.insert(*User);
     }
     for(std::set<llvm::User *>::iterator userI = toReplace.begin(); userI != toReplace.end(); ++userI) {

     Function &F = *MI;
     if(F.isDeclaration())
       continue;
-    DominatorTree & DT = getAnalysis<DominatorTree>(F);
+    DominatorTree & DT = getAnalysis<DominatorTreeWrapperPass>(F).getDomTree();
     std::deque<DomTreeNode *> Worklist;
     Worklist.push_back (DT.getRootNode());
     while(Worklist.size()) {

     Function &F = *MI;
     if(F.isDeclaration())
       continue;
-    DominatorTree & DT = getAnalysis<DominatorTree>(F);
+    DominatorTree & DT = getAnalysis<DominatorTreeWrapperPass>(F).getDomTree();
     LoopInfo & LI = getAnalysis<LoopInfo>(F);
     std::deque<DomTreeNode *> Worklist;
     Worklist.push_back (DT.getRootNode());

 // BCI - ptr
 // I - instruction whose uses to instrument
 bool TypeChecks::visitUses(Instruction *I, Instruction *AI, Value *BCI) {
-  for(Value::use_iterator II = I->use_begin(); II != I->use_end(); ++II) {
+  for(Value::user_iterator II = I->user_begin(); II != I->user_end(); ++II) {
     if(DisablePtrCmpChecks) {
       if(isa<CmpInst>(*II)) {
         if(I->getType()->isPointerTy())

lib/AssistDS/TypeChecksOpt.cpp

 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Module.h"
-#include "llvm/Assembly/Writer.h"
 #include "llvm/Support/Debug.h"
-#include "llvm/Support/InstIterator.h"
+#include "llvm/IR/InstIterator.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/Support/CommandLine.h"

lib/DSA/AddressTakenAnalysis.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm/Pass.h"
+#include "llvm/IR/CallSite.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Function.h"

 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/Debug.h"
-#include "llvm/Support/CallSite.h"
 
 #include <fstream>
 #include <set>

 
 static bool isAddressTaken(Value* V) {
   for (Value::use_iterator I = V->use_begin(), E = V->use_end(); I != E; ++I) {
-    User *U = *I;
+    User *U = I->getUser();
     if(isa<StoreInst>(U))
       return true;
     if (!isa<CallInst>(U) && !isa<InvokeInst>(U)) {

       // are never used
     } else {
       llvm::CallSite CS(cast<Instruction>(U));
-      if (!CS.isCallee(I))
+      if (!CS.isCallee(&(*I)))
         return true;
     }
   }

lib/DSA/Basic.cpp

 #include "dsa/DataStructure.h"
 #include "dsa/DSGraph.h"
 
-#include "llvm/InstVisitor.h"
+#include "llvm/IR/InstVisitor.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/TypeBuilder.h"
-#include "llvm/Support/InstIterator.h"
-#include "llvm/Support/GetElementPtrTypeIterator.h"
+#include "llvm/IR/InstIterator.h"
+#include "llvm/IR/GetElementPtrTypeIterator.h"
 
 using namespace llvm;
 

 char BasicDataStructures::ID = 0;
 
 bool BasicDataStructures::runOnModule(Module &M) {
-  init(&getAnalysis<DataLayout>());
+  init(&getAnalysis<DataLayoutPass>().getDataLayout());
 
   //
   // Create a void pointer type.  This is simply a pointer to an 8 bit value.

lib/DSA/DSGraph.cpp

 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/DataLayout.h"
-#include "llvm/Assembly/Writer.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/ADT/DepthFirstIterator.h"

lib/DSA/DSTest.cpp

 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/IR/ValueSymbolTable.h"
-#include "llvm/Assembly/Writer.h"
 using namespace llvm;
 
 namespace {

lib/DSA/DataStructure.cpp

 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/DataLayout.h"
-#include "llvm/Assembly/Writer.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/ADT/DepthFirstIterator.h"

   if (!clone) D->DSGraphsStolen = true;
 }
 
-void DataStructures::init(DataLayout* T) {
+void DataStructures::init(const DataLayout* T) {
   assert (!TD && "Already init");
   GraphSource = 0;
   Clone = false;

lib/DSA/DataStructureStats.cpp

 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Instructions.h"
-#include "llvm/InstVisitor.h"
+#include "llvm/IR/InstVisitor.h"
 #include "llvm/Pass.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Support/Debug.h"

     void getAnalysisUsage(AnalysisUsage &AU) const {
       AU.setPreservesAll();
       AU.addRequired<TDDataStructures>();
-      AU.addRequired<DataLayout>();
+      AU.addRequired<DataLayoutPass>();
       AU.addRequired<dsa::TypeSafety<TDDataStructures> >();
     }
 

 
 bool DSGraphStats::runOnFunction(Function& F) {
   DS = &getAnalysis<TDDataStructures>();
-  TD = &getAnalysis<DataLayout>();
+  TD = &getAnalysis<DataLayoutPass>().getDataLayout();
   TS = &getAnalysis<dsa::TypeSafety<TDDataStructures> >();
   TDGraph = DS->getDSGraph(F);
   countCallees(F);

lib/DSA/EquivClassGraphs.cpp

 #include "llvm/IR/Module.h"
 #include "llvm/Pass.h"
 #include "dsa/DSGraph.h"
-#include "llvm/Support/CallSite.h"
+#include "llvm/IR/CallSite.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/ADT/SCCIterator.h"
 #include "llvm/ADT/Statistic.h"

lib/DSA/Local.cpp

 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FormattedStream.h"
-#include "llvm/Support/GetElementPtrTypeIterator.h"
-#include "llvm/InstVisitor.h"
+#include "llvm/IR/GetElementPtrTypeIterator.h"
+#include "llvm/IR/InstVisitor.h"
 #include "llvm/Support/Timer.h"
 
 #include <fstream>

 char LocalDataStructures::ID;
 
 bool LocalDataStructures::runOnModule(Module &M) {
-  init(&getAnalysis<DataLayout>());
+  init(&getAnalysis<DataLayoutPass>().getDataLayout());
   addrAnalysis = &getAnalysis<AddressTakenAnalysis>();
 
   // First step, build the globals graph.

lib/DSA/Printer.cpp

 #include "dsa/DSGraphTraits.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Constants.h"
-#include "llvm/Assembly/Writer.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/GraphWriter.h"
 #include "llvm/ADT/Statistic.h"

 
   for (DSNode::globals_iterator i = N->globals_begin(), e = N->globals_end(); 
        i != e; ++i) {
-    WriteAsOperand(OS, *i, false, M);
+    (*i)->print(OS);
 
     // Figure out how many globals are equivalent to this one.
     if (GlobalECs) {

         if (!isa<GlobalValue>(I->first)) {
           std::string OS_str;
           llvm::raw_string_ostream OS(OS_str);
-          WriteAsOperand(OS, I->first, false, CurMod);
+          I->first->print(OS);
           GW.emitSimpleNode(I->first, "", OS.str());
           
           // Add edge from return node to real destination

   O << "Writing '" << Filename << "'...";
   if (!DontPrintGraphs) {
     std::string Error;
-    llvm::raw_fd_ostream F(Filename.c_str(), Error);
+    llvm::raw_fd_ostream F(Filename.c_str(), Error, sys::fs::F_Text);
 
     if (Error.size()) {
       O << "  error opening file for writing! " << Error << "\n";

lib/DSA/StdLibPass.cpp

 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
-#include "llvm/Support/GetElementPtrTypeIterator.h"
+#include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"

lib/DSA/TypeSafety.cpp

   //
   // Get access to prerequisite passes.
   //
-  TD      = &getAnalysis<DataLayout>();
+  TD      = &getAnalysis<DataLayoutPass>().getDataLayout();
   dsaPass = &getAnalysis<dsa>();
 
   //

lib/PoolAllocate/Heuristic.cpp

   for (std::map<const DSNode*, Value*>::iterator PDI = PDs.begin(),
          E = PDs.end(); PDI != E; ++PDI) {
     Value *OldPD = PDI->second;
-    std::vector<User*> OldPDUsers(OldPD->use_begin(), OldPD->use_end());
+    std::vector<User*> OldPDUsers(OldPD->user_begin(), OldPD->user_end());
     for (unsigned i = 0, e = OldPDUsers.size(); i != e; ++i) {
       CallSite PDUser(cast<Instruction>(OldPDUsers[i]));
       if (PDUser.getCalledValue() != PoolInit &&

lib/PoolAllocate/PAMultipleGlobalPool.cpp

 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/TypeBuilder.h"
-#include "llvm/Support/CFG.h"
+#include "llvm/IR/CFG.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/ADT/DepthFirstIterator.h"

 }
 
 void PoolAllocateMultipleGlobalPool::getAnalysisUsage(AnalysisUsage &AU) const {
-  AU.addRequired<DataLayout>();
+  AU.addRequired<DataLayoutPass>();
   assert(0 && "PoolAllocateMultipleGlobalPool doesn't work! Needs Steensgard-like analysis, which was removed!");
   //AU.addRequiredTransitive<SteensgaardDataStructures>();
   // It is a big lie.

   Graphs = NULL;
   assert (Graphs && "No DSA pass available!\n");
 
-  DataLayout & TD = getAnalysis<DataLayout>();
+  const DataLayout & TD = getAnalysis<DataLayoutPass>().getDataLayout();
 
   // Add the pool* prototypes to the module
   AddPoolPrototypes(&M);

 }
 
 void
-PoolAllocateMultipleGlobalPool::ProcessFunctionBodySimple (Function& F, DataLayout & TD) {
+PoolAllocateMultipleGlobalPool::ProcessFunctionBodySimple (Function& F, const DataLayout & TD) {
   std::vector<Instruction*> toDelete;
   std::vector<ReturnInst*> Returns;
 

lib/PoolAllocate/PASimple.cpp

 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Module.h"
-#include "llvm/Support/CFG.h"
+#include "llvm/IR/CFG.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/ADT/DepthFirstIterator.h"

 }
 
 void PoolAllocateSimple::getAnalysisUsage(AnalysisUsage &AU) const {
-  AU.addRequired<DataLayout>();
+  AU.addRequired<DataLayoutPass>();
   // Get the Target Data information and the Graphs
   if (CompleteDSA) {
     AU.addRequiredTransitive<EQTDDataStructures>();

     Graphs = &getAnalysis<BasicDataStructures>();
   }
   assert (Graphs && "No DSA pass available!\n");
-  DataLayout & TD = getAnalysis<DataLayout>();
+  const DataLayout & TD = getAnalysis<DataLayoutPass>().getDataLayout();
 
   // Add the pool* prototypes to the module
   AddPoolPrototypes(&M);

 }
 
 void
-PoolAllocateSimple::ProcessFunctionBodySimple (Function& F, DataLayout & TD) {
+PoolAllocateSimple::ProcessFunctionBodySimple (Function& F, const DataLayout & TD) {
   // Set of instructions to delete because they have been replaced.  We record
   // all instructions to delete first and then delete them later to avoid
   // invalidating the iterators over the instruction list.

lib/PoolAllocate/PointerCompress.cpp

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
-#include "llvm/Support/GetElementPtrTypeIterator.h"
-#include "llvm/InstVisitor.h"
+#include "llvm/IR/GetElementPtrTypeIterator.h"
+#include "llvm/IR/InstVisitor.h"
 #include "llvm/Support/FormattedStream.h"
 
 #include "llvm/Transforms/Utils/Cloning.h"

lib/PoolAllocate/PoolAllocate.cpp

 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Module.h"
-#include "llvm/Support/CFG.h"
+#include "llvm/IR/CFG.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/ADT/DepthFirstIterator.h"

   if (lie_preserve_passes == LIE_PRESERVE_ALL)
     AU.setPreservesAll();
 
-  AU.addRequired<DataLayout>();
+  AU.addRequired<DataLayoutPass>();
 }
 
 bool PoolAllocate::runOnModule(Module &M) {

     //  o) the called function is the function that we're replacing
     //
     std::vector<User *> toReplace;
-    for (Function::use_iterator User = F->use_begin();
-                                User != F->use_end();
+    for (Function::user_iterator User = F->user_begin();
+                                User != F->user_end();
                                 ++User) {
       if (CallInst * CI = dyn_cast<CallInst>(*User)) {
         if (CI->getCalledFunction() == F)

 
 void PoolAllocate::CalculateLivePoolFreeBlocks(std::set<BasicBlock*>&LiveBlocks,
                                                Value *PD) {
-  for (Value::use_iterator I = PD->use_begin(), E = PD->use_end(); I != E; ++I){
+  for (Value::user_iterator I = PD->user_begin(), E = PD->user_end(); I != E; ++I){
     //
     // The only users of the pool should be call, invoke, and cast
     // instructions.  We know that poolfree() and pooldestroy() do not need to

lib/PoolAllocate/PoolOptimize.cpp

       // Yes, if there are uses at all, nuke the pool init, destroy, and the PD.
       if (!HasPoolAlloc) {
         while (!PoolDesc->use_empty())
-          cast<Instruction>(PoolDesc->use_back())->eraseFromParent();
+          cast<Instruction>(PoolDesc->user_back())->eraseFromParent();
         if (AllocaInst *AI = dyn_cast<AllocaInst>(PoolDesc))
           AI->eraseFromParent();
         else
           cast<GlobalVariable>(PoolDesc)->eraseFromParent();
       } else {
         // Convert all of the pool descriptor users to the BumpPtr flavor.
-        std::vector<User*> PDUsers(PoolDesc->use_begin(), PoolDesc->use_end());
+        std::vector<User*> PDUsers(PoolDesc->user_begin(), PoolDesc->user_end());
         
         while (!PDUsers.empty()) {
           CallInst *CI = cast<CallInst>(PDUsers.back());

lib/PoolAllocate/RunTimeAssociate.cpp

 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Module.h"
-#include "llvm/Support/CFG.h"
+#include "llvm/IR/CFG.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/ADT/DepthFirstIterator.h"

lib/PoolAllocate/TransformFunctionBody.cpp

 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/DataLayout.h"
-#include "llvm/InstVisitor.h"
+#include "llvm/IR/InstVisitor.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/ADT/StringMap.h"

lib/rDSA/EquivClassGraphs.cpp

 #include "llvm/Module.h"
 #include "llvm/Pass.h"
 #include "rdsa/DSGraph.h"
-#include "llvm/Support/CallSite.h"
+#include "llvm/IR/CallSite.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/ADT/SCCIterator.h"
 #include "llvm/ADT/Statistic.h"

lib/rDSA/Local.cpp

 #include "llvm/DerivedTypes.h"
 #include "llvm/Instructions.h"
 #include "llvm/Intrinsics.h"
-#include "llvm/Support/GetElementPtrTypeIterator.h"
+#include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/Support/InstVisitor.h"
 #include "llvm/DataLayout.h"
 #include "llvm/Support/CommandLine.h"

 char LocalDataStructures::ID;
 
 bool LocalDataStructures::runOnModule(Module &M) {
-  init(&getAnalysis<DataLayout>());
+  init(&getAnalysis<DataLayoutPass>().getDataLayout());
 
   // First step, build the globals graph.
   {

lib/rDSA/StdLibPass.cpp

 #include "llvm/DerivedTypes.h"
 #include "llvm/Instructions.h"
 #include "llvm/Intrinsics.h"
-#include "llvm/Support/GetElementPtrTypeIterator.h"
+#include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/DataLayout.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"

lib/rDSA/Steensgaard.cpp

 bool
 SteensgaardDataStructures::runOnModule(Module &M) {
   DS = &getAnalysis<StdLibDataStructures>();
-  init(&getAnalysis<DataLayout>());
+  init(&getAnalysis<DataLayoutPass>().getDataLayout());
   return runOnModuleInternal(M);
 }