[llvm] r224566 - Rename MapValue(Metadata*) to MapMetadata()

Duncan P. N. Exon Smith dexonsmith at apple.com
Thu Dec 18 22:06:19 PST 2014


Author: dexonsmith
Date: Fri Dec 19 00:06:18 2014
New Revision: 224566

URL: http://llvm.org/viewvc/llvm-project?rev=224566&view=rev
Log:
Rename MapValue(Metadata*) to MapMetadata()

Instead of reusing the name `MapValue()` when mapping `Metadata`, use
`MapMetadata()`.  The old name doesn't make much sense after the
`Metadata`/`Value` split.

Modified:
    llvm/trunk/include/llvm/Transforms/Utils/ValueMapper.h
    llvm/trunk/lib/Linker/LinkModules.cpp
    llvm/trunk/lib/Transforms/Utils/CloneFunction.cpp
    llvm/trunk/lib/Transforms/Utils/CloneModule.cpp
    llvm/trunk/lib/Transforms/Utils/ValueMapper.cpp

Modified: llvm/trunk/include/llvm/Transforms/Utils/ValueMapper.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Transforms/Utils/ValueMapper.h?rev=224566&r1=224565&r2=224566&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Transforms/Utils/ValueMapper.h (original)
+++ llvm/trunk/include/llvm/Transforms/Utils/ValueMapper.h Fri Dec 19 00:06:18 2014
@@ -71,16 +71,16 @@ namespace llvm {
                   ValueMapTypeRemapper *TypeMapper = nullptr,
                   ValueMaterializer *Materializer = nullptr);
 
-  Metadata *MapValue(const Metadata *MD, 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);
 
-  /// MapValue - provide versions that preserve type safety for MDNodes.
-  MDNode *MapValue(const MDNode *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,

Modified: llvm/trunk/lib/Linker/LinkModules.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Linker/LinkModules.cpp?rev=224566&r1=224565&r2=224566&view=diff
==============================================================================
--- llvm/trunk/lib/Linker/LinkModules.cpp (original)
+++ llvm/trunk/lib/Linker/LinkModules.cpp Fri Dec 19 00:06:18 2014
@@ -1248,8 +1248,8 @@ void ModuleLinker::linkNamedMDNodes() {
     NamedMDNode *DestNMD = DstM->getOrInsertNamedMetadata(I->getName());
     // Add Src elements into Dest node.
     for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i)
-      DestNMD->addOperand(MapValue(I->getOperand(i), ValueMap,
-                                   RF_None, &TypeMap, &ValMaterializer));
+      DestNMD->addOperand(MapMetadata(I->getOperand(i), ValueMap, RF_None,
+                                      &TypeMap, &ValMaterializer));
   }
 }
 
