xref: /freebsd/contrib/llvm-project/llvm/lib/Transforms/Utils/ValueMapper.cpp (revision cb14a3fe5122c879eae1fb480ed7ce82a699ddb6)
1 //===- ValueMapper.cpp - Interface shared by lib/Transforms/Utils ---------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines the MapValue function, which is shared by various parts of
10 // the lib/Transforms/Utils library.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/Transforms/Utils/ValueMapper.h"
15 #include "llvm/ADT/ArrayRef.h"
16 #include "llvm/ADT/DenseMap.h"
17 #include "llvm/ADT/DenseSet.h"
18 #include "llvm/ADT/STLExtras.h"
19 #include "llvm/ADT/SmallVector.h"
20 #include "llvm/IR/Argument.h"
21 #include "llvm/IR/BasicBlock.h"
22 #include "llvm/IR/Constant.h"
23 #include "llvm/IR/Constants.h"
24 #include "llvm/IR/DebugInfoMetadata.h"
25 #include "llvm/IR/DerivedTypes.h"
26 #include "llvm/IR/Function.h"
27 #include "llvm/IR/GlobalAlias.h"
28 #include "llvm/IR/GlobalIFunc.h"
29 #include "llvm/IR/GlobalObject.h"
30 #include "llvm/IR/GlobalVariable.h"
31 #include "llvm/IR/InlineAsm.h"
32 #include "llvm/IR/Instruction.h"
33 #include "llvm/IR/Instructions.h"
34 #include "llvm/IR/IntrinsicInst.h"
35 #include "llvm/IR/Metadata.h"
36 #include "llvm/IR/Operator.h"
37 #include "llvm/IR/Type.h"
38 #include "llvm/IR/Value.h"
39 #include "llvm/Support/Casting.h"
40 #include "llvm/Support/Debug.h"
41 #include <cassert>
42 #include <limits>
43 #include <memory>
44 #include <utility>
45 
46 using namespace llvm;
47 
48 #define DEBUG_TYPE "value-mapper"
49 
50 // Out of line method to get vtable etc for class.
51 void ValueMapTypeRemapper::anchor() {}
52 void ValueMaterializer::anchor() {}
53 
54 namespace {
55 
56 /// A basic block used in a BlockAddress whose function body is not yet
57 /// materialized.
58 struct DelayedBasicBlock {
59   BasicBlock *OldBB;
60   std::unique_ptr<BasicBlock> TempBB;
61 
62   DelayedBasicBlock(const BlockAddress &Old)
63       : OldBB(Old.getBasicBlock()),
64         TempBB(BasicBlock::Create(Old.getContext())) {}
65 };
66 
67 struct WorklistEntry {
68   enum EntryKind {
69     MapGlobalInit,
70     MapAppendingVar,
71     MapAliasOrIFunc,
72     RemapFunction
73   };
74   struct GVInitTy {
75     GlobalVariable *GV;
76     Constant *Init;
77   };
78   struct AppendingGVTy {
79     GlobalVariable *GV;
80     Constant *InitPrefix;
81   };
82   struct AliasOrIFuncTy {
83     GlobalValue *GV;
84     Constant *Target;
85   };
86 
87   unsigned Kind : 2;
88   unsigned MCID : 29;
89   unsigned AppendingGVIsOldCtorDtor : 1;
90   unsigned AppendingGVNumNewMembers;
91   union {
92     GVInitTy GVInit;
93     AppendingGVTy AppendingGV;
94     AliasOrIFuncTy AliasOrIFunc;
95     Function *RemapF;
96   } Data;
97 };
98 
99 struct MappingContext {
100   ValueToValueMapTy *VM;
101   ValueMaterializer *Materializer = nullptr;
102 
103   /// Construct a MappingContext with a value map and materializer.
104   explicit MappingContext(ValueToValueMapTy &VM,
105                           ValueMaterializer *Materializer = nullptr)
106       : VM(&VM), Materializer(Materializer) {}
107 };
108 
109 class Mapper {
110   friend class MDNodeMapper;
111 
112 #ifndef NDEBUG
113   DenseSet<GlobalValue *> AlreadyScheduled;
114 #endif
115 
116   RemapFlags Flags;
117   ValueMapTypeRemapper *TypeMapper;
118   unsigned CurrentMCID = 0;
119   SmallVector<MappingContext, 2> MCs;
120   SmallVector<WorklistEntry, 4> Worklist;
121   SmallVector<DelayedBasicBlock, 1> DelayedBBs;
122   SmallVector<Constant *, 16> AppendingInits;
123 
124 public:
125   Mapper(ValueToValueMapTy &VM, RemapFlags Flags,
126          ValueMapTypeRemapper *TypeMapper, ValueMaterializer *Materializer)
127       : Flags(Flags), TypeMapper(TypeMapper),
128         MCs(1, MappingContext(VM, Materializer)) {}
129 
130   /// ValueMapper should explicitly call \a flush() before destruction.
131   ~Mapper() { assert(!hasWorkToDo() && "Expected to be flushed"); }
132 
133   bool hasWorkToDo() const { return !Worklist.empty(); }
134 
135   unsigned
136   registerAlternateMappingContext(ValueToValueMapTy &VM,
137                                   ValueMaterializer *Materializer = nullptr) {
138     MCs.push_back(MappingContext(VM, Materializer));
139     return MCs.size() - 1;
140   }
141 
142   void addFlags(RemapFlags Flags);
143 
144   void remapGlobalObjectMetadata(GlobalObject &GO);
145 
146   Value *mapValue(const Value *V);
147   void remapInstruction(Instruction *I);
148   void remapFunction(Function &F);
149   void remapDPValue(DPValue &DPV);
150 
151   Constant *mapConstant(const Constant *C) {
152     return cast_or_null<Constant>(mapValue(C));
153   }
154 
155   /// Map metadata.
156   ///
157   /// Find the mapping for MD.  Guarantees that the return will be resolved
158   /// (not an MDNode, or MDNode::isResolved() returns true).
159   Metadata *mapMetadata(const Metadata *MD);
160 
161   void scheduleMapGlobalInitializer(GlobalVariable &GV, Constant &Init,
162                                     unsigned MCID);
163   void scheduleMapAppendingVariable(GlobalVariable &GV, Constant *InitPrefix,
164                                     bool IsOldCtorDtor,
165                                     ArrayRef<Constant *> NewMembers,
166                                     unsigned MCID);
167   void scheduleMapAliasOrIFunc(GlobalValue &GV, Constant &Target,
168                                unsigned MCID);
169   void scheduleRemapFunction(Function &F, unsigned MCID);
170 
171   void flush();
172 
173 private:
174   void mapAppendingVariable(GlobalVariable &GV, Constant *InitPrefix,
175                             bool IsOldCtorDtor,
176                             ArrayRef<Constant *> NewMembers);
177 
178   ValueToValueMapTy &getVM() { return *MCs[CurrentMCID].VM; }
179   ValueMaterializer *getMaterializer() { return MCs[CurrentMCID].Materializer; }
180 
181   Value *mapBlockAddress(const BlockAddress &BA);
182 
183   /// Map metadata that doesn't require visiting operands.
184   std::optional<Metadata *> mapSimpleMetadata(const Metadata *MD);
185 
186   Metadata *mapToMetadata(const Metadata *Key, Metadata *Val);
187   Metadata *mapToSelf(const Metadata *MD);
188 };
189 
190 class MDNodeMapper {
191   Mapper &M;
192 
193   /// Data about a node in \a UniquedGraph.
194   struct Data {
195     bool HasChanged = false;
196     unsigned ID = std::numeric_limits<unsigned>::max();
197     TempMDNode Placeholder;
198   };
199 
200   /// A graph of uniqued nodes.
201   struct UniquedGraph {
202     SmallDenseMap<const Metadata *, Data, 32> Info; // Node properties.
203     SmallVector<MDNode *, 16> POT;                  // Post-order traversal.
204 
205     /// Propagate changed operands through the post-order traversal.
206     ///
207     /// Iteratively update \a Data::HasChanged for each node based on \a
208     /// Data::HasChanged of its operands, until fixed point.
209     void propagateChanges();
210 
211     /// Get a forward reference to a node to use as an operand.
212     Metadata &getFwdReference(MDNode &Op);
213   };
214 
215   /// Worklist of distinct nodes whose operands need to be remapped.
216   SmallVector<MDNode *, 16> DistinctWorklist;
217 
218   // Storage for a UniquedGraph.
219   SmallDenseMap<const Metadata *, Data, 32> InfoStorage;
220   SmallVector<MDNode *, 16> POTStorage;
221 
222 public:
223   MDNodeMapper(Mapper &M) : M(M) {}
224 
225   /// Map a metadata node (and its transitive operands).
226   ///
227   /// Map all the (unmapped) nodes in the subgraph under \c N.  The iterative
228   /// algorithm handles distinct nodes and uniqued node subgraphs using
229   /// different strategies.
230   ///
231   /// Distinct nodes are immediately mapped and added to \a DistinctWorklist
232   /// using \a mapDistinctNode().  Their mapping can always be computed
233   /// immediately without visiting operands, even if their operands change.
234   ///
235   /// The mapping for uniqued nodes depends on whether their operands change.
236   /// \a mapTopLevelUniquedNode() traverses the transitive uniqued subgraph of
237   /// a node to calculate uniqued node mappings in bulk.  Distinct leafs are
238   /// added to \a DistinctWorklist with \a mapDistinctNode().
239   ///
240   /// After mapping \c N itself, this function remaps the operands of the
241   /// distinct nodes in \a DistinctWorklist until the entire subgraph under \c
242   /// N has been mapped.
243   Metadata *map(const MDNode &N);
244 
245 private:
246   /// Map a top-level uniqued node and the uniqued subgraph underneath it.
247   ///
248   /// This builds up a post-order traversal of the (unmapped) uniqued subgraph
249   /// underneath \c FirstN and calculates the nodes' mapping.  Each node uses
250   /// the identity mapping (\a Mapper::mapToSelf()) as long as all of its
251   /// operands uses the identity mapping.
252   ///
253   /// The algorithm works as follows:
254   ///
255   ///  1. \a createPOT(): traverse the uniqued subgraph under \c FirstN and
256   ///     save the post-order traversal in the given \a UniquedGraph, tracking
257   ///     nodes' operands change.
258   ///
259   ///  2. \a UniquedGraph::propagateChanges(): propagate changed operands
260   ///     through the \a UniquedGraph until fixed point, following the rule
261   ///     that if a node changes, any node that references must also change.
262   ///
263   ///  3. \a mapNodesInPOT(): map the uniqued nodes, creating new uniqued nodes
264   ///     (referencing new operands) where necessary.
265   Metadata *mapTopLevelUniquedNode(const MDNode &FirstN);
266 
267   /// Try to map the operand of an \a MDNode.
268   ///
269   /// If \c Op is already mapped, return the mapping.  If it's not an \a
270   /// MDNode, compute and return the mapping.  If it's a distinct \a MDNode,
271   /// return the result of \a mapDistinctNode().
272   ///
273   /// \return std::nullopt if \c Op is an unmapped uniqued \a MDNode.
274   /// \post getMappedOp(Op) only returns std::nullopt if this returns
275   /// std::nullopt.
276   std::optional<Metadata *> tryToMapOperand(const Metadata *Op);
277 
278   /// Map a distinct node.
279   ///
280   /// Return the mapping for the distinct node \c N, saving the result in \a
281   /// DistinctWorklist for later remapping.
282   ///
283   /// \pre \c N is not yet mapped.
284   /// \pre \c N.isDistinct().
285   MDNode *mapDistinctNode(const MDNode &N);
286 
287   /// Get a previously mapped node.
288   std::optional<Metadata *> getMappedOp(const Metadata *Op) const;
289 
290   /// Create a post-order traversal of an unmapped uniqued node subgraph.
291   ///
292   /// This traverses the metadata graph deeply enough to map \c FirstN.  It
293   /// uses \a tryToMapOperand() (via \a Mapper::mapSimplifiedNode()), so any
294   /// metadata that has already been mapped will not be part of the POT.
295   ///
296   /// Each node that has a changed operand from outside the graph (e.g., a
297   /// distinct node, an already-mapped uniqued node, or \a ConstantAsMetadata)
298   /// is marked with \a Data::HasChanged.
299   ///
300   /// \return \c true if any nodes in \c G have \a Data::HasChanged.
301   /// \post \c G.POT is a post-order traversal ending with \c FirstN.
302   /// \post \a Data::hasChanged in \c G.Info indicates whether any node needs
303   /// to change because of operands outside the graph.
304   bool createPOT(UniquedGraph &G, const MDNode &FirstN);
305 
306   /// Visit the operands of a uniqued node in the POT.
307   ///
308   /// Visit the operands in the range from \c I to \c E, returning the first
309   /// uniqued node we find that isn't yet in \c G.  \c I is always advanced to
310   /// where to continue the loop through the operands.
311   ///
312   /// This sets \c HasChanged if any of the visited operands change.
313   MDNode *visitOperands(UniquedGraph &G, MDNode::op_iterator &I,
314                         MDNode::op_iterator E, bool &HasChanged);
315 
316   /// Map all the nodes in the given uniqued graph.
317   ///
318   /// This visits all the nodes in \c G in post-order, using the identity
319   /// mapping or creating a new node depending on \a Data::HasChanged.
320   ///
321   /// \pre \a getMappedOp() returns std::nullopt for nodes in \c G, but not for
322   /// any of their operands outside of \c G. \pre \a Data::HasChanged is true
323   /// for a node in \c G iff any of its operands have changed. \post \a
324   /// getMappedOp() returns the mapped node for every node in \c G.
325   void mapNodesInPOT(UniquedGraph &G);
326 
327   /// Remap a node's operands using the given functor.
328   ///
329   /// Iterate through the operands of \c N and update them in place using \c
330   /// mapOperand.
331   ///
332   /// \pre N.isDistinct() or N.isTemporary().
333   template <class OperandMapper>
334   void remapOperands(MDNode &N, OperandMapper mapOperand);
335 };
336 
337 } // end anonymous namespace
338 
339 Value *Mapper::mapValue(const Value *V) {
340   ValueToValueMapTy::iterator I = getVM().find(V);
341 
342   // If the value already exists in the map, use it.
343   if (I != getVM().end()) {
344     assert(I->second && "Unexpected null mapping");
345     return I->second;
346   }
347 
348   // If we have a materializer and it can materialize a value, use that.
349   if (auto *Materializer = getMaterializer()) {
350     if (Value *NewV = Materializer->materialize(const_cast<Value *>(V))) {
351       getVM()[V] = NewV;
352       return NewV;
353     }
354   }
355 
356   // Global values do not need to be seeded into the VM if they
357   // are using the identity mapping.
358   if (isa<GlobalValue>(V)) {
359     if (Flags & RF_NullMapMissingGlobalValues)
360       return nullptr;
361     return getVM()[V] = const_cast<Value *>(V);
362   }
363 
364   if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
365     // Inline asm may need *type* remapping.
366     FunctionType *NewTy = IA->getFunctionType();
367     if (TypeMapper) {
368       NewTy = cast<FunctionType>(TypeMapper->remapType(NewTy));
369 
370       if (NewTy != IA->getFunctionType())
371         V = InlineAsm::get(NewTy, IA->getAsmString(), IA->getConstraintString(),
372                            IA->hasSideEffects(), IA->isAlignStack(),
373                            IA->getDialect(), IA->canThrow());
374     }
375 
376     return getVM()[V] = const_cast<Value *>(V);
377   }
378 
379   if (const auto *MDV = dyn_cast<MetadataAsValue>(V)) {
380     const Metadata *MD = MDV->getMetadata();
381 
382     if (auto *LAM = dyn_cast<LocalAsMetadata>(MD)) {
383       // Look through to grab the local value.
384       if (Value *LV = mapValue(LAM->getValue())) {
385         if (V == LAM->getValue())
386           return const_cast<Value *>(V);
387         return MetadataAsValue::get(V->getContext(), ValueAsMetadata::get(LV));
388       }
389 
390       // FIXME: always return nullptr once Verifier::verifyDominatesUse()
391       // ensures metadata operands only reference defined SSA values.
392       return (Flags & RF_IgnoreMissingLocals)
393                  ? nullptr
394                  : MetadataAsValue::get(
395                        V->getContext(),
396                        MDTuple::get(V->getContext(), std::nullopt));
397     }
398     if (auto *AL = dyn_cast<DIArgList>(MD)) {
399       SmallVector<ValueAsMetadata *, 4> MappedArgs;
400       for (auto *VAM : AL->getArgs()) {
401         // Map both Local and Constant VAMs here; they will both ultimately
402         // be mapped via mapValue. The exceptions are constants when we have no
403         // module level changes and locals when they have no existing mapped
404         // value and RF_IgnoreMissingLocals is set; these have identity
405         // mappings.
406         if ((Flags & RF_NoModuleLevelChanges) && isa<ConstantAsMetadata>(VAM)) {
407           MappedArgs.push_back(VAM);
408         } else if (Value *LV = mapValue(VAM->getValue())) {
409           MappedArgs.push_back(
410               LV == VAM->getValue() ? VAM : ValueAsMetadata::get(LV));
411         } else if ((Flags & RF_IgnoreMissingLocals) && isa<LocalAsMetadata>(VAM)) {
412             MappedArgs.push_back(VAM);
413         } else {
414           // If we cannot map the value, set the argument as undef.
415           MappedArgs.push_back(ValueAsMetadata::get(
416               UndefValue::get(VAM->getValue()->getType())));
417         }
418       }
419       return MetadataAsValue::get(V->getContext(),
420                                   DIArgList::get(V->getContext(), MappedArgs));
421     }
422 
423     // If this is a module-level metadata and we know that nothing at the module
424     // level is changing, then use an identity mapping.
425     if (Flags & RF_NoModuleLevelChanges)
426       return getVM()[V] = const_cast<Value *>(V);
427 
428     // Map the metadata and turn it into a value.
429     auto *MappedMD = mapMetadata(MD);
430     if (MD == MappedMD)
431       return getVM()[V] = const_cast<Value *>(V);
432     return getVM()[V] = MetadataAsValue::get(V->getContext(), MappedMD);
433   }
434 
435   // Okay, this either must be a constant (which may or may not be mappable) or
436   // is something that is not in the mapping table.
437   Constant *C = const_cast<Constant*>(dyn_cast<Constant>(V));
438   if (!C)
439     return nullptr;
440 
441   if (BlockAddress *BA = dyn_cast<BlockAddress>(C))
442     return mapBlockAddress(*BA);
443 
444   if (const auto *E = dyn_cast<DSOLocalEquivalent>(C)) {
445     auto *Val = mapValue(E->getGlobalValue());
446     GlobalValue *GV = dyn_cast<GlobalValue>(Val);
447     if (GV)
448       return getVM()[E] = DSOLocalEquivalent::get(GV);
449 
450     auto *Func = cast<Function>(Val->stripPointerCastsAndAliases());
451     Type *NewTy = E->getType();
452     if (TypeMapper)
453       NewTy = TypeMapper->remapType(NewTy);
454     return getVM()[E] = llvm::ConstantExpr::getBitCast(
455                DSOLocalEquivalent::get(Func), NewTy);
456   }
457 
458   if (const auto *NC = dyn_cast<NoCFIValue>(C)) {
459     auto *Val = mapValue(NC->getGlobalValue());
460     GlobalValue *GV = cast<GlobalValue>(Val);
461     return getVM()[NC] = NoCFIValue::get(GV);
462   }
463 
464   auto mapValueOrNull = [this](Value *V) {
465     auto Mapped = mapValue(V);
466     assert((Mapped || (Flags & RF_NullMapMissingGlobalValues)) &&
467            "Unexpected null mapping for constant operand without "
468            "NullMapMissingGlobalValues flag");
469     return Mapped;
470   };
471 
472   // Otherwise, we have some other constant to remap.  Start by checking to see
473   // if all operands have an identity remapping.
474   unsigned OpNo = 0, NumOperands = C->getNumOperands();
475   Value *Mapped = nullptr;
476   for (; OpNo != NumOperands; ++OpNo) {
477     Value *Op = C->getOperand(OpNo);
478     Mapped = mapValueOrNull(Op);
479     if (!Mapped)
480       return nullptr;
481     if (Mapped != Op)
482       break;
483   }
484 
485   // See if the type mapper wants to remap the type as well.
486   Type *NewTy = C->getType();
487   if (TypeMapper)
488     NewTy = TypeMapper->remapType(NewTy);
489 
490   // If the result type and all operands match up, then just insert an identity
491   // mapping.
492   if (OpNo == NumOperands && NewTy == C->getType())
493     return getVM()[V] = C;
494 
495   // Okay, we need to create a new constant.  We've already processed some or
496   // all of the operands, set them all up now.
497   SmallVector<Constant*, 8> Ops;
498   Ops.reserve(NumOperands);
499   for (unsigned j = 0; j != OpNo; ++j)
500     Ops.push_back(cast<Constant>(C->getOperand(j)));
501 
502   // If one of the operands mismatch, push it and the other mapped operands.
503   if (OpNo != NumOperands) {
504     Ops.push_back(cast<Constant>(Mapped));
505 
506     // Map the rest of the operands that aren't processed yet.
507     for (++OpNo; OpNo != NumOperands; ++OpNo) {
508       Mapped = mapValueOrNull(C->getOperand(OpNo));
509       if (!Mapped)
510         return nullptr;
511       Ops.push_back(cast<Constant>(Mapped));
512     }
513   }
514   Type *NewSrcTy = nullptr;
515   if (TypeMapper)
516     if (auto *GEPO = dyn_cast<GEPOperator>(C))
517       NewSrcTy = TypeMapper->remapType(GEPO->getSourceElementType());
518 
519   if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C))
520     return getVM()[V] = CE->getWithOperands(Ops, NewTy, false, NewSrcTy);
521   if (isa<ConstantArray>(C))
522     return getVM()[V] = ConstantArray::get(cast<ArrayType>(NewTy), Ops);
523   if (isa<ConstantStruct>(C))
524     return getVM()[V] = ConstantStruct::get(cast<StructType>(NewTy), Ops);
525   if (isa<ConstantVector>(C))
526     return getVM()[V] = ConstantVector::get(Ops);
527   // If this is a no-operand constant, it must be because the type was remapped.
528   if (isa<PoisonValue>(C))
529     return getVM()[V] = PoisonValue::get(NewTy);
530   if (isa<UndefValue>(C))
531     return getVM()[V] = UndefValue::get(NewTy);
532   if (isa<ConstantAggregateZero>(C))
533     return getVM()[V] = ConstantAggregateZero::get(NewTy);
534   if (isa<ConstantTargetNone>(C))
535     return getVM()[V] = Constant::getNullValue(NewTy);
536   assert(isa<ConstantPointerNull>(C));
537   return getVM()[V] = ConstantPointerNull::get(cast<PointerType>(NewTy));
538 }
539 
540 void Mapper::remapDPValue(DPValue &V) {
541   // Remap variables and DILocations.
542   auto *MappedVar = mapMetadata(V.getVariable());
543   auto *MappedDILoc = mapMetadata(V.getDebugLoc());
544   V.setVariable(cast<DILocalVariable>(MappedVar));
545   V.setDebugLoc(DebugLoc(cast<DILocation>(MappedDILoc)));
546 
547   // Find Value operands and remap those.
548   SmallVector<Value *, 4> Vals, NewVals;
549   for (Value *Val : V.location_ops())
550     Vals.push_back(Val);
551   for (Value *Val : Vals)
552     NewVals.push_back(mapValue(Val));
553 
554   // If there are no changes to the Value operands, finished.
555   if (Vals == NewVals)
556     return;
557 
558   bool IgnoreMissingLocals = Flags & RF_IgnoreMissingLocals;
559 
560   // Otherwise, do some replacement.
561   if (!IgnoreMissingLocals &&
562       llvm::any_of(NewVals, [&](Value *V) { return V == nullptr; })) {
563     V.setKillLocation();
564   } else {
565     // Either we have all non-empty NewVals, or we're permitted to ignore
566     // missing locals.
567     for (unsigned int I = 0; I < Vals.size(); ++I)
568       if (NewVals[I])
569         V.replaceVariableLocationOp(I, NewVals[I]);
570   }
571 }
572 
573 Value *Mapper::mapBlockAddress(const BlockAddress &BA) {
574   Function *F = cast<Function>(mapValue(BA.getFunction()));
575 
576   // F may not have materialized its initializer.  In that case, create a
577   // dummy basic block for now, and replace it once we've materialized all
578   // the initializers.
579   BasicBlock *BB;
580   if (F->empty()) {
581     DelayedBBs.push_back(DelayedBasicBlock(BA));
582     BB = DelayedBBs.back().TempBB.get();
583   } else {
584     BB = cast_or_null<BasicBlock>(mapValue(BA.getBasicBlock()));
585   }
586 
587   return getVM()[&BA] = BlockAddress::get(F, BB ? BB : BA.getBasicBlock());
588 }
589 
590 Metadata *Mapper::mapToMetadata(const Metadata *Key, Metadata *Val) {
591   getVM().MD()[Key].reset(Val);
592   return Val;
593 }
594 
595 Metadata *Mapper::mapToSelf(const Metadata *MD) {
596   return mapToMetadata(MD, const_cast<Metadata *>(MD));
597 }
598 
599 std::optional<Metadata *> MDNodeMapper::tryToMapOperand(const Metadata *Op) {
600   if (!Op)
601     return nullptr;
602 
603   if (std::optional<Metadata *> MappedOp = M.mapSimpleMetadata(Op)) {
604 #ifndef NDEBUG
605     if (auto *CMD = dyn_cast<ConstantAsMetadata>(Op))
606       assert((!*MappedOp || M.getVM().count(CMD->getValue()) ||
607               M.getVM().getMappedMD(Op)) &&
608              "Expected Value to be memoized");
609     else
610       assert((isa<MDString>(Op) || M.getVM().getMappedMD(Op)) &&
611              "Expected result to be memoized");
612 #endif
613     return *MappedOp;
614   }
615 
616   const MDNode &N = *cast<MDNode>(Op);
617   if (N.isDistinct())
618     return mapDistinctNode(N);
619   return std::nullopt;
620 }
621 
622 MDNode *MDNodeMapper::mapDistinctNode(const MDNode &N) {
623   assert(N.isDistinct() && "Expected a distinct node");
624   assert(!M.getVM().getMappedMD(&N) && "Expected an unmapped node");
625   Metadata *NewM = nullptr;
626 
627   if (M.Flags & RF_ReuseAndMutateDistinctMDs) {
628     NewM = M.mapToSelf(&N);
629   } else {
630     NewM = MDNode::replaceWithDistinct(N.clone());
631     LLVM_DEBUG(dbgs() << "\nMap " << N << "\n"
632                       << "To  " << *NewM << "\n\n");
633     M.mapToMetadata(&N, NewM);
634   }
635   DistinctWorklist.push_back(cast<MDNode>(NewM));
636 
637   return DistinctWorklist.back();
638 }
639 
640 static ConstantAsMetadata *wrapConstantAsMetadata(const ConstantAsMetadata &CMD,
641                                                   Value *MappedV) {
642   if (CMD.getValue() == MappedV)
643     return const_cast<ConstantAsMetadata *>(&CMD);
644   return MappedV ? ConstantAsMetadata::getConstant(MappedV) : nullptr;
645 }
646 
647 std::optional<Metadata *> MDNodeMapper::getMappedOp(const Metadata *Op) const {
648   if (!Op)
649     return nullptr;
650 
651   if (std::optional<Metadata *> MappedOp = M.getVM().getMappedMD(Op))
652     return *MappedOp;
653 
654   if (isa<MDString>(Op))
655     return const_cast<Metadata *>(Op);
656 
657   if (auto *CMD = dyn_cast<ConstantAsMetadata>(Op))
658     return wrapConstantAsMetadata(*CMD, M.getVM().lookup(CMD->getValue()));
659 
660   return std::nullopt;
661 }
662 
663 Metadata &MDNodeMapper::UniquedGraph::getFwdReference(MDNode &Op) {
664   auto Where = Info.find(&Op);
665   assert(Where != Info.end() && "Expected a valid reference");
666 
667   auto &OpD = Where->second;
668   if (!OpD.HasChanged)
669     return Op;
670 
671   // Lazily construct a temporary node.
672   if (!OpD.Placeholder)
673     OpD.Placeholder = Op.clone();
674 
675   return *OpD.Placeholder;
676 }
677 
678 template <class OperandMapper>
679 void MDNodeMapper::remapOperands(MDNode &N, OperandMapper mapOperand) {
680   assert(!N.isUniqued() && "Expected distinct or temporary nodes");
681   for (unsigned I = 0, E = N.getNumOperands(); I != E; ++I) {
682     Metadata *Old = N.getOperand(I);
683     Metadata *New = mapOperand(Old);
684     if (Old != New)
685       LLVM_DEBUG(dbgs() << "Replacing Op " << Old << " with " << New << " in "
686                         << N << "\n");
687 
688     if (Old != New)
689       N.replaceOperandWith(I, New);
690   }
691 }
692 
693 namespace {
694 
695 /// An entry in the worklist for the post-order traversal.
696 struct POTWorklistEntry {
697   MDNode *N;              ///< Current node.
698   MDNode::op_iterator Op; ///< Current operand of \c N.
699 
700   /// Keep a flag of whether operands have changed in the worklist to avoid
701   /// hitting the map in \a UniquedGraph.
702   bool HasChanged = false;
703 
704   POTWorklistEntry(MDNode &N) : N(&N), Op(N.op_begin()) {}
705 };
706 
707 } // end anonymous namespace
708 
709 bool MDNodeMapper::createPOT(UniquedGraph &G, const MDNode &FirstN) {
710   assert(G.Info.empty() && "Expected a fresh traversal");
711   assert(FirstN.isUniqued() && "Expected uniqued node in POT");
712 
713   // Construct a post-order traversal of the uniqued subgraph under FirstN.
714   bool AnyChanges = false;
715   SmallVector<POTWorklistEntry, 16> Worklist;
716   Worklist.push_back(POTWorklistEntry(const_cast<MDNode &>(FirstN)));
717   (void)G.Info[&FirstN];
718   while (!Worklist.empty()) {
719     // Start or continue the traversal through the this node's operands.
720     auto &WE = Worklist.back();
721     if (MDNode *N = visitOperands(G, WE.Op, WE.N->op_end(), WE.HasChanged)) {
722       // Push a new node to traverse first.
723       Worklist.push_back(POTWorklistEntry(*N));
724       continue;
725     }
726 
727     // Push the node onto the POT.
728     assert(WE.N->isUniqued() && "Expected only uniqued nodes");
729     assert(WE.Op == WE.N->op_end() && "Expected to visit all operands");
730     auto &D = G.Info[WE.N];
731     AnyChanges |= D.HasChanged = WE.HasChanged;
732     D.ID = G.POT.size();
733     G.POT.push_back(WE.N);
734 
735     // Pop the node off the worklist.
736     Worklist.pop_back();
737   }
738   return AnyChanges;
739 }
740 
741 MDNode *MDNodeMapper::visitOperands(UniquedGraph &G, MDNode::op_iterator &I,
742                                     MDNode::op_iterator E, bool &HasChanged) {
743   while (I != E) {
744     Metadata *Op = *I++; // Increment even on early return.
745     if (std::optional<Metadata *> MappedOp = tryToMapOperand(Op)) {
746       // Check if the operand changes.
747       HasChanged |= Op != *MappedOp;
748       continue;
749     }
750 
751     // A uniqued metadata node.
752     MDNode &OpN = *cast<MDNode>(Op);
753     assert(OpN.isUniqued() &&
754            "Only uniqued operands cannot be mapped immediately");
755     if (G.Info.insert(std::make_pair(&OpN, Data())).second)
756       return &OpN; // This is a new one.  Return it.
757   }
758   return nullptr;
759 }
760 
761 void MDNodeMapper::UniquedGraph::propagateChanges() {
762   bool AnyChanges;
763   do {
764     AnyChanges = false;
765     for (MDNode *N : POT) {
766       auto &D = Info[N];
767       if (D.HasChanged)
768         continue;
769 
770       if (llvm::none_of(N->operands(), [&](const Metadata *Op) {
771             auto Where = Info.find(Op);
772             return Where != Info.end() && Where->second.HasChanged;
773           }))
774         continue;
775 
776       AnyChanges = D.HasChanged = true;
777     }
778   } while (AnyChanges);
779 }
780 
781 void MDNodeMapper::mapNodesInPOT(UniquedGraph &G) {
782   // Construct uniqued nodes, building forward references as necessary.
783   SmallVector<MDNode *, 16> CyclicNodes;
784   for (auto *N : G.POT) {
785     auto &D = G.Info[N];
786     if (!D.HasChanged) {
787       // The node hasn't changed.
788       M.mapToSelf(N);
789       continue;
790     }
791 
792     // Remember whether this node had a placeholder.
793     bool HadPlaceholder(D.Placeholder);
794 
795     // Clone the uniqued node and remap the operands.
796     TempMDNode ClonedN = D.Placeholder ? std::move(D.Placeholder) : N->clone();
797     remapOperands(*ClonedN, [this, &D, &G](Metadata *Old) {
798       if (std::optional<Metadata *> MappedOp = getMappedOp(Old))
799         return *MappedOp;
800       (void)D;
801       assert(G.Info[Old].ID > D.ID && "Expected a forward reference");
802       return &G.getFwdReference(*cast<MDNode>(Old));
803     });
804 
805     auto *NewN = MDNode::replaceWithUniqued(std::move(ClonedN));
806     if (N && NewN && N != NewN) {
807       LLVM_DEBUG(dbgs() << "\nMap " << *N << "\n"
808                         << "To  " << *NewN << "\n\n");
809     }
810 
811     M.mapToMetadata(N, NewN);
812 
813     // Nodes that were referenced out of order in the POT are involved in a
814     // uniquing cycle.
815     if (HadPlaceholder)
816       CyclicNodes.push_back(NewN);
817   }
818 
819   // Resolve cycles.
820   for (auto *N : CyclicNodes)
821     if (!N->isResolved())
822       N->resolveCycles();
823 }
824 
825 Metadata *MDNodeMapper::map(const MDNode &N) {
826   assert(DistinctWorklist.empty() && "MDNodeMapper::map is not recursive");
827   assert(!(M.Flags & RF_NoModuleLevelChanges) &&
828          "MDNodeMapper::map assumes module-level changes");
829 
830   // Require resolved nodes whenever metadata might be remapped.
831   assert(N.isResolved() && "Unexpected unresolved node");
832 
833   Metadata *MappedN =
834       N.isUniqued() ? mapTopLevelUniquedNode(N) : mapDistinctNode(N);
835   while (!DistinctWorklist.empty())
836     remapOperands(*DistinctWorklist.pop_back_val(), [this](Metadata *Old) {
837       if (std::optional<Metadata *> MappedOp = tryToMapOperand(Old))
838         return *MappedOp;
839       return mapTopLevelUniquedNode(*cast<MDNode>(Old));
840     });
841   return MappedN;
842 }
843 
844 Metadata *MDNodeMapper::mapTopLevelUniquedNode(const MDNode &FirstN) {
845   assert(FirstN.isUniqued() && "Expected uniqued node");
846 
847   // Create a post-order traversal of uniqued nodes under FirstN.
848   UniquedGraph G;
849   if (!createPOT(G, FirstN)) {
850     // Return early if no nodes have changed.
851     for (const MDNode *N : G.POT)
852       M.mapToSelf(N);
853     return &const_cast<MDNode &>(FirstN);
854   }
855 
856   // Update graph with all nodes that have changed.
857   G.propagateChanges();
858 
859   // Map all the nodes in the graph.
860   mapNodesInPOT(G);
861 
862   // Return the original node, remapped.
863   return *getMappedOp(&FirstN);
864 }
865 
866 std::optional<Metadata *> Mapper::mapSimpleMetadata(const Metadata *MD) {
867   // If the value already exists in the map, use it.
868   if (std::optional<Metadata *> NewMD = getVM().getMappedMD(MD))
869     return *NewMD;
870 
871   if (isa<MDString>(MD))
872     return const_cast<Metadata *>(MD);
873 
874   // This is a module-level metadata.  If nothing at the module level is
875   // changing, use an identity mapping.
876   if ((Flags & RF_NoModuleLevelChanges))
877     return const_cast<Metadata *>(MD);
878 
879   if (auto *CMD = dyn_cast<ConstantAsMetadata>(MD)) {
880     // Don't memoize ConstantAsMetadata.  Instead of lasting until the
881     // LLVMContext is destroyed, they can be deleted when the GlobalValue they
882     // reference is destructed.  These aren't super common, so the extra
883     // indirection isn't that expensive.
884     return wrapConstantAsMetadata(*CMD, mapValue(CMD->getValue()));
885   }
886 
887   assert(isa<MDNode>(MD) && "Expected a metadata node");
888 
889   return std::nullopt;
890 }
891 
892 Metadata *Mapper::mapMetadata(const Metadata *MD) {
893   assert(MD && "Expected valid metadata");
894   assert(!isa<LocalAsMetadata>(MD) && "Unexpected local metadata");
895 
896   if (std::optional<Metadata *> NewMD = mapSimpleMetadata(MD))
897     return *NewMD;
898 
899   return MDNodeMapper(*this).map(*cast<MDNode>(MD));
900 }
901 
902 void Mapper::flush() {
903   // Flush out the worklist of global values.
904   while (!Worklist.empty()) {
905     WorklistEntry E = Worklist.pop_back_val();
906     CurrentMCID = E.MCID;
907     switch (E.Kind) {
908     case WorklistEntry::MapGlobalInit:
909       E.Data.GVInit.GV->setInitializer(mapConstant(E.Data.GVInit.Init));
910       remapGlobalObjectMetadata(*E.Data.GVInit.GV);
911       break;
912     case WorklistEntry::MapAppendingVar: {
913       unsigned PrefixSize = AppendingInits.size() - E.AppendingGVNumNewMembers;
914       // mapAppendingVariable call can change AppendingInits if initalizer for
915       // the variable depends on another appending global, because of that inits
916       // need to be extracted and updated before the call.
917       SmallVector<Constant *, 8> NewInits(
918           drop_begin(AppendingInits, PrefixSize));
919       AppendingInits.resize(PrefixSize);
920       mapAppendingVariable(*E.Data.AppendingGV.GV,
921                            E.Data.AppendingGV.InitPrefix,
922                            E.AppendingGVIsOldCtorDtor, ArrayRef(NewInits));
923       break;
924     }
925     case WorklistEntry::MapAliasOrIFunc: {
926       GlobalValue *GV = E.Data.AliasOrIFunc.GV;
927       Constant *Target = mapConstant(E.Data.AliasOrIFunc.Target);
928       if (auto *GA = dyn_cast<GlobalAlias>(GV))
929         GA->setAliasee(Target);
930       else if (auto *GI = dyn_cast<GlobalIFunc>(GV))
931         GI->setResolver(Target);
932       else
933         llvm_unreachable("Not alias or ifunc");
934       break;
935     }
936     case WorklistEntry::RemapFunction:
937       remapFunction(*E.Data.RemapF);
938       break;
939     }
940   }
941   CurrentMCID = 0;
942 
943   // Finish logic for block addresses now that all global values have been
944   // handled.
945   while (!DelayedBBs.empty()) {
946     DelayedBasicBlock DBB = DelayedBBs.pop_back_val();
947     BasicBlock *BB = cast_or_null<BasicBlock>(mapValue(DBB.OldBB));
948     DBB.TempBB->replaceAllUsesWith(BB ? BB : DBB.OldBB);
949   }
950 }
951 
952 void Mapper::remapInstruction(Instruction *I) {
953   // Remap operands.
954   for (Use &Op : I->operands()) {
955     Value *V = mapValue(Op);
956     // If we aren't ignoring missing entries, assert that something happened.
957     if (V)
958       Op = V;
959     else
960       assert((Flags & RF_IgnoreMissingLocals) &&
961              "Referenced value not in value map!");
962   }
963 
964   // Remap phi nodes' incoming blocks.
965   if (PHINode *PN = dyn_cast<PHINode>(I)) {
966     for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
967       Value *V = mapValue(PN->getIncomingBlock(i));
968       // If we aren't ignoring missing entries, assert that something happened.
969       if (V)
970         PN->setIncomingBlock(i, cast<BasicBlock>(V));
971       else
972         assert((Flags & RF_IgnoreMissingLocals) &&
973                "Referenced block not in value map!");
974     }
975   }
976 
977   // Remap attached metadata.
978   SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
979   I->getAllMetadata(MDs);
980   for (const auto &MI : MDs) {
981     MDNode *Old = MI.second;
982     MDNode *New = cast_or_null<MDNode>(mapMetadata(Old));
983     if (New != Old)
984       I->setMetadata(MI.first, New);
985   }
986 
987   if (!TypeMapper)
988     return;
989 
990   // If the instruction's type is being remapped, do so now.
991   if (auto *CB = dyn_cast<CallBase>(I)) {
992     SmallVector<Type *, 3> Tys;
993     FunctionType *FTy = CB->getFunctionType();
994     Tys.reserve(FTy->getNumParams());
995     for (Type *Ty : FTy->params())
996       Tys.push_back(TypeMapper->remapType(Ty));
997     CB->mutateFunctionType(FunctionType::get(
998         TypeMapper->remapType(I->getType()), Tys, FTy->isVarArg()));
999 
1000     LLVMContext &C = CB->getContext();
1001     AttributeList Attrs = CB->getAttributes();
1002     for (unsigned i = 0; i < Attrs.getNumAttrSets(); ++i) {
1003       for (int AttrIdx = Attribute::FirstTypeAttr;
1004            AttrIdx <= Attribute::LastTypeAttr; AttrIdx++) {
1005         Attribute::AttrKind TypedAttr = (Attribute::AttrKind)AttrIdx;
1006         if (Type *Ty =
1007                 Attrs.getAttributeAtIndex(i, TypedAttr).getValueAsType()) {
1008           Attrs = Attrs.replaceAttributeTypeAtIndex(C, i, TypedAttr,
1009                                                     TypeMapper->remapType(Ty));
1010           break;
1011         }
1012       }
1013     }
1014     CB->setAttributes(Attrs);
1015     return;
1016   }
1017   if (auto *AI = dyn_cast<AllocaInst>(I))
1018     AI->setAllocatedType(TypeMapper->remapType(AI->getAllocatedType()));
1019   if (auto *GEP = dyn_cast<GetElementPtrInst>(I)) {
1020     GEP->setSourceElementType(
1021         TypeMapper->remapType(GEP->getSourceElementType()));
1022     GEP->setResultElementType(
1023         TypeMapper->remapType(GEP->getResultElementType()));
1024   }
1025   I->mutateType(TypeMapper->remapType(I->getType()));
1026 }
1027 
1028 void Mapper::remapGlobalObjectMetadata(GlobalObject &GO) {
1029   SmallVector<std::pair<unsigned, MDNode *>, 8> MDs;
1030   GO.getAllMetadata(MDs);
1031   GO.clearMetadata();
1032   for (const auto &I : MDs)
1033     GO.addMetadata(I.first, *cast<MDNode>(mapMetadata(I.second)));
1034 }
1035 
1036 void Mapper::remapFunction(Function &F) {
1037   // Remap the operands.
1038   for (Use &Op : F.operands())
1039     if (Op)
1040       Op = mapValue(Op);
1041 
1042   // Remap the metadata attachments.
1043   remapGlobalObjectMetadata(F);
1044 
1045   // Remap the argument types.
1046   if (TypeMapper)
1047     for (Argument &A : F.args())
1048       A.mutateType(TypeMapper->remapType(A.getType()));
1049 
1050   // Remap the instructions.
1051   for (BasicBlock &BB : F)
1052     for (Instruction &I : BB)
1053       remapInstruction(&I);
1054 }
1055 
1056 void Mapper::mapAppendingVariable(GlobalVariable &GV, Constant *InitPrefix,
1057                                   bool IsOldCtorDtor,
1058                                   ArrayRef<Constant *> NewMembers) {
1059   SmallVector<Constant *, 16> Elements;
1060   if (InitPrefix) {
1061     unsigned NumElements =
1062         cast<ArrayType>(InitPrefix->getType())->getNumElements();
1063     for (unsigned I = 0; I != NumElements; ++I)
1064       Elements.push_back(InitPrefix->getAggregateElement(I));
1065   }
1066 
1067   PointerType *VoidPtrTy;
1068   Type *EltTy;
1069   if (IsOldCtorDtor) {
1070     // FIXME: This upgrade is done during linking to support the C API.  See
1071     // also IRLinker::linkAppendingVarProto() in IRMover.cpp.
1072     VoidPtrTy = PointerType::getUnqual(GV.getContext());
1073     auto &ST = *cast<StructType>(NewMembers.front()->getType());
1074     Type *Tys[3] = {ST.getElementType(0), ST.getElementType(1), VoidPtrTy};
1075     EltTy = StructType::get(GV.getContext(), Tys, false);
1076   }
1077 
1078   for (auto *V : NewMembers) {
1079     Constant *NewV;
1080     if (IsOldCtorDtor) {
1081       auto *S = cast<ConstantStruct>(V);
1082       auto *E1 = cast<Constant>(mapValue(S->getOperand(0)));
1083       auto *E2 = cast<Constant>(mapValue(S->getOperand(1)));
1084       Constant *Null = Constant::getNullValue(VoidPtrTy);
1085       NewV = ConstantStruct::get(cast<StructType>(EltTy), E1, E2, Null);
1086     } else {
1087       NewV = cast_or_null<Constant>(mapValue(V));
1088     }
1089     Elements.push_back(NewV);
1090   }
1091 
1092   GV.setInitializer(
1093       ConstantArray::get(cast<ArrayType>(GV.getValueType()), Elements));
1094 }
1095 
1096 void Mapper::scheduleMapGlobalInitializer(GlobalVariable &GV, Constant &Init,
1097                                           unsigned MCID) {
1098   assert(AlreadyScheduled.insert(&GV).second && "Should not reschedule");
1099   assert(MCID < MCs.size() && "Invalid mapping context");
1100 
1101   WorklistEntry WE;
1102   WE.Kind = WorklistEntry::MapGlobalInit;
1103   WE.MCID = MCID;
1104   WE.Data.GVInit.GV = &GV;
1105   WE.Data.GVInit.Init = &Init;
1106   Worklist.push_back(WE);
1107 }
1108 
1109 void Mapper::scheduleMapAppendingVariable(GlobalVariable &GV,
1110                                           Constant *InitPrefix,
1111                                           bool IsOldCtorDtor,
1112                                           ArrayRef<Constant *> NewMembers,
1113                                           unsigned MCID) {
1114   assert(AlreadyScheduled.insert(&GV).second && "Should not reschedule");
1115   assert(MCID < MCs.size() && "Invalid mapping context");
1116 
1117   WorklistEntry WE;
1118   WE.Kind = WorklistEntry::MapAppendingVar;
1119   WE.MCID = MCID;
1120   WE.Data.AppendingGV.GV = &GV;
1121   WE.Data.AppendingGV.InitPrefix = InitPrefix;
1122   WE.AppendingGVIsOldCtorDtor = IsOldCtorDtor;
1123   WE.AppendingGVNumNewMembers = NewMembers.size();
1124   Worklist.push_back(WE);
1125   AppendingInits.append(NewMembers.begin(), NewMembers.end());
1126 }
1127 
1128 void Mapper::scheduleMapAliasOrIFunc(GlobalValue &GV, Constant &Target,
1129                                      unsigned MCID) {
1130   assert(AlreadyScheduled.insert(&GV).second && "Should not reschedule");
1131   assert((isa<GlobalAlias>(GV) || isa<GlobalIFunc>(GV)) &&
1132          "Should be alias or ifunc");
1133   assert(MCID < MCs.size() && "Invalid mapping context");
1134 
1135   WorklistEntry WE;
1136   WE.Kind = WorklistEntry::MapAliasOrIFunc;
1137   WE.MCID = MCID;
1138   WE.Data.AliasOrIFunc.GV = &GV;
1139   WE.Data.AliasOrIFunc.Target = &Target;
1140   Worklist.push_back(WE);
1141 }
1142 
1143 void Mapper::scheduleRemapFunction(Function &F, unsigned MCID) {
1144   assert(AlreadyScheduled.insert(&F).second && "Should not reschedule");
1145   assert(MCID < MCs.size() && "Invalid mapping context");
1146 
1147   WorklistEntry WE;
1148   WE.Kind = WorklistEntry::RemapFunction;
1149   WE.MCID = MCID;
1150   WE.Data.RemapF = &F;
1151   Worklist.push_back(WE);
1152 }
1153 
1154 void Mapper::addFlags(RemapFlags Flags) {
1155   assert(!hasWorkToDo() && "Expected to have flushed the worklist");
1156   this->Flags = this->Flags | Flags;
1157 }
1158 
1159 static Mapper *getAsMapper(void *pImpl) {
1160   return reinterpret_cast<Mapper *>(pImpl);
1161 }
1162 
1163 namespace {
1164 
1165 class FlushingMapper {
1166   Mapper &M;
1167 
1168 public:
1169   explicit FlushingMapper(void *pImpl) : M(*getAsMapper(pImpl)) {
1170     assert(!M.hasWorkToDo() && "Expected to be flushed");
1171   }
1172 
1173   ~FlushingMapper() { M.flush(); }
1174 
1175   Mapper *operator->() const { return &M; }
1176 };
1177 
1178 } // end anonymous namespace
1179 
1180 ValueMapper::ValueMapper(ValueToValueMapTy &VM, RemapFlags Flags,
1181                          ValueMapTypeRemapper *TypeMapper,
1182                          ValueMaterializer *Materializer)
1183     : pImpl(new Mapper(VM, Flags, TypeMapper, Materializer)) {}
1184 
1185 ValueMapper::~ValueMapper() { delete getAsMapper(pImpl); }
1186 
1187 unsigned
1188 ValueMapper::registerAlternateMappingContext(ValueToValueMapTy &VM,
1189                                              ValueMaterializer *Materializer) {
1190   return getAsMapper(pImpl)->registerAlternateMappingContext(VM, Materializer);
1191 }
1192 
1193 void ValueMapper::addFlags(RemapFlags Flags) {
1194   FlushingMapper(pImpl)->addFlags(Flags);
1195 }
1196 
1197 Value *ValueMapper::mapValue(const Value &V) {
1198   return FlushingMapper(pImpl)->mapValue(&V);
1199 }
1200 
1201 Constant *ValueMapper::mapConstant(const Constant &C) {
1202   return cast_or_null<Constant>(mapValue(C));
1203 }
1204 
1205 Metadata *ValueMapper::mapMetadata(const Metadata &MD) {
1206   return FlushingMapper(pImpl)->mapMetadata(&MD);
1207 }
1208 
1209 MDNode *ValueMapper::mapMDNode(const MDNode &N) {
1210   return cast_or_null<MDNode>(mapMetadata(N));
1211 }
1212 
1213 void ValueMapper::remapInstruction(Instruction &I) {
1214   FlushingMapper(pImpl)->remapInstruction(&I);
1215 }
1216 
1217 void ValueMapper::remapDPValue(Module *M, DPValue &V) {
1218   FlushingMapper(pImpl)->remapDPValue(V);
1219 }
1220 
1221 void ValueMapper::remapDPValueRange(
1222     Module *M, iterator_range<DPValue::self_iterator> Range) {
1223   for (DPValue &DPV : Range) {
1224     remapDPValue(M, DPV);
1225   }
1226 }
1227 
1228 void ValueMapper::remapFunction(Function &F) {
1229   FlushingMapper(pImpl)->remapFunction(F);
1230 }
1231 
1232 void ValueMapper::remapGlobalObjectMetadata(GlobalObject &GO) {
1233   FlushingMapper(pImpl)->remapGlobalObjectMetadata(GO);
1234 }
1235 
1236 void ValueMapper::scheduleMapGlobalInitializer(GlobalVariable &GV,
1237                                                Constant &Init,
1238                                                unsigned MCID) {
1239   getAsMapper(pImpl)->scheduleMapGlobalInitializer(GV, Init, MCID);
1240 }
1241 
1242 void ValueMapper::scheduleMapAppendingVariable(GlobalVariable &GV,
1243                                                Constant *InitPrefix,
1244                                                bool IsOldCtorDtor,
1245                                                ArrayRef<Constant *> NewMembers,
1246                                                unsigned MCID) {
1247   getAsMapper(pImpl)->scheduleMapAppendingVariable(
1248       GV, InitPrefix, IsOldCtorDtor, NewMembers, MCID);
1249 }
1250 
1251 void ValueMapper::scheduleMapGlobalAlias(GlobalAlias &GA, Constant &Aliasee,
1252                                          unsigned MCID) {
1253   getAsMapper(pImpl)->scheduleMapAliasOrIFunc(GA, Aliasee, MCID);
1254 }
1255 
1256 void ValueMapper::scheduleMapGlobalIFunc(GlobalIFunc &GI, Constant &Resolver,
1257                                          unsigned MCID) {
1258   getAsMapper(pImpl)->scheduleMapAliasOrIFunc(GI, Resolver, MCID);
1259 }
1260 
1261 void ValueMapper::scheduleRemapFunction(Function &F, unsigned MCID) {
1262   getAsMapper(pImpl)->scheduleRemapFunction(F, MCID);
1263 }
1264