include/llvm/Transforms/MutateStructTypes.h

   1 //===- llvm/Transforms/MutateStructTypes.h - Change struct defns -*- C++ -*--=//
   2 //
   3 // This pass is used to change structure accesses and type definitions in some
   4 // way.  It can be used to arbitrarily permute structure fields, safely, without
   5 // breaking code.  A transformation may only be done on a type if that type has
   6 // been found to be "safe" by the 'FindUnsafePointerTypes' pass.  This pass will
   7 // assert and die if you try to do an illegal transformation.
   8 //
   9 // This is an interprocedural pass that requires the entire program to do a
  10 // transformation.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_TRANSFORMS_MUTATESTRUCTTYPES_H
  15 #define LLVM_TRANSFORMS_MUTATESTRUCTTYPES_H
  16
  17 #include "llvm/Pass.h"
  18 #include "llvm/AbstractTypeUser.h"
  19
  20 class Value;
  21 class Type;
  22 class StructType;
  23 class CompositeType;
  24 class GlobalValue;
  25
  26 class MutateStructTypes : public Pass {
  27   // TransformType - Representation of the destination type for a particular
  28   // incoming structure.  The first member is the destination type that we are
  29   // mapping to, and the second member is the destination slot # to put each
  30   // incoming slot [or negative if the specified incoming slot should be
  31   // removed].
  32   //
  33   typedef std::pair<const StructType*, std::vector<int> > TransformType;
  34
  35   // Transforms to do for each structure type...
  36   std::map<const StructType*, TransformType> Transforms;
  37
  38   // Mapping of old type to new types...
  39   std::map<const Type *, PATypeHolder> TypeMap;
  40
  41   // Mapping from global value of old type, to a global value of the new type...
  42   std::map<const GlobalValue*, GlobalValue*> GlobalMap;
  43
  44   // Mapping from intra function value to intra function value
  45   std::map<const Value*, Value*> LocalValueMap;
  46
  47 public:
  48   // Ctor - Take a map that specifies what transformation to do for each field
  49   // of the specified structure types.  There is one element of the vector for
  50   // each field of the structure.  The value specified indicates which slot of
  51   // the destination structure the field should end up in.  A negative value
  52   // indicates that the field should be deleted entirely.
  53   //
  54   typedef std::map<const StructType*, std::vector<int> > TransformsType;
  55
  56   MutateStructTypes(const TransformsType &Transforms) {
  57     setTransforms(Transforms);
  58   }
  59
  60   // run - do the transformation
  61   virtual bool run(Module *M);
  62
  63 protected:
  64
  65   // Alternatively, it is valid to subclass this class and provide transforms
  66   // this way.  See SimpleStructMutation for an example.
  67   //
  68   MutateStructTypes() {}
  69   void setTransforms(const TransformsType &Transforms);
  70   void clearTransforms();
  71
  72 private:
  73
  74   // processGlobals - This loops over global constants defined in the
  75   // module, converting them to their new type.  Also this creates placeholder
  76   // functions for functions than need to be copied because they have a new
  77   // signature type.
  78   //
  79   void processGlobals(Module *M);
  80
  81   // transformFunction - This transforms the instructions of the function to use
  82   // the new types.
  83   //
  84   void transformFunction(Function *F);
  85
  86   // removeDeadGlobals - This removes the old versions of functions that are no
  87   // longer needed.
  88   //
  89   void removeDeadGlobals(Module *M);
  90
  91 private:
  92   // ConvertType - Convert from the old type system to the new one...
  93   const Type *ConvertType(const Type *Ty);
  94
  95   // ConvertValue - Convert from the old value in the old type system to the new
  96   // type system.
  97   //
  98   Value *ConvertValue(const Value *V);
  99
 100   // AdjustIndices - Convert the indexes specifed by Idx to the new changed form
 101   // using the specified OldTy as the base type being indexed into.
 102   //
 103   void AdjustIndices(const CompositeType *OldTy, std::vector<Value*> &Idx,
 104                      unsigned idx = 0);
 105 };
 106
 107 #endif