Initial checkin of Structure mutator
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@1245 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/include/llvm/Transforms/MutateStructTypes.h b/include/llvm/Transforms/MutateStructTypes.h
new file mode 100644
index 0000000..1f3b250
--- /dev/null
+++ b/include/llvm/Transforms/MutateStructTypes.h
@@ -0,0 +1,87 @@
+//===- llvm/Transforms/MutateStructTypes.h - Change struct defns -*- C++ -*--=//
+//
+// This pass is used to change structure accesses and type definitions in some
+// way. It can be used to arbitrarily permute structure fields, safely, without
+// breaking code. A transformation may only be done on a type if that type has
+// been found to be "safe" by the 'FindUnsafePointerTypes' pass. This pass will
+// assert and die if you try to do an illegal transformation.
+//
+// This is an interprocedural pass that requires the entire program to do a
+// transformation.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_MUTATESTRUCTTYPES_H
+#define LLVM_TRANSFORMS_MUTATESTRUCTTYPES_H
+
+#include "llvm/Pass.h"
+#include <map>
+
+class StructType;
+class GlobalValue;
+
+class MutateStructTypes : public Pass {
+ // TransformType - Representation of the destination type for a particular
+ // incoming structure. The first member is the destination type that we are
+ // mapping to, and the second member is the destination slot # to put each
+ // incoming slot [or negative if the specified incoming slot should be
+ // removed].
+ //
+ typedef pair<const StructType*, vector<int> > TransformType;
+
+ // Transforms to do for each structure type...
+ map<const StructType*, TransformType> Transforms;
+
+ // Mapping of old type to new types...
+ map<const Type *, PATypeHolder<Type> > TypeMap;
+
+ // Mapping from global value of old type, to a global value of the new type...
+ map<const GlobalValue*, GlobalValue*> GlobalMap;
+
+ // Mapping from intra method value to intra method value
+ map<const Value*, Value*> LocalValueMap;
+
+public:
+ // Ctor - Take a map that specifies what transformation to do for each field
+ // of the specified structure types. There is one element of the vector for
+ // each field of the structure. The value specified indicates which slot of
+ // the destination structure the field should end up in. A negative value
+ // indicates that the field should be deleted entirely.
+ //
+ MutateStructTypes(const map<const StructType*, vector<int> > &Transforms);
+
+
+ // doPassInitialization - This loops over global constants defined in the
+ // module, converting them to their new type. Also this creates placeholder
+ // methods for methods than need to be copied because they have a new
+ // signature type.
+ //
+ bool doPassInitialization(Module *M);
+
+ // doPerMethodWork - This transforms the instructions of the method to use the
+ // new types.
+ //
+ bool doPerMethodWork(Method *M);
+
+ // doPassFinalization - This removes the old versions of methods that are no
+ // longer needed.
+ //
+ virtual bool doPassFinalization(Module *M);
+
+private:
+ // ConvertType - Convert from the old type system to the new one...
+ const Type *ConvertType(const Type *Ty);
+
+ // ConvertValue - Convert from the old value in the old type system to the new
+ // type system.
+ //
+ Value *ConvertValue(const Value *V);
+
+ // AdjustIndices - Convert the indexes specifed by Idx to the new changed form
+ // using the specified OldTy as the base type being indexed into.
+ //
+ void AdjustIndices(const StructType *OldTy, vector<ConstPoolVal*> &Idx,
+ unsigned idx = 0);
+};
+
+#endif