@@ -1257,7 +1257,7 @@ void ModuleLinker::linkNamedMDNodes() {
 ///
 /// FIXME: this creates an asymmetric result: we strip losing subprograms from
 /// DstM, but leave losing subprograms in SrcM.  Instead we should also strip
-/// losers from SrcM, but this requires extra plumbing in MapValue.
+/// losers from SrcM, but this requires extra plumbing in MapMetadata.
 void ModuleLinker::stripReplacedSubprograms() {
   // Avoid quadratic runtime by returning early when there's nothing to do.
   if (OverridingFunctions.empty())

Modified: llvm/trunk/lib/Transforms/Utils/CloneFunction.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/CloneFunction.cpp?rev=224566&r1=224565&r2=224566&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Utils/CloneFunction.cpp (original)
+++ llvm/trunk/lib/Transforms/Utils/CloneFunction.cpp Fri Dec 19 00:06:18 2014
@@ -186,7 +186,7 @@ static void CloneDebugInfoMetadata(Funct
   // Ensure that OldFunc appears in the map.
   // (if it's already there it must point to NewFunc anyway)
   VMap[OldFunc] = NewFunc;
-  DISubprogram NewSubprogram(MapValue(OldSubprogramMDNode, VMap));
+  DISubprogram NewSubprogram(MapMetadata(OldSubprogramMDNode, VMap));
 
   for (DICompileUnit CU : Finder.compile_units()) {
     DIArray Subprograms(CU.getSubprograms());

Modified: llvm/trunk/lib/Transforms/Utils/CloneModule.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/CloneModule.cpp?rev=224566&r1=224565&r2=224566&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Utils/CloneModule.cpp (original)
+++ llvm/trunk/lib/Transforms/Utils/CloneModule.cpp Fri Dec 19 00:06:18 2014
@@ -118,7 +118,7 @@ Module *llvm::CloneModule(const Module *
     const NamedMDNode &NMD = *I;
     NamedMDNode *NewNMD = New->getOrInsertNamedMetadata(NMD.getName());
     for (unsigned i = 0, e = NMD.getNumOperands(); i != e; ++i)
-      NewNMD->addOperand(MapValue(NMD.getOperand(i), VMap));
+      NewNMD->addOperand(MapMetadata(NMD.getOperand(i), VMap));
   }
 
   return New;

Modified: llvm/trunk/lib/Transforms/Utils/ValueMapper.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/ValueMapper.cpp?rev=224566&r1=224565&r2=224566&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Utils/ValueMapper.cpp (original)
+++ llvm/trunk/lib/Transforms/Utils/ValueMapper.cpp Fri Dec 19 00:06:18 2014
@@ -64,7 +64,7 @@ Value *llvm::MapValue(const Value *V, Va
     if (!isa<LocalAsMetadata>(MD) && (Flags & RF_NoModuleLevelChanges))
       return VM[V] = const_cast<Value *>(V);
 
-    auto *MappedMD = MapValue(MD, VM, Flags, TypeMapper, Materializer);
+    auto *MappedMD = MapMetadata(MD, VM, Flags, TypeMapper, Materializer);
     if (MD == MappedMD || (!MappedMD && (Flags & RF_IgnoreMissingEntries)))
       return VM[V] = const_cast<Value *>(V);
 
@@ -154,10 +154,10 @@ static Metadata *mapToSelf(ValueToValueM
   return mapToMetadata(VM, MD, const_cast<Metadata *>(MD));
 }
 
-static Metadata *MapValueImpl(const Metadata *MD, ValueToValueMapTy &VM,
-                              RemapFlags Flags,
-                              ValueMapTypeRemapper *TypeMapper,
-                              ValueMaterializer *Materializer) {
+static Metadata *MapMetadataImpl(const Metadata *MD, ValueToValueMapTy &VM,
+                                 RemapFlags Flags,
+                                 ValueMapTypeRemapper *TypeMapper,
+                                 ValueMaterializer *Materializer) {
   // If the value already exists in the map, use it.
   if (Metadata *NewMD = VM.MD().lookup(MD).get())
     return NewMD;
@@ -193,7 +193,7 @@ static Metadata *MapValueImpl(const Meta
     if (!Op)
       return nullptr;
     if (Metadata *MappedOp =
-            MapValueImpl(Op, VM, Flags, TypeMapper, Materializer))
+            MapMetadataImpl(Op, VM, Flags, TypeMapper, Materializer))
       return MappedOp;
     // Use identity map if MappedOp is null and we can ignore missing entries.
     if (Flags & RF_IgnoreMissingEntries)
@@ -241,21 +241,21 @@ static Metadata *MapValueImpl(const Meta
   return const_cast<Metadata *>(MD);
 }
 
-Metadata *llvm::MapValue(const Metadata *MD, ValueToValueMapTy &VM,
-                         RemapFlags Flags, ValueMapTypeRemapper *TypeMapper,
-                         ValueMaterializer *Materializer) {
-  Metadata *NewMD = MapValueImpl(MD, VM, Flags, TypeMapper, Materializer);
+Metadata *llvm::MapMetadata(const Metadata *MD, ValueToValueMapTy &VM,
+                            RemapFlags Flags, ValueMapTypeRemapper *TypeMapper,
+                            ValueMaterializer *Materializer) {
+  Metadata *NewMD = MapMetadataImpl(MD, VM, Flags, TypeMapper, Materializer);
   if (NewMD && NewMD != MD)
     if (auto *G = dyn_cast<GenericMDNode>(NewMD))
       G->resolveCycles();
   return NewMD;
 }
 
-MDNode *llvm::MapValue(const MDNode *MD, ValueToValueMapTy &VM,
-                       RemapFlags Flags, ValueMapTypeRemapper *TypeMapper,
-                       ValueMaterializer *Materializer) {
-  return cast<MDNode>(MapValue(static_cast<const Metadata *>(MD), VM, Flags,
-                               TypeMapper, Materializer));
+MDNode *llvm::MapMetadata(const MDNode *MD, ValueToValueMapTy &VM,
+                          RemapFlags Flags, ValueMapTypeRemapper *TypeMapper,
+                          ValueMaterializer *Materializer) {
+  return cast<MDNode>(MapMetadata(static_cast<const Metadata *>(MD), VM, Flags,
+                                  TypeMapper, Materializer));
 }
 
 /// RemapInstruction - Convert the instruction operands from referencing the
@@ -296,7 +296,7 @@ void llvm::RemapInstruction(Instruction
            ME = MDs.end();
        MI != ME; ++MI) {
     MDNode *Old = MI->second;
-    MDNode *New = MapValue(Old, VMap, Flags, TypeMapper, Materializer);
+    MDNode *New = MapMetadata(Old, VMap, Flags, TypeMapper, Materializer);
     if (New != Old)
       I->setMetadata(MI->first, New);
   }





More information about the llvm-commits mailing list