Coverage Report

Created: 2019-07-24 05:18

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