1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
//===-- llvm/Transforms/MutateStructTypes.h - Rearrange structs -*- C++ -*-===//
//
// 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 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"
namespace llvm {
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);
};
} // End llvm namespace
#endif
|
