Convert xforms over to use new pass structure

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@1596 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/Transforms/IPO.h

@@ -6,12 +6,9 @@
 #ifndef LLVM_TRANSFORMS_CLEANUPGCCOUTPUT_H
 #define LLVM_TRANSFORMS_CLEANUPGCCOUTPUT_H
 
-#include "llvm/Analysis/FindUsedTypes.h"
+#include "llvm/Pass.h"
-
-class CleanupGCCOutput : public MethodPass {
-  FindUsedTypes FUT;      // Use FUT to eliminate type names that are never used
-public:
 
+struct CleanupGCCOutput : public MethodPass {
   // PatchUpMethodReferences - This is a part of the functionality exported by
   // the CleanupGCCOutput pass.  This causes functions with different signatures
   // to be linked together if they have the same name.
@@ -32,6 +29,12 @@ public:
 
   // doPassFinalization - Strip out type names that are unused by the program
   bool doFinalization(Module *M);
+
+  // getAnalysisUsageInfo - This function needs FindUsedTypes to do its job...
+  //
+  virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
+                                    Pass::AnalysisSet &Destroyed,
+                                    Pass::AnalysisSet &Provided);
 };
 
 #endif

include/llvm/Transforms/IPO/ConstantMerge.h

@@ -18,7 +18,6 @@
 #define LLVM_TRANSFORMS_CONSTANTMERGE_H
 
 #include "llvm/Pass.h"
-#include <map>
 class Constant;
 class GlobalVariable;
 

include/llvm/Transforms/IPO/GlobalDCE.h

@@ -18,6 +18,14 @@ struct GlobalDCE : public Pass {
   // the specified callgraph to reflect the changes.
   //
   bool run(Module *M);
+
+  // getAnalysisUsageInfo - This function works on the call graph of a module.
+  // It is capable of updating the call graph to reflect the new state of the
+  // module.
+  //
+  virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
+                                    Pass::AnalysisSet &Destroyed,
+                                    Pass::AnalysisSet &Provided);
 };
 
 #endif

include/llvm/Transforms/IPO/SimpleStructMutation.h

@@ -23,8 +23,15 @@ public:
     return Changed;
   }
 
+  // getAnalysisUsageInfo - This function needs the results of the
+  // FindUsedTypes and FindUnsafePointerTypes analysis passes...
+  //
+  virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
+                                    Pass::AnalysisSet &Destroyed,
+                                    Pass::AnalysisSet &Provided);
+
 private:
-  static TransformsType getTransforms(Module *M, enum Transform);
+  TransformsType getTransforms(Module *M, enum Transform);
 };
 
 #endif

include/llvm/Transforms/MutateStructTypes.h

@@ -15,8 +15,10 @@
 #define LLVM_TRANSFORMS_MUTATESTRUCTTYPES_H
 
 #include "llvm/Pass.h"
-#include <map>
+#include "llvm/AbstractTypeUser.h"
 
+class Value;
+class Type;
 class StructType;
 class CompositeType;
 class GlobalValue;
@@ -58,6 +60,13 @@ public:
   // run - do the transformation
   virtual bool run(Module *M);
 
+  // getAnalysisUsageInfo - This function needs the results of the
+  // FindUsedTypes and FindUnsafePointerTypes analysis passes...
+  //
+  virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
+                                    Pass::AnalysisSet &Destroyed,
+                                    Pass::AnalysisSet &Provided);
+
 protected:
 
   // Alternatively, it is valid to subclass this class and provide transforms

include/llvm/Transforms/Scalar/ConstantProp.h

@@ -4,10 +4,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_OPT_CONSTANT_PROPOGATION_H
+#ifndef LLVM_TRANSFORMS_SCALAR_CONSTANT_PROPOGATION_H
-#define LLVM_OPT_CONSTANT_PROPOGATION_H
+#define LLVM_TRANSFORMS_SCALAR_CONSTANT_PROPOGATION_H
 
 #include "llvm/Pass.h"
