ValueMaterializer: fuse materializeDeclFor and materializeInitFor (NFC)

[mehdi_amini]

Summary

They were originally separated to handle the co-recursion between
the ValueMapper and the ValueMaterializer. This recursion does not
exist anymore: the ValueMapper now uses a Worklist and the
ValueMaterializer is scheduling job on the Worklist.

llvm/trunk/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h

template <typename BaseLayerT,
           typename IndirectStubsMgrT = IndirectStubsManager>
 class CompileOnDemandLayer {
 private:
 
   template <typename MaterializerFtor>
   class LambdaMaterializer final : public ValueMaterializer {
   public:
     LambdaMaterializer(MaterializerFtor M) : M(std::move(M)) {}
-    Value *materializeDeclFor(Value *V) final { return M(V); }
+    Value *materialize(Value *V) final { return M(V); }
 
   private:
     MaterializerFtor M;
   };
 
   template <typename MaterializerFtor>
   LambdaMaterializer<MaterializerFtor>
   createLambdaMaterializer(MaterializerFtor M) {

llvm/trunk/include/llvm/Transforms/Utils/ValueMapper.h

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 *materializeDeclFor(Value *V) = 0;
+  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

llvm/trunk/lib/Linker/IRMover.cpp

 /// Creates prototypes for functions that are lazily linked on the fly. This
 /// speeds up linking for modules with many/ lazily linked functions of which
 /// few get used.
 class GlobalValueMaterializer final : public ValueMaterializer {
   IRLinker &TheIRLinker;
 
 public:
   GlobalValueMaterializer(IRLinker &TheIRLinker) : TheIRLinker(TheIRLinker) {}
-  Value *materializeDeclFor(Value *V) override;
+  Value *materialize(Value *V) override;
 };
 
 class LocalValueMaterializer final : public ValueMaterializer {
   IRLinker &TheIRLinker;
 
 public:
   LocalValueMaterializer(IRLinker &TheIRLinker) : TheIRLinker(TheIRLinker) {}
-  Value *materializeDeclFor(Value *V) override;
+  Value *materialize(Value *V) override;
 };
 
 /// Type of the Metadata map in \a ValueToValueMapTy.
 typedef DenseMap<const Metadata *, TrackingMDRef> MDMapT;
 
 /// This is responsible for keeping track of the state used for moving data
 /// from SrcM to DstM.
 class IRLinker {
if (GlobalValue *ConflictGV = M->getNamedValue(Name)) {
     GV->takeName(ConflictGV);
     ConflictGV->setName(Name); // This will cause ConflictGV to get renamed
     assert(ConflictGV->getName() != Name && "forceRenaming didn't work");
   } else {
     GV->setName(Name); // Force the name back
   }
 }
 
-Value *GlobalValueMaterializer::materializeDeclFor(Value *SGV) {
+Value *GlobalValueMaterializer::materialize(Value *SGV) {
   return TheIRLinker.materialize(SGV, false);
 }
 
-Value *LocalValueMaterializer::materializeDeclFor(Value *SGV) {
+Value *LocalValueMaterializer::materialize(Value *SGV) {
   return TheIRLinker.materialize(SGV, true);
 }
 
 Value *IRLinker::materialize(Value *V, bool ForAlias) {
   auto *SGV = dyn_cast<GlobalValue>(V);
   if (!SGV)
     return nullptr;
 

llvm/trunk/lib/Transforms/Utils/ValueMapper.cpp

Value *Mapper::mapValue(const Value *V) {
   // If the value already exists in the map, use it.
   if (I != getVM().end()) {
     assert(I->second && "Unexpected null mapping");
     return I->second;
   }
 
   // If we have a materializer and it can materialize a value, use that.
   if (auto *Materializer = getMaterializer()) {
-    if (Value *NewV =
-            Materializer->materializeDeclFor(const_cast<Value *>(V))) {
-      return getVM()[V] = NewV;
+    if (Value *NewV = Materializer->materialize(const_cast<Value *>(V))) {
+      getVM()[V] = NewV;
+      return NewV;
     }
   }
 
   // Global values do not need to be seeded into the VM if they
   // are using the identity mapping.
   if (isa<GlobalValue>(V)) {
     if (Flags & RF_NullMapMissingGlobalValues)
       return nullptr;