/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/include/llvm/Transforms/Utils/ValueMapper.h
Line | Count | Source (jump to first uncovered line) |
1 | | //===- ValueMapper.h - Remapping for constants and metadata -----*- C++ -*-===// |
2 | | // |
3 | | // The LLVM Compiler Infrastructure |
4 | | // |
5 | | // This file is distributed under the University of Illinois Open Source |
6 | | // License. See LICENSE.TXT for details. |
7 | | // |
8 | | //===----------------------------------------------------------------------===// |
9 | | // |
10 | | // This file defines the MapValue interface which is used by various parts of |
11 | | // the Transforms/Utils library to implement cloning and linking facilities. |
12 | | // |
13 | | //===----------------------------------------------------------------------===// |
14 | | |
15 | | #ifndef LLVM_TRANSFORMS_UTILS_VALUEMAPPER_H |
16 | | #define LLVM_TRANSFORMS_UTILS_VALUEMAPPER_H |
17 | | |
18 | | #include "llvm/ADT/ArrayRef.h" |
19 | | #include "llvm/IR/ValueHandle.h" |
20 | | #include "llvm/IR/ValueMap.h" |
21 | | |
22 | | namespace llvm { |
23 | | |
24 | | class Value; |
25 | | class Instruction; |
26 | | typedef ValueMap<const Value *, WeakTrackingVH> ValueToValueMapTy; |
27 | | |
28 | | /// This is a class that can be implemented by clients to remap types when |
29 | | /// cloning constants and instructions. |
30 | | class ValueMapTypeRemapper { |
31 | | virtual void anchor(); // Out of line method. |
32 | | |
33 | | public: |
34 | 877 | virtual ~ValueMapTypeRemapper() = default; |
35 | | |
36 | | /// The client should implement this method if they want to remap types while |
37 | | /// mapping values. |
38 | | virtual Type *remapType(Type *SrcTy) = 0; |
39 | | }; |
40 | | |
41 | | /// This is a class that can be implemented by clients to materialize Values on |
42 | | /// demand. |
43 | | class ValueMaterializer { |
44 | | virtual void anchor(); // Out of line method. |
45 | | |
46 | | protected: |
47 | | ~ValueMaterializer() = default; |
48 | 1.77k | ValueMaterializer() = default; |
49 | | ValueMaterializer(const ValueMaterializer &) = default; |
50 | | ValueMaterializer &operator=(const ValueMaterializer &) = default; |
51 | | |
52 | | public: |
53 | | /// This method can be implemented to generate a mapped Value on demand. For |
54 | | /// example, if linking lazily. Returns null if the value is not materialized. |
55 | | virtual Value *materialize(Value *V) = 0; |
56 | | }; |
57 | | |
58 | | /// These are flags that the value mapping APIs allow. |
59 | | enum RemapFlags { |
60 | | RF_None = 0, |
61 | | |
62 | | /// If this flag is set, the remapper knows that only local values within a |
63 | | /// function (such as an instruction or argument) are mapped, not global |
64 | | /// values like functions and global metadata. |
65 | | RF_NoModuleLevelChanges = 1, |
66 | | |
67 | | /// If this flag is set, the remapper ignores missing function-local entries |
68 | | /// (Argument, Instruction, BasicBlock) that are not in the value map. If it |
69 | | /// is unset, it aborts if an operand is asked to be remapped which doesn't |
70 | | /// exist in the mapping. |
71 | | /// |
72 | | /// There are no such assertions in MapValue(), whose results are almost |
73 | | /// unchanged by this flag. This flag mainly changes the assertion behaviour |
74 | | /// in RemapInstruction(). |
75 | | /// |
76 | | /// Since an Instruction's metadata operands (even that point to SSA values) |
77 | | /// aren't guaranteed to be dominated by their definitions, MapMetadata will |
78 | | /// return "!{}" instead of "null" for \a LocalAsMetadata instances whose SSA |
79 | | /// values are unmapped when this flag is set. Otherwise, \a MapValue() |
80 | | /// completely ignores this flag. |
81 | | /// |
82 | | /// \a MapMetadata() always ignores this flag. |
83 | | RF_IgnoreMissingLocals = 2, |
84 | | |
85 | | /// Instruct the remapper to move distinct metadata instead of duplicating it |
86 | | /// when there are module-level changes. |
87 | | RF_MoveDistinctMDs = 4, |
88 | | |
89 | | /// Any global values not in value map are mapped to null instead of mapping |
90 | | /// to self. Illegal if RF_IgnoreMissingLocals is also set. |
91 | | RF_NullMapMissingGlobalValues = 8, |
92 | | }; |
93 | | |
94 | 813k | static inline RemapFlags operator|(RemapFlags LHS, RemapFlags RHS) { |
95 | 813k | return RemapFlags(unsigned(LHS) | unsigned(RHS)); |
96 | 813k | } Unexecuted instantiation: opt.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Unexecuted instantiation: AMDGPUAlwaysInlinePass.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Unexecuted instantiation: AMDGPUOpenCLImageTypeLoweringPass.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Unexecuted instantiation: NVPTXGenericToNVVM.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Unexecuted instantiation: CodeGenPrepare.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) WinEHPrepare.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Line | Count | Source | 94 | 82 | static inline RemapFlags operator|(RemapFlags LHS, RemapFlags RHS) { | 95 | 82 | return RemapFlags(unsigned(LHS) | unsigned(RHS)); | 96 | 82 | } |
Unexecuted instantiation: CoroSplit.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Unexecuted instantiation: AlwaysInliner.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Unexecuted instantiation: Inliner.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Unexecuted instantiation: PartialInlining.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Unexecuted instantiation: SampleProfile.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Unexecuted instantiation: ThinLTOBitcodeWriter.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Unexecuted instantiation: AddressSanitizer.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) InductiveRangeCheckElimination.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Line | Count | Source | 94 | 438 | static inline RemapFlags operator|(RemapFlags LHS, RemapFlags RHS) { | 95 | 438 | return RemapFlags(unsigned(LHS) | unsigned(RHS)); | 96 | 438 | } |
Unexecuted instantiation: InferAddressSpaces.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Unexecuted instantiation: JumpThreading.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Unexecuted instantiation: LoopDataPrefetch.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Unexecuted instantiation: LoopDistribute.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Unexecuted instantiation: LoopLoadElimination.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) LoopRotation.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Line | Count | Source | 94 | 142k | static inline RemapFlags operator|(RemapFlags LHS, RemapFlags RHS) { | 95 | 142k | return RemapFlags(unsigned(LHS) | unsigned(RHS)); | 96 | 142k | } |
LoopUnswitch.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Line | Count | Source | 94 | 615k | static inline RemapFlags operator|(RemapFlags LHS, RemapFlags RHS) { | 95 | 615k | return RemapFlags(unsigned(LHS) | unsigned(RHS)); | 96 | 615k | } |
Unexecuted instantiation: LoopVersioningLICM.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Unexecuted instantiation: PlaceSafepoints.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) CloneFunction.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Line | Count | Source | 94 | 7.79k | static inline RemapFlags operator|(RemapFlags LHS, RemapFlags RHS) { | 95 | 7.79k | return RemapFlags(unsigned(LHS) | unsigned(RHS)); | 96 | 7.79k | } |
Unexecuted instantiation: CloneModule.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Unexecuted instantiation: InlineFunction.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Unexecuted instantiation: LoopUnroll.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Unexecuted instantiation: LoopUnrollPeel.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) LoopUnrollRuntime.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Line | Count | Source | 94 | 8.42k | static inline RemapFlags operator|(RemapFlags LHS, RemapFlags RHS) { | 95 | 8.42k | return RemapFlags(unsigned(LHS) | unsigned(RHS)); | 96 | 8.42k | } |
Unexecuted instantiation: LoopVersioning.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) SimplifyCFG.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Line | Count | Source | 94 | 37.2k | static inline RemapFlags operator|(RemapFlags LHS, RemapFlags RHS) { | 95 | 37.2k | return RemapFlags(unsigned(LHS) | unsigned(RHS)); | 96 | 37.2k | } |
ValueMapper.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Line | Count | Source | 94 | 876 | static inline RemapFlags operator|(RemapFlags LHS, RemapFlags RHS) { | 95 | 876 | return RemapFlags(unsigned(LHS) | unsigned(RHS)); | 96 | 876 | } |
Unexecuted instantiation: LoopVectorize.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) IRMover.cpp:llvm::operator|(llvm::RemapFlags, llvm::RemapFlags) Line | Count | Source | 94 | 877 | static inline RemapFlags operator|(RemapFlags LHS, RemapFlags RHS) { | 95 | 877 | return RemapFlags(unsigned(LHS) | unsigned(RHS)); | 96 | 877 | } |
|
97 | | |
98 | | /// Context for (re-)mapping values (and metadata). |
99 | | /// |
100 | | /// A shared context used for mapping and remapping of Value and Metadata |
101 | | /// instances using \a ValueToValueMapTy, \a RemapFlags, \a |
102 | | /// ValueMapTypeRemapper, and \a ValueMaterializer. |
103 | | /// |
104 | | /// There are a number of top-level entry points: |
105 | | /// - \a mapValue() (and \a mapConstant()); |
106 | | /// - \a mapMetadata() (and \a mapMDNode()); |
107 | | /// - \a remapInstruction(); and |
108 | | /// - \a remapFunction(). |
109 | | /// |
110 | | /// The \a ValueMaterializer can be used as a callback, but cannot invoke any |
111 | | /// of these top-level functions recursively. Instead, callbacks should use |
112 | | /// one of the following to schedule work lazily in the \a ValueMapper |
113 | | /// instance: |
114 | | /// - \a scheduleMapGlobalInitializer() |
115 | | /// - \a scheduleMapAppendingVariable() |
116 | | /// - \a scheduleMapGlobalAliasee() |
117 | | /// - \a scheduleRemapFunction() |
118 | | /// |
119 | | /// Sometimes a callback needs a different mapping context. Such a context can |
120 | | /// be registered using \a registerAlternateMappingContext(), which takes an |
121 | | /// alternate \a ValueToValueMapTy and \a ValueMaterializer and returns a ID to |
122 | | /// pass into the schedule*() functions. |
123 | | /// |
124 | | /// TODO: lib/Linker really doesn't need the \a ValueHandle in the \a |
125 | | /// ValueToValueMapTy. We should template \a ValueMapper (and its |
126 | | /// implementation classes), and explicitly instantiate on two concrete |
127 | | /// instances of \a ValueMap (one as \a ValueToValueMap, and one with raw \a |
128 | | /// Value pointers). It may be viable to do away with \a TrackingMDRef in the |
129 | | /// \a Metadata side map for the lib/Linker case as well, in which case we'll |
130 | | /// need a new template parameter on \a ValueMap. |
131 | | /// |
132 | | /// TODO: Update callers of \a RemapInstruction() and \a MapValue() (etc.) to |
133 | | /// use \a ValueMapper directly. |
134 | | class ValueMapper { |
135 | | void *pImpl; |
136 | | |
137 | | public: |
138 | | ValueMapper(ValueToValueMapTy &VM, RemapFlags Flags = RF_None, |
139 | | ValueMapTypeRemapper *TypeMapper = nullptr, |
140 | | ValueMaterializer *Materializer = nullptr); |
141 | | ValueMapper(ValueMapper &&) = delete; |
142 | | ValueMapper(const ValueMapper &) = delete; |
143 | | ValueMapper &operator=(ValueMapper &&) = delete; |
144 | | ValueMapper &operator=(const ValueMapper &) = delete; |
145 | | ~ValueMapper(); |
146 | | |
147 | | /// Register an alternate mapping context. |
148 | | /// |
149 | | /// Returns a MappingContextID that can be used with the various schedule*() |
150 | | /// API to switch in a different value map on-the-fly. |
151 | | unsigned |
152 | | registerAlternateMappingContext(ValueToValueMapTy &VM, |
153 | | ValueMaterializer *Materializer = nullptr); |
154 | | |
155 | | /// Add to the current \a RemapFlags. |
156 | | /// |
157 | | /// \note Like the top-level mapping functions, \a addFlags() must be called |
158 | | /// at the top level, not during a callback in a \a ValueMaterializer. |
159 | | void addFlags(RemapFlags Flags); |
160 | | |
161 | | Metadata *mapMetadata(const Metadata &MD); |
162 | | MDNode *mapMDNode(const MDNode &N); |
163 | | |
164 | | Value *mapValue(const Value &V); |
165 | | Constant *mapConstant(const Constant &C); |
166 | | |
167 | | void remapInstruction(Instruction &I); |
168 | | void remapFunction(Function &F); |
169 | | |
170 | | void scheduleMapGlobalInitializer(GlobalVariable &GV, Constant &Init, |
171 | | unsigned MappingContextID = 0); |
172 | | void scheduleMapAppendingVariable(GlobalVariable &GV, Constant *InitPrefix, |
173 | | bool IsOldCtorDtor, |
174 | | ArrayRef<Constant *> NewMembers, |
175 | | unsigned MappingContextID = 0); |
176 | | void scheduleMapGlobalAliasee(GlobalAlias &GA, Constant &Aliasee, |
177 | | unsigned MappingContextID = 0); |
178 | | void scheduleRemapFunction(Function &F, unsigned MappingContextID = 0); |
179 | | }; |
180 | | |
181 | | /// Look up or compute a value in the value map. |
182 | | /// |
183 | | /// Return a mapped value for a function-local value (Argument, Instruction, |
184 | | /// BasicBlock), or compute and memoize a value for a Constant. |
185 | | /// |
186 | | /// 1. If \c V is in VM, return the result. |
187 | | /// 2. Else if \c V can be materialized with \c Materializer, do so, memoize |
188 | | /// it in \c VM, and return it. |
189 | | /// 3. Else if \c V is a function-local value, return nullptr. |
190 | | /// 4. Else if \c V is a \a GlobalValue, return \c nullptr or \c V depending |
191 | | /// on \a RF_NullMapMissingGlobalValues. |
192 | | /// 5. Else if \c V is a \a MetadataAsValue wrapping a LocalAsMetadata, |
193 | | /// recurse on the local SSA value, and return nullptr or "metadata !{}" on |
194 | | /// missing depending on RF_IgnoreMissingValues. |
195 | | /// 6. Else if \c V is a \a MetadataAsValue, rewrap the return of \a |
196 | | /// MapMetadata(). |
197 | | /// 7. Else, compute the equivalent constant, and return it. |
198 | | inline Value *MapValue(const Value *V, ValueToValueMapTy &VM, |
199 | | RemapFlags Flags = RF_None, |
200 | | ValueMapTypeRemapper *TypeMapper = nullptr, |
201 | 370k | ValueMaterializer *Materializer = nullptr) { |
202 | 370k | return ValueMapper(VM, Flags, TypeMapper, Materializer).mapValue(*V); |
203 | 370k | } |
204 | | |
205 | | /// Lookup or compute a mapping for a piece of metadata. |
206 | | /// |
207 | | /// Compute and memoize a mapping for \c MD. |
208 | | /// |
209 | | /// 1. If \c MD is mapped, return it. |
210 | | /// 2. Else if \a RF_NoModuleLevelChanges or \c MD is an \a MDString, return |
211 | | /// \c MD. |
212 | | /// 3. Else if \c MD is a \a ConstantAsMetadata, call \a MapValue() and |
213 | | /// re-wrap its return (returning nullptr on nullptr). |
214 | | /// 4. Else, \c MD is an \a MDNode. These are remapped, along with their |
215 | | /// transitive operands. Distinct nodes are duplicated or moved depending |
216 | | /// on \a RF_MoveDistinctNodes. Uniqued nodes are remapped like constants. |
217 | | /// |
218 | | /// \note \a LocalAsMetadata is completely unsupported by \a MapMetadata. |
219 | | /// Instead, use \a MapValue() with its wrapping \a MetadataAsValue instance. |
220 | | inline Metadata *MapMetadata(const Metadata *MD, ValueToValueMapTy &VM, |
221 | | RemapFlags Flags = RF_None, |
222 | | ValueMapTypeRemapper *TypeMapper = nullptr, |
223 | 0 | ValueMaterializer *Materializer = nullptr) { |
224 | 0 | return ValueMapper(VM, Flags, TypeMapper, Materializer).mapMetadata(*MD); |
225 | 0 | } |
226 | | |
227 | | /// Version of MapMetadata with type safety for MDNode. |
228 | | inline MDNode *MapMetadata(const MDNode *MD, ValueToValueMapTy &VM, |
229 | | RemapFlags Flags = RF_None, |
230 | | ValueMapTypeRemapper *TypeMapper = nullptr, |
231 | 613 | ValueMaterializer *Materializer = nullptr) { |
232 | 613 | return ValueMapper(VM, Flags, TypeMapper, Materializer).mapMDNode(*MD); |
233 | 613 | } |
234 | | |
235 | | /// Convert the instruction operands from referencing the current values into |
236 | | /// those specified by VM. |
237 | | /// |
238 | | /// If \a RF_IgnoreMissingLocals is set and an operand can't be found via \a |
239 | | /// MapValue(), use the old value. Otherwise assert that this doesn't happen. |
240 | | /// |
241 | | /// Note that \a MapValue() only returns \c nullptr for SSA values missing from |
242 | | /// \c VM. |
243 | | inline void RemapInstruction(Instruction *I, ValueToValueMapTy &VM, |
244 | | RemapFlags Flags = RF_None, |
245 | | ValueMapTypeRemapper *TypeMapper = nullptr, |
246 | 4.23M | ValueMaterializer *Materializer = nullptr) { |
247 | 4.23M | ValueMapper(VM, Flags, TypeMapper, Materializer).remapInstruction(*I); |
248 | 4.23M | } |
249 | | |
250 | | /// Remap the operands, metadata, arguments, and instructions of a function. |
251 | | /// |
252 | | /// Calls \a MapValue() on prefix data, prologue data, and personality |
253 | | /// function; calls \a MapMetadata() on each attached MDNode; remaps the |
254 | | /// argument types using the provided \c TypeMapper; and calls \a |
255 | | /// RemapInstruction() on every instruction. |
256 | | inline void RemapFunction(Function &F, ValueToValueMapTy &VM, |
257 | | RemapFlags Flags = RF_None, |
258 | | ValueMapTypeRemapper *TypeMapper = nullptr, |
259 | 0 | ValueMaterializer *Materializer = nullptr) { |
260 | 0 | ValueMapper(VM, Flags, TypeMapper, Materializer).remapFunction(F); |
261 | 0 | } |
262 | | |
263 | | /// Version of MapValue with type safety for Constant. |
264 | | inline Constant *MapValue(const Constant *V, ValueToValueMapTy &VM, |
265 | | RemapFlags Flags = RF_None, |
266 | | ValueMapTypeRemapper *TypeMapper = nullptr, |
267 | 120 | ValueMaterializer *Materializer = nullptr) { |
268 | 120 | return ValueMapper(VM, Flags, TypeMapper, Materializer).mapConstant(*V); |
269 | 120 | } |
270 | | |
271 | | } // end namespace llvm |
272 | | |
273 | | #endif // LLVM_TRANSFORMS_UTILS_VALUEMAPPER_H |