ValueMapper: Treat LocalAsMetadata more like function-local Values

This is a partial re-commit -- maybe more of a re-implementation -- of
r265631 (reverted in r265637).

This makes RF_IgnoreMissingLocals behave (almost) consistently between
the Value and the Metadata hierarchy.  In particular:

  - MapValue returns nullptr or "metadata !{}" for missing locals in
    MetadataAsValue/LocalAsMetadata bridging paris, depending on
    the RF_IgnoreMissingLocals flag.

  - MapValue doesn't memoize LocalAsMetadata-related results.

  - MapMetadata no longer deals with LocalAsMetadata or
    RF_IgnoreMissingLocals at all.  (This wasn't in r265631 at all, but
    I realized during testing it would make the patch simpler with no
    loss of generality.)

r265631 went too far, making both functions universally ignore
RF_IgnoreMissingLocals.  This broke building (e.g.) compiler-rt.
Reassociate (and possibly other passes) don't currently maintain
dominates-use invariants for metadata operands, resulting in IR like
this:

    define void @foo(i32 %arg) {
      call void @llvm.some.intrinsic(metadata i32 %x)
      %x = add i32 1, i32 %arg
    }

If the inliner chooses to inline @foo into another function, then
RemapInstruction will call `MapValue(metadata i32 %x)` and assert that
the return is not nullptr.

I've filed PR27273 to add a Verifier check and fix the underlying
problem in the optimization passes.

As a workaround, return `!{}` instead of nullptr for unmapped
LocalAsMetadata when RF_IgnoreMissingLocals is unset.  Otherwise, match
the behaviour of r265631.

Original commit message:

    ValueMapper: Make LocalAsMetadata match function-local Values

    Start treating LocalAsMetadata similarly to function-local members of
    the Value hierarchy in MapValue and MapMetadata.

      - Don't memoize them.
      - Return nullptr if they are missing.

    This also cleans up ConstantAsMetadata to stop listening to the
    RF_IgnoreMissingLocals flag.

llvm-svn: 265759

1 files changed, 35 insertions, 7 deletions

diff --git a/llvm/include/llvm/Transforms/Utils/ValueMapper.h b/llvm/include/llvm/Transforms/Utils/ValueMapper.h
index e8023bd3df9..e4dedfe699c 100644
--- a/llvm/include/llvm/Transforms/Utils/ValueMapper.h
+++ b/llvm/include/llvm/Transforms/Utils/ValueMapper.h
@@ -68,13 +68,21 @@ enum RemapFlags {
   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.
+  /// (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 result should be
-  /// essentially unchanged by this flag.  This only changes the assertion
-  /// behaviour in RemapInstruction().
+  /// 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
@@ -101,12 +109,32 @@ static inline RemapFlags operator|(RemapFlags LHS, RemapFlags RHS) {
 ///  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, Compute the equivalent constant, and return it.
+///  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.
 Value *MapValue(const Value *V, ValueToValueMapTy &VM,
                 RemapFlags Flags = RF_None,
                 ValueMapTypeRemapper *TypeMapper = nullptr,
                 ValueMaterializer *Materializer = nullptr);
 
+/// 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.
 Metadata *MapMetadata(const Metadata *MD, ValueToValueMapTy &VM,
                       RemapFlags Flags = RF_None,
                       ValueMapTypeRemapper *TypeMapper = nullptr,