Added LLVM project notice to the top of every C++ source file.

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

diff --git a/lib/Transforms/IPO/SimpleStructMutation.cpp b/lib/Transforms/IPO/SimpleStructMutation.cpp
index 33e028950476a639f707c1e18c9f3920732d6e62..012fa22770224c17b8e543eef96b4c5d43969bef 100644 (file)
--- a/lib/Transforms/IPO/SimpleStructMutation.cpp
+++ b/lib/Transforms/IPO/SimpleStructMutation.cpp
@@ -1,50 +1,74 @@
-//===- SimpleStructMutation.cpp - Swap structure elements around -*- C++ -*--=//
+//===- SimpleStructMutation.cpp - Swap structure elements around ----------===//
+// 
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// 
+//===----------------------------------------------------------------------===//
 //
 // 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/MutateStructTypes.h"
+#include "llvm/Transforms/IPO.h"
+#include "llvm/Transforms/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;
 
 namespace {
-  class SimpleStructMutation : public MutateStructTypes {
-  public:
-    enum Transform { SwapElements, SortElements } CurrentXForm;
-    
-    SimpleStructMutation(enum Transform XForm) : CurrentXForm(XForm) {}
-    
-    virtual bool run(Module *M) {
-      setTransforms(getTransforms(M, CurrentXForm));
-      bool Changed = MutateStructTypes::run(M);
-      clearTransforms();
-      return Changed;
-    }
+  struct SimpleStructMutation : public MutateStructTypes {
+    enum Transform { SwapElements, SortElements };
     
+    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(FindUsedTypes::ID);
-      AU.addRequired(FindUnsafePointerTypes::ID);
+      AU.addRequired<TargetData>();
+      AU.addRequired<FindUsedTypes>();
+      AU.addRequired<FindUnsafePointerTypes>();
       MutateStructTypes::getAnalysisUsage(AU);
     }
     
-  private:
-    TransformsType getTransforms(Module *M, enum Transform);
+  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;
+    }
+  };
+
+  struct SortStructElements : public SimpleStructMutation {
+    virtual bool run(Module &M) {
+      setTransforms(getTransforms(M, SortElements));
+      bool Changed = MutateStructTypes::run(M);
+      clearTransforms();
+      return Changed;
+    }
   };
+
+  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
@@ -83,9 +107,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);
 
@@ -116,7 +140,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
 
@@ -152,23 +176,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);
-}
-