diff options
author | Chris Lattner <sabre@nondot.org> | 2004-06-28 00:44:18 +0000 |
---|---|---|
committer | Chris Lattner <sabre@nondot.org> | 2004-06-28 00:44:18 +0000 |
commit | 65f437ce7b477b19f2d54fee1f95100de75a628d (patch) | |
tree | f6b69e6a8d55c04f96a1084b8077ad1c34a3f959 | |
parent | c7553074125556c1e9721208ca4353d5a5a5f7b9 (diff) | |
download | external_llvm-65f437ce7b477b19f2d54fee1f95100de75a628d.zip external_llvm-65f437ce7b477b19f2d54fee1f95100de75a628d.tar.gz external_llvm-65f437ce7b477b19f2d54fee1f95100de75a628d.tar.bz2 |
These passes are long dead/obsolete. They never worked in the first place
and are a maintenence burden. Nuke nuke nuke
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@14457 91177308-0d34-0410-b5e6-96231b3b80d8
-rw-r--r-- | lib/Transforms/IPO/SimpleStructMutation.cpp | 188 |
1 files changed, 0 insertions, 188 deletions
diff --git a/lib/Transforms/IPO/SimpleStructMutation.cpp b/lib/Transforms/IPO/SimpleStructMutation.cpp deleted file mode 100644 index 401677a..0000000 --- a/lib/Transforms/IPO/SimpleStructMutation.cpp +++ /dev/null @@ -1,188 +0,0 @@ -//===- 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.h" -#include "llvm/Transforms/MutateStructTypes.h" -#include "llvm/Analysis/FindUsedTypes.h" -#include "llvm/Analysis/FindUnsafePointerTypes.h" -#include "llvm/Target/TargetData.h" -#include "llvm/DerivedTypes.h" -#include <algorithm> -using namespace llvm; - -namespace { - 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<TargetData>(); - AU.addRequired<FindUsedTypes>(); - AU.addRequired<FindUnsafePointerTypes>(); - MutateStructTypes::getAnalysisUsage(AU); - } - - 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 -// subtypes, occur in TypesToModify. -// -static void PruneTypes(const Type *Ty, - std::set<const StructType*> &TypesToModify, - std::set<const Type*> &ProcessedTypes) { - if (ProcessedTypes.count(Ty)) return; // Already been checked - ProcessedTypes.insert(Ty); - - // If the element is in TypesToModify, remove it now... - if (const StructType *ST = dyn_cast<StructType>(Ty)) { - TypesToModify.erase(ST); // This doesn't fail if the element isn't present - std::cerr << "Unable to swap type: " << ST << "\n"; - } - - // Remove all types that this type contains as well... do not remove types - // that are referenced only through pointers, because we depend on the size of - // the pointer, not on what the structure points to. - // - for (Type::subtype_iterator I = Ty->subtype_begin(), E = Ty->subtype_end(); - I != E; ++I) { - if (!isa<PointerType>(I->get())) - PruneTypes(*I, TypesToModify, ProcessedTypes); - } -} - -static bool FirstLess(const std::pair<unsigned, unsigned> &LHS, - const std::pair<unsigned, unsigned> &RHS) { - return LHS.second < RHS.second; -} - -static unsigned getIndex(const std::vector<std::pair<unsigned, unsigned> > &Vec, - unsigned Field) { - for (unsigned i = 0; ; ++i) - if (Vec[i].first == Field) return i; -} - -static inline void GetTransformation(const TargetData &TD, const StructType *ST, - std::vector<int> &Transform, - enum SimpleStructMutation::Transform XForm) { - unsigned NumElements = ST->getNumElements(); - Transform.reserve(NumElements); - - switch (XForm) { - case SimpleStructMutation::SwapElements: - // The transformation to do is: just simply swap the elements - for (unsigned i = 0; i < NumElements; ++i) - Transform.push_back(NumElements-i-1); - break; - - case SimpleStructMutation::SortElements: { - std::vector<std::pair<unsigned, unsigned> > ElList; - - // Build mapping from index to size - for (unsigned i = 0; i < NumElements; ++i) - ElList.push_back(std::make_pair(i,TD.getTypeSize(ST->getElementType(i)))); - - sort(ElList.begin(), ElList.end(), ptr_fun(FirstLess)); - - for (unsigned i = 0; i < NumElements; ++i) - Transform.push_back(getIndex(ElList, i)); - - break; - } - } -} - - -SimpleStructMutation::TransformsType - 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 - - // Get the results out of the analyzers... - FindUsedTypes &FUT = getAnalysis<FindUsedTypes>(); - const std::set<const Type *> &UsedTypes = FUT.getTypes(); - - FindUnsafePointerTypes &FUPT = getAnalysis<FindUnsafePointerTypes>(); - const std::set<PointerType*> &UnsafePTys = FUPT.getUnsafeTypes(); - - - // Combine the two sets, weeding out non structure types. Closures in C++ - // sure would be nice. - std::set<const StructType*> TypesToModify; - for (std::set<const Type *>::const_iterator I = UsedTypes.begin(), - E = UsedTypes.end(); I != E; ++I) - if (const StructType *ST = dyn_cast<StructType>(*I)) - TypesToModify.insert(ST); - - - // Go through the Unsafe types and remove all types from TypesToModify that we - // are not allowed to modify, because that would be unsafe. - // - std::set<const Type*> ProcessedTypes; - for (std::set<PointerType*>::const_iterator I = UnsafePTys.begin(), - E = UnsafePTys.end(); I != E; ++I) { - //cerr << "Pruning type: " << *I << "\n"; - PruneTypes(*I, TypesToModify, ProcessedTypes); - } - - - // Build up a set of structure types that we are going to modify, and - // information describing how to modify them. - std::map<const StructType*, std::vector<int> > Transforms; - TargetData &TD = getAnalysis<TargetData>(); - - for (std::set<const StructType*>::iterator I = TypesToModify.begin(), - E = TypesToModify.end(); I != E; ++I) { - const StructType *ST = *I; - - std::vector<int> &Transform = Transforms[ST]; // Fill in the map directly - GetTransformation(TD, ST, Transform, XForm); - } - - return Transforms; -} - |