+#include "llvm/BasicBlock.h"
 class TerminatorInst;
 
 struct ConstantPropogation : public MethodPass {

include/llvm/Transforms/Scalar/DCE.h

@@ -9,7 +9,7 @@
 #define LLVM_OPT_DCE_H
 
 #include "llvm/Pass.h"
-#include "llvm/BasicBlock.h"
+#include "llvm/Method.h"
 
 //===----------------------------------------------------------------------===//
 // DeadInstElimination - This pass quickly removes trivially dead instructions
@@ -68,13 +68,13 @@ struct DeadCodeElimination : public MethodPass {
 // it more successful are removing non-obviously dead instructions.
 //
 struct AgressiveDCE : public MethodPass {
-  // DoADCE - Execute the Agressive Dead Code Elimination Algorithm
+  virtual bool runOnMethod(Method *M);
-  //
-  static bool doADCE(Method *M);                        // Defined in ADCE.cpp
 
-  virtual bool runOnMethod(Method *M) {
+  // getAnalysisUsageInfo - We require post dominance frontiers (aka Control
-    return doADCE(M);
+  // Dependence Graph)
-  }
+  virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Requires,
+                                    Pass::AnalysisSet &Destroyed,
+                                    Pass::AnalysisSet &Provided);
 };
 
 

include/llvm/Transforms/Scalar/IndVarSimplify.h

@@ -10,10 +10,16 @@
 
 #include "llvm/Pass.h"
 
-struct InductionVariableSimplify : public MethodPass {
+namespace cfg { class LoopInfo; }
-  static bool doit(Method *M);
 
-  virtual bool runOnMethod(Method *M) { return doit(M); }
+struct InductionVariableSimplify : public MethodPass {
+  static bool doit(Method *M, cfg::LoopInfo &Loops);
+
+  virtual bool runOnMethod(Method *M);
+
+  virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
+                                    Pass::AnalysisSet &Destroyed,
+                                    Pass::AnalysisSet &Provided);
 };
 
 #endif

include/llvm/Transforms/Scalar/InductionVars.h

@@ -9,15 +9,19 @@
 #define LLVM_OPT_INDUCTION_VARS_H
 
 #include "llvm/Pass.h"
+namespace cfg { class IntervalPartition; }
 
 struct InductionVariableCannonicalize : public MethodPass {
   // doInductionVariableCannonicalize - Simplify induction variables in loops
   //
-  static bool doIt(Method *M);
+  static bool doIt(Method *M, cfg::IntervalPartition &IP);
 
-  virtual bool runOnMethod(Method *M) {
+  virtual bool runOnMethod(Method *M);
-    return doIt(M);
+
-  }
+  // getAnalysisUsageInfo - Declare that we need IntervalPartitions
+  void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
+                            Pass::AnalysisSet &Destroyed,
+                            Pass::AnalysisSet &Provided);
 };
 
 #endif

include/llvm/Transforms/Scalar/InstructionCombining.h

@@ -16,6 +16,7 @@
 #define LLVM_TRANSFORMS_SCALAR_INSTRUCTIONCOMBINING_H
 
 #include "llvm/Pass.h"
+class Instruction;
 
 struct InstructionCombining : public MethodPass {
   static bool doit(Method *M);

include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h

@@ -0,0 +1,37 @@
+//===-- UnifyMethodExitNodes.h - Ensure methods have one return --*- C++ -*--=//
+//
+// This pass is used to ensure that methods have at most one return instruction
+// in them.  It also holds onto the return instruction of the last unified
+// method.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_XFORMS_UNIFY_METHOD_EXIT_NODES_H
+#define LLVM_XFORMS_UNIFY_METHOD_EXIT_NODES_H
+
+#include "llvm/Pass.h"
+#include "llvm/Analysis/SimplifyCFG.h"   // FIXME!!
+
+struct UnifyMethodExitNodes : public MethodPass {
+  BasicBlock *ExitNode;
+public:
+  static AnalysisID ID;            // Pass ID
+  UnifyMethodExitNodes(AnalysisID id) : ExitNode(0) { assert(ID == id); }
+
+  virtual bool runOnMethod(Method *M) {
+    ExitNode = cfg::UnifyAllExitNodes(M);
+
+    return true; // FIXME: This should return a correct code!!!
+  }
+
+  BasicBlock *getExitNode() const { return ExitNode; }
+
+  virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
+                                    Pass::AnalysisSet &Destroyed,
+                                    Pass::AnalysisSet &Provided) {
+    // FIXME: Should invalidate CFG
+    Provided.push_back(ID);  // Provide self!
+  }
+};
+
+#endif