Non-functionality change just to make it more clear what is going on

[oota-llvm.git] / lib / Transforms / IPO / SimpleStructMutation.cpp

diff --git a/lib/Transforms/IPO/SimpleStructMutation.cpp b/lib/Transforms/IPO/SimpleStructMutation.cpp
index 168f839736603e44476b843466476f18a673dccd..4e21dd69a0d4838376bc42ee511a4e456a9b91b5 100644 (file)
--- a/lib/Transforms/IPO/SimpleStructMutation.cpp
+++ b/lib/Transforms/IPO/SimpleStructMutation.cpp
@@ -1,54 +1,67 @@
-//===- SimpleStructMutation.cpp - Swap structure elements around ---*- C++ -*--=//
+//===- SimpleStructMutation.cpp - Swap structure elements around -*- C++ -*--=//
 //
 // This pass does a simple transformation that swaps all of the elements of the
 // struct types in the program around.
 //
 //===----------------------------------------------------------------------===//
 
-
-#include "llvm/Transforms/IPO/SimpleStructMutation.h"
+#include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/IPO/MutateStructTypes.h"
 #include "llvm/Analysis/FindUsedTypes.h"
 #include "llvm/Analysis/FindUnsafePointerTypes.h"
-#include "../TransformInternals.h"
+#include "llvm/Target/TargetData.h"
+#include "llvm/DerivedTypes.h"
 #include <algorithm>
-#include <iostream>
 using std::vector;
 using std::set;
 using std::pair;
 
-#include "llvm/Assembly/Writer.h"
-
 namespace {
-  class SimpleStructMutation : public MutateStructTypes {
-  public:
-    enum Transform { SwapElements, SortElements } CurrentXForm;
+  struct SimpleStructMutation : public MutateStructTypes {
+    enum Transform { SwapElements, SortElements };
     
-    SimpleStructMutation(enum Transform XForm) : CurrentXForm(XForm) {}
+    virtual bool run(Module &M)  = 0;
+
+    // getAnalysisUsage - This function needs the results of the
+    // FindUsedTypes and FindUnsafePointerTypes analysis passes...
+    //
+    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+      AU.addRequired<TargetData>();
+      AU.addRequired<FindUsedTypes>();
+      AU.addRequired<FindUnsafePointerTypes>();
+      MutateStructTypes::getAnalysisUsage(AU);
+    }
     
-    virtual bool run(Module *M) {
-      setTransforms(getTransforms(M, CurrentXForm));
+  protected:
+    TransformsType getTransforms(Module &M, enum Transform);
+  };
+
+  struct SwapStructElements : public SimpleStructMutation {
+    virtual bool run(Module &M) {
+      setTransforms(getTransforms(M, SwapElements));
       bool Changed = MutateStructTypes::run(M);
       clearTransforms();
       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) {
-      Required.push_back(FindUsedTypes::ID);
-      Required.push_back(FindUnsafePointerTypes::ID);
-      MutateStructTypes::getAnalysisUsageInfo(Required, Destroyed, Provided);
+  };
+
+  struct SortStructElements : public SimpleStructMutation {
+    virtual bool run(Module &M) {
+      setTransforms(getTransforms(M, SortElements));
+      bool Changed = MutateStructTypes::run(M);
+      clearTransforms();
+      return Changed;
     }
-    
-  private:
-    TransformsType getTransforms(Module *M, enum Transform);
   };
+
+  RegisterOpt<SwapStructElements> X("swapstructs",
+                                    "Swap structure types around");
+  RegisterOpt<SortStructElements> Y("sortstructs",
+                                    "Sort structure elements by size");
 }  // end anonymous namespace
 
+Pass *createSwapElementsPass() { return new SwapStructElements(); }
+Pass *createSortElementsPass() { return new SortStructElements(); }
 
 
 // PruneTypes - Given a type Ty, make sure that neither it, or one of its
@@ -87,9 +100,9 @@ static unsigned getIndex(const vector<pair<unsigned, unsigned> > &Vec,
     if (Vec[i].first == Field) return i;
 }
 
-static inline void GetTransformation(const StructType *ST,
+static inline void GetTransformation(const TargetData &TD, const StructType *ST,
                                      vector<int> &Transform,
-                                enum SimpleStructMutation::Transform XForm) {
+                                   enum SimpleStructMutation::Transform XForm) {
   unsigned NumElements = ST->getElementTypes().size();
   Transform.reserve(NumElements);
 
@@ -120,7 +133,7 @@ static inline void GetTransformation(const StructType *ST,
 
 
 SimpleStructMutation::TransformsType
-  SimpleStructMutation::getTransforms(Module *M, enum Transform XForm) {
+  SimpleStructMutation::getTransforms(Module &, enum Transform XForm) {
   // We need to know which types to modify, and which types we CAN'T modify
   // TODO: Do symbol tables as well
 
@@ -156,23 +169,15 @@ SimpleStructMutation::TransformsType
   // Build up a set of structure types that we are going to modify, and
   // information describing how to modify them.
   std::map<const StructType*, vector<int> > Transforms;
+  TargetData &TD = getAnalysis<TargetData>();
 
   for (set<const StructType*>::iterator I = TypesToModify.begin(),
          E = TypesToModify.end(); I != E; ++I) {
     const StructType *ST = *I;
 
     vector<int> &Transform = Transforms[ST];  // Fill in the map directly
-    GetTransformation(ST, Transform, XForm);
+    GetTransformation(TD, ST, Transform, XForm);
   }
   
   return Transforms;
 }
-
-
-Pass *createSwapElementsPass() {
-  return new SimpleStructMutation(SimpleStructMutation::SwapElements);
-}
-Pass *createSortElementsPass() {
-  return new SimpleStructMutation(SimpleStructMutation::SortElements);
-}
-