1 files changed, 249 insertions, 111 deletions

diff --git a/include/llvm/Transforms/Utils/ValueMapper.h b/include/llvm/Transforms/Utils/ValueMapper.h
index 469022f34c56..de649009612c 100644
--- a/include/llvm/Transforms/Utils/ValueMapper.h
+++ b/include/llvm/Transforms/Utils/ValueMapper.h
@@ -18,117 +18,255 @@
 #include "llvm/IR/ValueMap.h"
 
 namespace llvm {
-  class Value;
-  class Instruction;
-  typedef ValueMap<const Value *, WeakVH> ValueToValueMapTy;
-
-  /// ValueMapTypeRemapper - This is a class that can be implemented by clients
-  /// to remap types when cloning constants and instructions.
-  class ValueMapTypeRemapper {
-    virtual void anchor();  // Out of line method.
-  public:
-    virtual ~ValueMapTypeRemapper() {}
-
-    /// remapType - The client should implement this method if they want to
-    /// remap types while mapping values.
-    virtual Type *remapType(Type *SrcTy) = 0;
-  };
-
-  /// ValueMaterializer - This is a class that can be implemented by clients
-  /// to materialize Values on demand.
-  class ValueMaterializer {
-    virtual void anchor(); // Out of line method.
-
-  protected:
-    ~ValueMaterializer() = default;
-    ValueMaterializer() = default;
-    ValueMaterializer(const ValueMaterializer&) = default;
-    ValueMaterializer &operator=(const ValueMaterializer&) = default;
-
-  public:
-    /// The client should implement this method if they want to generate a
-    /// mapped Value on demand. For example, if linking lazily.
-    virtual Value *materializeDeclFor(Value *V) = 0;
-
-    /// If the data being mapped is recursive, the above function can map
-    /// just the declaration and this is called to compute the initializer.
-    /// It is called after the mapping is recorded, so it doesn't need to worry
-    /// about recursion.
-    virtual void materializeInitFor(GlobalValue *New, GlobalValue *Old);
-
-    /// If the client needs to handle temporary metadata it must implement
-    /// these methods.
-    virtual Metadata *mapTemporaryMetadata(Metadata *MD) { return nullptr; }
-    virtual void replaceTemporaryMetadata(const Metadata *OrigMD,
-                                          Metadata *NewMD) {}
-
-    /// The client should implement this method if some metadata need
-    /// not be mapped, for example DISubprogram metadata for functions not
-    /// linked into the destination module.
-    virtual bool isMetadataNeeded(Metadata *MD) { return true; }
-  };
-
-  /// RemapFlags - These are flags that the value mapping APIs allow.
-  enum RemapFlags {
-    RF_None = 0,
-
-    /// RF_NoModuleLevelChanges - If this flag is set, the remapper knows that
-    /// only local values within a function (such as an instruction or argument)
-    /// are mapped, not global values like functions and global metadata.
-    RF_NoModuleLevelChanges = 1,
-
-    /// RF_IgnoreMissingEntries - If this flag is set, the remapper ignores
-    /// entries that are not in the value map.  If it is unset, it aborts if an
-    /// operand is asked to be remapped which doesn't exist in the mapping.
-    RF_IgnoreMissingEntries = 2,
-
-    /// Instruct the remapper to move distinct metadata instead of duplicating
-    /// it when there are module-level changes.
-    RF_MoveDistinctMDs = 4,
-
-    /// Any global values not in value map are mapped to null instead of
-    /// mapping to self. Illegal if RF_IgnoreMissingEntries is also set.
-    RF_NullMapMissingGlobalValues = 8,
-
-    /// Set when there is still temporary metadata that must be handled,
-    /// such as when we are doing function importing and will materialize
-    /// and link metadata as a postpass.
-    RF_HaveUnmaterializedMetadata = 16,
-  };
-
-  static inline RemapFlags operator|(RemapFlags LHS, RemapFlags RHS) {
-    return RemapFlags(unsigned(LHS)|unsigned(RHS));
-  }
-
-  Value *MapValue(const Value *V, ValueToValueMapTy &VM,
-                  RemapFlags Flags = RF_None,
-                  ValueMapTypeRemapper *TypeMapper = nullptr,
-                  ValueMaterializer *Materializer = nullptr);
-
-  Metadata *MapMetadata(const Metadata *MD, ValueToValueMapTy &VM,
-                        RemapFlags Flags = RF_None,
-                        ValueMapTypeRemapper *TypeMapper = nullptr,
-                        ValueMaterializer *Materializer = nullptr);
-
-  /// MapMetadata - provide versions that preserve type safety for MDNodes.
-  MDNode *MapMetadata(const MDNode *MD, ValueToValueMapTy &VM,
-                      RemapFlags Flags = RF_None,
-                      ValueMapTypeRemapper *TypeMapper = nullptr,
-                      ValueMaterializer *Materializer = nullptr);
-
-  void RemapInstruction(Instruction *I, ValueToValueMapTy &VM,
-                        RemapFlags Flags = RF_None,
-                        ValueMapTypeRemapper *TypeMapper = nullptr,
-                        ValueMaterializer *Materializer = nullptr);
-
-  /// MapValue - provide versions that preserve type safety for Constants.
-  inline Constant *MapValue(const Constant *V, ValueToValueMapTy &VM,
-                            RemapFlags Flags = RF_None,
-                            ValueMapTypeRemapper *TypeMapper = nullptr,
-                            ValueMaterializer *Materializer = nullptr) {
-    return cast<Constant>(MapValue((const Value*)V, VM, Flags, TypeMapper,
-                                   Materializer));
-  }
+
+class Value;
+class Instruction;
+typedef ValueMap<const Value *, WeakVH> ValueToValueMapTy;
+
+/// This is a class that can be implemented by clients to remap types when
+/// cloning constants and instructions.
+class ValueMapTypeRemapper {
+  virtual void anchor(); // Out of line method.
+public:
+  virtual ~ValueMapTypeRemapper() {}
+
+  /// The client should implement this method if they want to remap types while
+  /// mapping values.
+  virtual Type *remapType(Type *SrcTy) = 0;
+};
+
+/// This is a class that can be implemented by clients to materialize Values on
+/// demand.
+class ValueMaterializer {
+  virtual void anchor(); // Out of line method.
+
+protected:
+  ~ValueMaterializer() = default;
+  ValueMaterializer() = default;
+  ValueMaterializer(const ValueMaterializer &) = default;
+  ValueMaterializer &operator=(const ValueMaterializer &) = default;
+
+public:
+  /// This method can be implemented to generate a mapped Value on demand. For
+  /// example, if linking lazily. Returns null if the value is not materialized.
+  virtual Value *materialize(Value *V) = 0;
+};
+
+/// These are flags that the value mapping APIs allow.
+enum RemapFlags {
+  RF_None = 0,
+
+  /// If this flag is set, the remapper knows that only local values within a
+  /// function (such as an instruction or argument) are mapped, not global
+  /// values like functions and global metadata.
+  RF_NoModuleLevelChanges = 1,
+
+  /// If this flag is set, the remapper ignores missing function-local entries
+  /// (Argument, Instruction, BasicBlock) that are not in the value map.  If it
+  /// is unset, it aborts if an operand is asked to be remapped which doesn't
+  /// exist in the mapping.
+  ///
+  /// There are no such assertions in MapValue(), whose results are almost
+  /// unchanged by this flag.  This flag mainly changes the assertion behaviour
+  /// in RemapInstruction().
+  ///
+  /// Since an Instruction's metadata operands (even that point to SSA values)
+  /// aren't guaranteed to be dominated by their definitions, MapMetadata will
+  /// return "!{}" instead of "null" for \a LocalAsMetadata instances whose SSA
+  /// values are unmapped when this flag is set.  Otherwise, \a MapValue()
+  /// completely ignores this flag.
+  ///
+  /// \a MapMetadata() always ignores this flag.
+  RF_IgnoreMissingLocals = 2,
+
+  /// Instruct the remapper to move distinct metadata instead of duplicating it
+  /// when there are module-level changes.
+  RF_MoveDistinctMDs = 4,
+
+  /// Any global values not in value map are mapped to null instead of mapping
+  /// to self.  Illegal if RF_IgnoreMissingLocals is also set.
+  RF_NullMapMissingGlobalValues = 8,
+};
+
+static inline RemapFlags operator|(RemapFlags LHS, RemapFlags RHS) {
+  return RemapFlags(unsigned(LHS) | unsigned(RHS));
+}
+
+class ValueMapperImpl;
+
+/// Context for (re-)mapping values (and metadata).
+///
+/// A shared context used for mapping and remapping of Value and Metadata
+/// instances using \a ValueToValueMapTy, \a RemapFlags, \a
+/// ValueMapTypeRemapper, and \a ValueMaterializer.
+///
+/// There are a number of top-level entry points:
+/// - \a mapValue() (and \a mapConstant());
+/// - \a mapMetadata() (and \a mapMDNode());
+/// - \a remapInstruction(); and
+/// - \a remapFunction().
+///
+/// The \a ValueMaterializer can be used as a callback, but cannot invoke any
+/// of these top-level functions recursively.  Instead, callbacks should use
+/// one of the following to schedule work lazily in the \a ValueMapper
+/// instance:
+/// - \a scheduleMapGlobalInitializer()
+/// - \a scheduleMapAppendingVariable()
+/// - \a scheduleMapGlobalAliasee()
+/// - \a scheduleRemapFunction()
+///
+/// Sometimes a callback needs a diferent mapping context.  Such a context can
+/// be registered using \a registerAlternateMappingContext(), which takes an
+/// alternate \a ValueToValueMapTy and \a ValueMaterializer and returns a ID to
+/// pass into the schedule*() functions.
+///
+/// TODO: lib/Linker really doesn't need the \a ValueHandle in the \a
+/// ValueToValueMapTy.  We should template \a ValueMapper (and its
+/// implementation classes), and explicitly instantiate on two concrete
+/// instances of \a ValueMap (one as \a ValueToValueMap, and one with raw \a
+/// Value pointers).  It may be viable to do away with \a TrackingMDRef in the
+/// \a Metadata side map for the lib/Linker case as well, in which case we'll
+/// need a new template parameter on \a ValueMap.
+///
+/// TODO: Update callers of \a RemapInstruction() and \a MapValue() (etc.) to
+/// use \a ValueMapper directly.
+class ValueMapper {
+  void *pImpl;
+
+  ValueMapper(ValueMapper &&) = delete;
+  ValueMapper(const ValueMapper &) = delete;
+  ValueMapper &operator=(ValueMapper &&) = delete;
+  ValueMapper &operator=(const ValueMapper &) = delete;
+
+public:
+  ValueMapper(ValueToValueMapTy &VM, RemapFlags Flags = RF_None,
+              ValueMapTypeRemapper *TypeMapper = nullptr,
+              ValueMaterializer *Materializer = nullptr);
+  ~ValueMapper();
+
+  /// Register an alternate mapping context.
+  ///
+  /// Returns a MappingContextID that can be used with the various schedule*()
+  /// API to switch in a different value map on-the-fly.
+  unsigned
+  registerAlternateMappingContext(ValueToValueMapTy &VM,
+                                  ValueMaterializer *Materializer = nullptr);
+
+  /// Add to the current \a RemapFlags.
+  ///
+  /// \note Like the top-level mapping functions, \a addFlags() must be called
+  /// at the top level, not during a callback in a \a ValueMaterializer.
+  void addFlags(RemapFlags Flags);
+
+  Metadata *mapMetadata(const Metadata &MD);
+  MDNode *mapMDNode(const MDNode &N);
+
+  Value *mapValue(const Value &V);
+  Constant *mapConstant(const Constant &C);
+
+  void remapInstruction(Instruction &I);
+  void remapFunction(Function &F);
+
+  void scheduleMapGlobalInitializer(GlobalVariable &GV, Constant &Init,
+                                    unsigned MappingContextID = 0);
+  void scheduleMapAppendingVariable(GlobalVariable &GV, Constant *InitPrefix,
+                                    bool IsOldCtorDtor,
+                                    ArrayRef<Constant *> NewMembers,
+                                    unsigned MappingContextID = 0);
+  void scheduleMapGlobalAliasee(GlobalAlias &GA, Constant &Aliasee,
+                                unsigned MappingContextID = 0);
+  void scheduleRemapFunction(Function &F, unsigned MappingContextID = 0);
+};
+
+/// Look up or compute a value in the value map.
+///
+/// Return a mapped value for a function-local value (Argument, Instruction,
+/// BasicBlock), or compute and memoize a value for a Constant.
+///
+///  1. If \c V is in VM, return the result.
+///  2. Else if \c V can be materialized with \c Materializer, do so, memoize
+///     it in \c VM, and return it.
+///  3. Else if \c V is a function-local value, return nullptr.
+///  4. Else if \c V is a \a GlobalValue, return \c nullptr or \c V depending
+///     on \a RF_NullMapMissingGlobalValues.
+///  5. Else if \c V is a \a MetadataAsValue wrapping a LocalAsMetadata,
+///     recurse on the local SSA value, and return nullptr or "metadata !{}" on
+///     missing depending on RF_IgnoreMissingValues.
+///  6. Else if \c V is a \a MetadataAsValue, rewrap the return of \a
+///     MapMetadata().
+///  7. Else, compute the equivalent constant, and return it.
+inline Value *MapValue(const Value *V, ValueToValueMapTy &VM,
+                       RemapFlags Flags = RF_None,
+                       ValueMapTypeRemapper *TypeMapper = nullptr,
+                       ValueMaterializer *Materializer = nullptr) {
+  return ValueMapper(VM, Flags, TypeMapper, Materializer).mapValue(*V);
+}
+
+/// Lookup or compute a mapping for a piece of metadata.
+///
+/// Compute and memoize a mapping for \c MD.
+///
+///  1. If \c MD is mapped, return it.
+///  2. Else if \a RF_NoModuleLevelChanges or \c MD is an \a MDString, return
+///     \c MD.
+///  3. Else if \c MD is a \a ConstantAsMetadata, call \a MapValue() and
+///     re-wrap its return (returning nullptr on nullptr).
+///  4. Else, \c MD is an \a MDNode.  These are remapped, along with their
+///     transitive operands.  Distinct nodes are duplicated or moved depending
+///     on \a RF_MoveDistinctNodes.  Uniqued nodes are remapped like constants.
+///
+/// \note \a LocalAsMetadata is completely unsupported by \a MapMetadata.
+/// Instead, use \a MapValue() with its wrapping \a MetadataAsValue instance.
+inline Metadata *MapMetadata(const Metadata *MD, ValueToValueMapTy &VM,
+                             RemapFlags Flags = RF_None,
+                             ValueMapTypeRemapper *TypeMapper = nullptr,
+                             ValueMaterializer *Materializer = nullptr) {
+  return ValueMapper(VM, Flags, TypeMapper, Materializer).mapMetadata(*MD);
+}
+
+/// Version of MapMetadata with type safety for MDNode.
+inline MDNode *MapMetadata(const MDNode *MD, ValueToValueMapTy &VM,
+                           RemapFlags Flags = RF_None,
+                           ValueMapTypeRemapper *TypeMapper = nullptr,
+                           ValueMaterializer *Materializer = nullptr) {
+  return ValueMapper(VM, Flags, TypeMapper, Materializer).mapMDNode(*MD);
+}
+
+/// Convert the instruction operands from referencing the current values into
+/// those specified by VM.
+///
+/// If \a RF_IgnoreMissingLocals is set and an operand can't be found via \a
+/// MapValue(), use the old value.  Otherwise assert that this doesn't happen.
+///
+/// Note that \a MapValue() only returns \c nullptr for SSA values missing from
+/// \c VM.
+inline void RemapInstruction(Instruction *I, ValueToValueMapTy &VM,
+                             RemapFlags Flags = RF_None,
+                             ValueMapTypeRemapper *TypeMapper = nullptr,
+                             ValueMaterializer *Materializer = nullptr) {
+  ValueMapper(VM, Flags, TypeMapper, Materializer).remapInstruction(*I);
+}
+
+/// Remap the operands, metadata, arguments, and instructions of a function.
+///
+/// Calls \a MapValue() on prefix data, prologue data, and personality
+/// function; calls \a MapMetadata() on each attached MDNode; remaps the
+/// argument types using the provided \c TypeMapper; and calls \a
+/// RemapInstruction() on every instruction.
+inline void RemapFunction(Function &F, ValueToValueMapTy &VM,
+                          RemapFlags Flags = RF_None,
+                          ValueMapTypeRemapper *TypeMapper = nullptr,
+                          ValueMaterializer *Materializer = nullptr) {
+  ValueMapper(VM, Flags, TypeMapper, Materializer).remapFunction(F);
+}
+
+/// Version of MapValue with type safety for Constant.
+inline Constant *MapValue(const Constant *V, ValueToValueMapTy &VM,
+                          RemapFlags Flags = RF_None,
+                          ValueMapTypeRemapper *TypeMapper = nullptr,
+                          ValueMaterializer *Materializer = nullptr) {
+  return ValueMapper(VM, Flags, TypeMapper, Materializer).mapConstant(*V);
+}
 
 } // End llvm namespace