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.

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) {

include/llvm/Transforms/Utils/ValueMapper.h

 
 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);
+  /// 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

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;
-  void materializeInitFor(GlobalValue *New, GlobalValue *Old) override;
+  Value *materialize(Value *V) override;
 };
 
 class LocalValueMaterializer final : public ValueMaterializer {
   IRLinker &TheIRLinker;
 
 public:
   LocalValueMaterializer(IRLinker &TheIRLinker) : TheIRLinker(TheIRLinker) {}
-  Value *materializeDeclFor(Value *V) override;
-  void materializeInitFor(GlobalValue *New, GlobalValue *Old) 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 {
IRLinker(Module &DstM, MDMapT &SharedMDs,
                                                          &LValMaterializer)) {
     ValueMap.getMDMap() = std::move(SharedMDs);
     for (GlobalValue *GV : ValuesToLink)
       maybeAdd(GV);
   }
   ~IRLinker() { SharedMDs = std::move(*ValueMap.getMDMap()); }
 
   bool run();
-  Value *materializeDeclFor(Value *V, bool ForAlias);
-  void materializeInitFor(GlobalValue *New, GlobalValue *Old, bool ForAlias);
+  Value *materialize(Value *V, bool ForAlias);
 };
 }
 
 /// The LLVM SymbolTable class autorenames globals that conflict in the symbol
 /// table. This is good for all clients except for us. Go through the trouble
 /// to force this back.
 static void forceRenaming(GlobalValue *GV, StringRef Name) {
   // If the global doesn't force its name or if it already has the right name,
   // there is nothing for us to do.
   if (GV->hasLocalLinkage() || GV->getName() == Name)
     return;
 
   Module *M = GV->getParent();
 
   // If there is a conflict, rename the conflict.
   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 *V) {
-  return TheIRLinker.materializeDeclFor(V, false);
+Value *GlobalValueMaterializer::materialize(Value *SGV) {
+  return TheIRLinker.materialize(SGV, false);
 }
 
-void GlobalValueMaterializer::materializeInitFor(GlobalValue *New,
-                                                 GlobalValue *Old) {
-  TheIRLinker.materializeInitFor(New, Old, false);
+Value *LocalValueMaterializer::materialize(Value *SGV) {
+  return TheIRLinker.materialize(SGV, true);
 }
 
-Value *LocalValueMaterializer::materializeDeclFor(Value *V) {
-  return TheIRLinker.materializeDeclFor(V, true);
-}
-
-void LocalValueMaterializer::materializeInitFor(GlobalValue *New,
-                                                GlobalValue *Old) {
-  TheIRLinker.materializeInitFor(New, Old, true);
-}
-
-Value *IRLinker::materializeDeclFor(Value *V, bool ForAlias) {
+Value *IRLinker::materialize(Value *V, bool ForAlias) {
   auto *SGV = dyn_cast<GlobalValue>(V);
   if (!SGV)
     return nullptr;
 
-  return linkGlobalValueProto(SGV, ForAlias);
-}
+  Constant *NewProto = linkGlobalValueProto(SGV, ForAlias);
+  if (!NewProto)
+    return NewProto;
+
+  GlobalValue *New = dyn_cast<GlobalValue>(NewProto);
+  if (!New)
+    return NewProto;
 
-void IRLinker::materializeInitFor(GlobalValue *New, GlobalValue *Old,
-                                  bool ForAlias) {
   // If we already created the body, just return.
   if (auto *F = dyn_cast<Function>(New)) {
     if (!F->isDeclaration())
-      return;
+      return New;
   } else if (auto *V = dyn_cast<GlobalVariable>(New)) {
     if (V->hasInitializer() || V->hasAppendingLinkage())
-      return;
+      return New;
   } else {
     auto *A = cast<GlobalAlias>(New);
     if (A->getAliasee())
-      return;
+      return New;
   }
 
   // When linking a global for an alias, it will always be linked. However we
   // need to check if it was not already scheduled to satify a reference from a
   // regular global value initializer. We know if it has been schedule if the
   // "New" GlobalValue that is mapped here for the alias is the same as the one
   // already mapped. If there is an entry in the ValueMap but the value is
   // different, it means that the value already had a definition in the
   // destination module (linkonce for instance), but we need a new definition
   // for the alias ("New" will be different.
-  if (ForAlias && ValueMap.lookup(Old) == New)
-    return;
+  if (ForAlias && ValueMap.lookup(SGV) == New)
+    return New;
+
+  if (ForAlias || shouldLink(New, *SGV))
+    linkGlobalValueBody(*New, *SGV);
 
-  if (ForAlias || shouldLink(New, *Old))
-    linkGlobalValueBody(*New, *Old);
+  return New;
 }
 
 /// Loop through the global variables in the src module and merge them into the
 /// dest module.
 GlobalVariable *IRLinker::copyGlobalVariableProto(const GlobalVariable *SGVar) {
   // No linking to be performed or linking from the source: simply create an
   // identical version of the symbol over in the dest module... the
   // initializer will be filled in later by LinkGlobalInits.

lib/Transforms/Utils/ValueMapper.cpp

 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Operator.h"
 using namespace llvm;
 
 // Out of line method to get vtable etc for class.
 void ValueMapTypeRemapper::anchor() {}
 void ValueMaterializer::anchor() {}
-void ValueMaterializer::materializeInitFor(GlobalValue *New, GlobalValue *Old) {
-}
 
 namespace {
 
 /// A basic block used in a BlockAddress whose function body is not yet
 /// materialized.
 struct DelayedBasicBlock {
   BasicBlock *OldBB;
   std::unique_ptr<BasicBlock> TempBB;
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))) {
+    if (Value *NewV = Materializer->materialize(const_cast<Value *>(V))) {
       getVM()[V] = NewV;
-      if (auto *NewGV = dyn_cast<GlobalValue>(NewV))
-        Materializer->materializeInitFor(
-            NewGV, cast<GlobalValue>(const_cast<Value *>(V)));
       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)