mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-21 03:29:40 +00:00
For details, See: docs/2002-06-25-MegaPatchInfo.txt git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2779 91177308-0d34-0410-b5e6-96231b3b80d8
108 lines
3.7 KiB
C++
108 lines
3.7 KiB
C++
//===- 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 "llvm/AbstractTypeUser.h"
|
|
|
|
class Value;
|
|
class Type;
|
|
class StructType;
|
|
class CompositeType;
|
|
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 std::pair<const StructType*, std::vector<int> > TransformType;
|
|
|
|
// Transforms to do for each structure type...
|
|
std::map<const StructType*, TransformType> Transforms;
|
|
|
|
// Mapping of old type to new types...
|
|
std::map<const Type *, PATypeHolder> TypeMap;
|
|
|
|
// Mapping from global value of old type, to a global value of the new type...
|
|
std::map<const GlobalValue*, GlobalValue*> GlobalMap;
|
|
|
|
// Mapping from intra function value to intra function value
|
|
std::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.
|
|
//
|
|
typedef std::map<const StructType*, std::vector<int> > TransformsType;
|
|
|
|
MutateStructTypes(const TransformsType &Transforms) {
|
|
setTransforms(Transforms);
|
|
}
|
|
|
|
// run - do the transformation
|
|
virtual bool run(Module &M);
|
|
|
|
protected:
|
|
|
|
// Alternatively, it is valid to subclass this class and provide transforms
|
|
// this way. See SimpleStructMutation for an example.
|
|
//
|
|
MutateStructTypes() {}
|
|
void setTransforms(const TransformsType &Transforms);
|
|
void clearTransforms();
|
|
|
|
private:
|
|
|
|
// processGlobals - This loops over global constants defined in the
|
|
// module, converting them to their new type. Also this creates placeholder
|
|
// functions for functions than need to be copied because they have a new
|
|
// signature type.
|
|
//
|
|
void processGlobals(Module &M);
|
|
|
|
// transformFunction - This transforms the instructions of the function to use
|
|
// the new types.
|
|
//
|
|
void transformFunction(Function *F);
|
|
|
|
// removeDeadGlobals - This removes the old versions of functions that are no
|
|
// longer needed.
|
|
//
|
|
void removeDeadGlobals(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 CompositeType *OldTy, std::vector<Value*> &Idx,
|
|
unsigned idx = 0);
|
|
};
|
|
|
|
#endif
|