-//===- SwapStructContents.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/SwapStructContents.h"
-#include "llvm/Transforms/MutateStructTypes.h"
+#include "llvm/Transforms/IPO/SimpleStructMutation.h"
+#include "llvm/Transforms/IPO/MutateStructTypes.h"
#include "llvm/Analysis/FindUsedTypes.h"
#include "llvm/Analysis/FindUnsafePointerTypes.h"
-#include "TransformInternals.h"
+#include "../TransformInternals.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;
+
+ SimpleStructMutation(enum Transform XForm) : CurrentXForm(XForm) {}
+
+ virtual bool run(Module *M) {
+ setTransforms(getTransforms(M, CurrentXForm));
+ 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);
+ }
+
+ private:
+ TransformsType getTransforms(Module *M, enum Transform);
+ };
+} // end anonymous namespace
+
// PruneTypes - Given a type Ty, make sure that neither it, or one of its
}
}
+
SimpleStructMutation::TransformsType
SimpleStructMutation::getTransforms(Module *M, enum Transform XForm) {
-
- // FIXME: These should be calculated by the Pass framework!
-
// We need to know which types to modify, and which types we CAN'T modify
- FindUsedTypes *FUT = new FindUsedTypes(/*true*/); // TODO: Do symbol tables as well
- FindUnsafePointerTypes *FUPT = new FindUnsafePointerTypes();
-
- // Simutaneously find all of the types used, and all of the types that aren't
- // safe.
- //
- PassManager Analyses;
- Analyses.add(FUT);
- Analyses.add(FUPT);
- Analyses.run(M); // Do analyses
+ // TODO: Do symbol tables as well
// Get the results out of the analyzers...
- const set<PointerType*> &UnsafePTys = FUPT->getUnsafeTypes();
- const set<const Type *> &UsedTypes = FUT->getTypes();
+ FindUsedTypes &FUT = getAnalysis<FindUsedTypes>();
+ const set<const Type *> &UsedTypes = FUT.getTypes();
+
+ FindUnsafePointerTypes &FUPT = getAnalysis<FindUnsafePointerTypes>();
+ const set<PointerType*> &UnsafePTys = FUPT.getUnsafeTypes();
+
// Combine the two sets, weeding out non structure types. Closures in C++
return Transforms;
}
+
+Pass *createSwapElementsPass() {
+ return new SimpleStructMutation(SimpleStructMutation::SwapElements);
+}
+Pass *createSortElementsPass() {
+ return new SimpleStructMutation(SimpleStructMutation::SortElements);
+}
+