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
46using namespace llvm;
47
48#define DEBUG_TYPE "value-mapper"
49
50// Out of line method to get vtable etc for class.
51void ValueMapTypeRemapper::anchor() {}
52void ValueMaterializer::anchor() {}
53
54namespace {
55
56/// A basic block used in a BlockAddress whose function body is not yet
57/// materialized.
58struct DelayedBasicBlock {
59 BasicBlock *OldBB;
60 std::unique_ptr<BasicBlock> TempBB;
61
62 DelayedBasicBlock(const BlockAddress &Old)
63 : OldBB(Old.getBasicBlock()),
64 TempBB(BasicBlock::Create(Context&: Old.getContext())) {}
65};
66
67struct 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
99struct 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
109class 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
124public:
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(Elt: 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 remapDbgRecord(DbgRecord &DVR);
150
151 Constant *mapConstant(const Constant *C) {
152 return cast_or_null<Constant>(Val: mapValue(V: 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
173private:
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
190class 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
222public:
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
245private:
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
339Value *Mapper::mapValue(const Value *V) {
340 ValueToValueMapTy::iterator I = getVM().find(Val: 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(V: 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>(Val: 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>(Val: V)) {
365 // Inline asm may need *type* remapping.
366 FunctionType *NewTy = IA->getFunctionType();
367 if (TypeMapper) {
368 NewTy = cast<FunctionType>(Val: TypeMapper->remapType(SrcTy: NewTy));
369
370 if (NewTy != IA->getFunctionType())
371 V = InlineAsm::get(Ty: NewTy, AsmString: IA->getAsmString(), Constraints: IA->getConstraintString(),
372 hasSideEffects: IA->hasSideEffects(), isAlignStack: IA->isAlignStack(),
373 asmDialect: IA->getDialect(), canThrow: IA->canThrow());
374 }
375
376 return getVM()[V] = const_cast<Value *>(V);
377 }
378
379 if (const auto *MDV = dyn_cast<MetadataAsValue>(Val: V)) {
380 const Metadata *MD = MDV->getMetadata();
381
382 if (auto *LAM = dyn_cast<LocalAsMetadata>(Val: MD)) {
383 // Look through to grab the local value.
384 if (Value *LV = mapValue(V: LAM->getValue())) {
385 if (V == LAM->getValue())
386 return const_cast<Value *>(V);
387 return MetadataAsValue::get(Context&: V->getContext(), MD: ValueAsMetadata::get(V: 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 Context&: V->getContext(),
396 MD: MDTuple::get(Context&: V->getContext(), MDs: std::nullopt));
397 }
398 if (auto *AL = dyn_cast<DIArgList>(Val: 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>(Val: VAM)) {
407 MappedArgs.push_back(Elt: VAM);
408 } else if (Value *LV = mapValue(V: VAM->getValue())) {
409 MappedArgs.push_back(
410 Elt: LV == VAM->getValue() ? VAM : ValueAsMetadata::get(V: LV));
411 } else if ((Flags & RF_IgnoreMissingLocals) && isa<LocalAsMetadata>(Val: VAM)) {
412 MappedArgs.push_back(Elt: VAM);
413 } else {
414 // If we cannot map the value, set the argument as undef.
415 MappedArgs.push_back(Elt: ValueAsMetadata::get(
416 V: UndefValue::get(T: VAM->getValue()->getType())));
417 }
418 }
419 return MetadataAsValue::get(Context&: V->getContext(),
420 MD: DIArgList::get(Context&: V->getContext(), Args: 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(Context&: V->getContext(), MD: 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>(Val: V));
438 if (!C)
439 return nullptr;
440
441 if (BlockAddress *BA = dyn_cast<BlockAddress>(Val: C))
442 return mapBlockAddress(BA: *BA);
443
444 if (const auto *E = dyn_cast<DSOLocalEquivalent>(Val: C)) {
445 auto *Val = mapValue(V: 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: Val->stripPointerCastsAndAliases());
451 Type *NewTy = E->getType();
452 if (TypeMapper)
453 NewTy = TypeMapper->remapType(SrcTy: NewTy);
454 return getVM()[E] = llvm::ConstantExpr::getBitCast(
455 C: DSOLocalEquivalent::get(GV: Func), Ty: NewTy);
456 }
457
458 if (const auto *NC = dyn_cast<NoCFIValue>(Val: C)) {
459 auto *Val = mapValue(V: 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(i: 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(SrcTy: 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(N: NumOperands);
499 for (unsigned j = 0; j != OpNo; ++j)
500 Ops.push_back(Elt: cast<Constant>(Val: C->getOperand(i: j)));
501
502 // If one of the operands mismatch, push it and the other mapped operands.
503 if (OpNo != NumOperands) {
504 Ops.push_back(Elt: cast<Constant>(Val: 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(i: OpNo));
509 if (!Mapped)
510 return nullptr;
511 Ops.push_back(Elt: cast<Constant>(Val: Mapped));
512 }
513 }
514 Type *NewSrcTy = nullptr;
515 if (TypeMapper)
516 if (auto *GEPO = dyn_cast<GEPOperator>(Val: C))
517 NewSrcTy = TypeMapper->remapType(SrcTy: GEPO->getSourceElementType());
518
519 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Val: C))
520 return getVM()[V] = CE->getWithOperands(Ops, Ty: NewTy, OnlyIfReduced: false, SrcTy: NewSrcTy);
521 if (isa<ConstantArray>(Val: C))
522 return getVM()[V] = ConstantArray::get(T: cast<ArrayType>(Val: NewTy), V: Ops);
523 if (isa<ConstantStruct>(Val: C))
524 return getVM()[V] = ConstantStruct::get(T: cast<StructType>(Val: NewTy), V: Ops);
525 if (isa<ConstantVector>(Val: C))
526 return getVM()[V] = ConstantVector::get(V: Ops);
527 // If this is a no-operand constant, it must be because the type was remapped.
528 if (isa<PoisonValue>(Val: C))
529 return getVM()[V] = PoisonValue::get(T: NewTy);
530 if (isa<UndefValue>(Val: C))
531 return getVM()[V] = UndefValue::get(T: NewTy);
532 if (isa<ConstantAggregateZero>(Val: C))
533 return getVM()[V] = ConstantAggregateZero::get(Ty: NewTy);
534 if (isa<ConstantTargetNone>(Val: C))
535 return getVM()[V] = Constant::getNullValue(Ty: NewTy);
536 assert(isa<ConstantPointerNull>(C));
537 return getVM()[V] = ConstantPointerNull::get(T: cast<PointerType>(Val: NewTy));
538}
539
540void Mapper::remapDbgRecord(DbgRecord &DR) {
541 // Remap DILocations.
542 auto *MappedDILoc = mapMetadata(MD: DR.getDebugLoc());
543 DR.setDebugLoc(DebugLoc(cast<DILocation>(Val: MappedDILoc)));
544
545 if (DbgLabelRecord *DLR = dyn_cast<DbgLabelRecord>(Val: &DR)) {
546 // Remap labels.
547 DLR->setLabel(cast<DILabel>(Val: mapMetadata(MD: DLR->getLabel())));
548 return;
549 }
550
551 DbgVariableRecord &V = cast<DbgVariableRecord>(Val&: DR);
552 // Remap variables.
553 auto *MappedVar = mapMetadata(MD: V.getVariable());
554 V.setVariable(cast<DILocalVariable>(Val: MappedVar));
555
556 bool IgnoreMissingLocals = Flags & RF_IgnoreMissingLocals;
557
558 if (V.isDbgAssign()) {
559 auto *NewAddr = mapValue(V: V.getAddress());
560 if (!IgnoreMissingLocals && !NewAddr)
561 V.setKillAddress();
562 else if (NewAddr)
563 V.setAddress(NewAddr);
564 V.setAssignId(cast<DIAssignID>(Val: mapMetadata(MD: V.getAssignID())));
565 }
566
567 // Find Value operands and remap those.
568 SmallVector<Value *, 4> Vals, NewVals;
569 for (Value *Val : V.location_ops())
570 Vals.push_back(Elt: Val);
571 for (Value *Val : Vals)
572 NewVals.push_back(Elt: mapValue(V: Val));
573
574 // If there are no changes to the Value operands, finished.
575 if (Vals == NewVals)
576 return;
577
578 // Otherwise, do some replacement.
579 if (!IgnoreMissingLocals &&
580 llvm::any_of(Range&: NewVals, P: [&](Value *V) { return V == nullptr; })) {
581 V.setKillLocation();
582 } else {
583 // Either we have all non-empty NewVals, or we're permitted to ignore
584 // missing locals.
585 for (unsigned int I = 0; I < Vals.size(); ++I)
586 if (NewVals[I])
587 V.replaceVariableLocationOp(OpIdx: I, NewValue: NewVals[I]);
588 }
589}
590
591Value *Mapper::mapBlockAddress(const BlockAddress &BA) {
592 Function *F = cast<Function>(Val: mapValue(V: BA.getFunction()));
593
594 // F may not have materialized its initializer. In that case, create a
595 // dummy basic block for now, and replace it once we've materialized all
596 // the initializers.
597 BasicBlock *BB;
598 if (F->empty()) {
599 DelayedBBs.push_back(Elt: DelayedBasicBlock(BA));
600 BB = DelayedBBs.back().TempBB.get();
601 } else {
602 BB = cast_or_null<BasicBlock>(Val: mapValue(V: BA.getBasicBlock()));
603 }
604
605 return getVM()[&BA] = BlockAddress::get(F, BB: BB ? BB : BA.getBasicBlock());
606}
607
608Metadata *Mapper::mapToMetadata(const Metadata *Key, Metadata *Val) {
609 getVM().MD()[Key].reset(MD: Val);
610 return Val;
611}
612
613Metadata *Mapper::mapToSelf(const Metadata *MD) {
614 return mapToMetadata(Key: MD, Val: const_cast<Metadata *>(MD));
615}
616
617std::optional<Metadata *> MDNodeMapper::tryToMapOperand(const Metadata *Op) {
618 if (!Op)
619 return nullptr;
620
621 if (std::optional<Metadata *> MappedOp = M.mapSimpleMetadata(MD: Op)) {
622#ifndef NDEBUG
623 if (auto *CMD = dyn_cast<ConstantAsMetadata>(Op))
624 assert((!*MappedOp || M.getVM().count(CMD->getValue()) ||
625 M.getVM().getMappedMD(Op)) &&
626 "Expected Value to be memoized");
627 else
628 assert((isa<MDString>(Op) || M.getVM().getMappedMD(Op)) &&
629 "Expected result to be memoized");
630#endif
631 return *MappedOp;
632 }
633
634 const MDNode &N = *cast<MDNode>(Val: Op);
635 if (N.isDistinct())
636 return mapDistinctNode(N);
637 return std::nullopt;
638}
639
640MDNode *MDNodeMapper::mapDistinctNode(const MDNode &N) {
641 assert(N.isDistinct() && "Expected a distinct node");
642 assert(!M.getVM().getMappedMD(&N) && "Expected an unmapped node");
643 Metadata *NewM = nullptr;
644
645 if (M.Flags & RF_ReuseAndMutateDistinctMDs) {
646 NewM = M.mapToSelf(MD: &N);
647 } else {
648 NewM = MDNode::replaceWithDistinct(N: N.clone());
649 LLVM_DEBUG(dbgs() << "\nMap " << N << "\n"
650 << "To " << *NewM << "\n\n");
651 M.mapToMetadata(Key: &N, Val: NewM);
652 }
653 DistinctWorklist.push_back(Elt: cast<MDNode>(Val: NewM));
654
655 return DistinctWorklist.back();
656}
657
658static ConstantAsMetadata *wrapConstantAsMetadata(const ConstantAsMetadata &CMD,
659 Value *MappedV) {
660 if (CMD.getValue() == MappedV)
661 return const_cast<ConstantAsMetadata *>(&CMD);
662 return MappedV ? ConstantAsMetadata::getConstant(C: MappedV) : nullptr;
663}
664
665std::optional<Metadata *> MDNodeMapper::getMappedOp(const Metadata *Op) const {
666 if (!Op)
667 return nullptr;
668
669 if (std::optional<Metadata *> MappedOp = M.getVM().getMappedMD(MD: Op))
670 return *MappedOp;
671
672 if (isa<MDString>(Val: Op))
673 return const_cast<Metadata *>(Op);
674
675 if (auto *CMD = dyn_cast<ConstantAsMetadata>(Val: Op))
676 return wrapConstantAsMetadata(CMD: *CMD, MappedV: M.getVM().lookup(Val: CMD->getValue()));
677
678 return std::nullopt;
679}
680
681Metadata &MDNodeMapper::UniquedGraph::getFwdReference(MDNode &Op) {
682 auto Where = Info.find(Val: &Op);
683 assert(Where != Info.end() && "Expected a valid reference");
684
685 auto &OpD = Where->second;
686 if (!OpD.HasChanged)
687 return Op;
688
689 // Lazily construct a temporary node.
690 if (!OpD.Placeholder)
691 OpD.Placeholder = Op.clone();
692
693 return *OpD.Placeholder;
694}
695
696template <class OperandMapper>
697void MDNodeMapper::remapOperands(MDNode &N, OperandMapper mapOperand) {
698 assert(!N.isUniqued() && "Expected distinct or temporary nodes");
699 for (unsigned I = 0, E = N.getNumOperands(); I != E; ++I) {
700 Metadata *Old = N.getOperand(I);
701 Metadata *New = mapOperand(Old);
702 if (Old != New)
703 LLVM_DEBUG(dbgs() << "Replacing Op " << Old << " with " << New << " in "
704 << N << "\n");
705
706 if (Old != New)
707 N.replaceOperandWith(I, New);
708 }
709}
710
711namespace {
712
713/// An entry in the worklist for the post-order traversal.
714struct POTWorklistEntry {
715 MDNode *N; ///< Current node.
716 MDNode::op_iterator Op; ///< Current operand of \c N.
717
718 /// Keep a flag of whether operands have changed in the worklist to avoid
719 /// hitting the map in \a UniquedGraph.
720 bool HasChanged = false;
721
722 POTWorklistEntry(MDNode &N) : N(&N), Op(N.op_begin()) {}
723};
724
725} // end anonymous namespace
726
727bool MDNodeMapper::createPOT(UniquedGraph &G, const MDNode &FirstN) {
728 assert(G.Info.empty() && "Expected a fresh traversal");
729 assert(FirstN.isUniqued() && "Expected uniqued node in POT");
730
731 // Construct a post-order traversal of the uniqued subgraph under FirstN.
732 bool AnyChanges = false;
733 SmallVector<POTWorklistEntry, 16> Worklist;
734 Worklist.push_back(Elt: POTWorklistEntry(const_cast<MDNode &>(FirstN)));
735 (void)G.Info[&FirstN];
736 while (!Worklist.empty()) {
737 // Start or continue the traversal through the this node's operands.
738 auto &WE = Worklist.back();
739 if (MDNode *N = visitOperands(G, I&: WE.Op, E: WE.N->op_end(), HasChanged&: WE.HasChanged)) {
740 // Push a new node to traverse first.
741 Worklist.push_back(Elt: POTWorklistEntry(*N));
742 continue;
743 }
744
745 // Push the node onto the POT.
746 assert(WE.N->isUniqued() && "Expected only uniqued nodes");
747 assert(WE.Op == WE.N->op_end() && "Expected to visit all operands");
748 auto &D = G.Info[WE.N];
749 AnyChanges |= D.HasChanged = WE.HasChanged;
750 D.ID = G.POT.size();
751 G.POT.push_back(Elt: WE.N);
752
753 // Pop the node off the worklist.
754 Worklist.pop_back();
755 }
756 return AnyChanges;
757}
758
759MDNode *MDNodeMapper::visitOperands(UniquedGraph &G, MDNode::op_iterator &I,
760 MDNode::op_iterator E, bool &HasChanged) {
761 while (I != E) {
762 Metadata *Op = *I++; // Increment even on early return.
763 if (std::optional<Metadata *> MappedOp = tryToMapOperand(Op)) {
764 // Check if the operand changes.
765 HasChanged |= Op != *MappedOp;
766 continue;
767 }
768
769 // A uniqued metadata node.
770 MDNode &OpN = *cast<MDNode>(Val: Op);
771 assert(OpN.isUniqued() &&
772 "Only uniqued operands cannot be mapped immediately");
773 if (G.Info.insert(KV: std::make_pair(x: &OpN, y: Data())).second)
774 return &OpN; // This is a new one. Return it.
775 }
776 return nullptr;
777}
778
779void MDNodeMapper::UniquedGraph::propagateChanges() {
780 bool AnyChanges;
781 do {
782 AnyChanges = false;
783 for (MDNode *N : POT) {
784 auto &D = Info[N];
785 if (D.HasChanged)
786 continue;
787
788 if (llvm::none_of(Range: N->operands(), P: [&](const Metadata *Op) {
789 auto Where = Info.find(Val: Op);
790 return Where != Info.end() && Where->second.HasChanged;
791 }))
792 continue;
793
794 AnyChanges = D.HasChanged = true;
795 }
796 } while (AnyChanges);
797}
798
799void MDNodeMapper::mapNodesInPOT(UniquedGraph &G) {
800 // Construct uniqued nodes, building forward references as necessary.
801 SmallVector<MDNode *, 16> CyclicNodes;
802 for (auto *N : G.POT) {
803 auto &D = G.Info[N];
804 if (!D.HasChanged) {
805 // The node hasn't changed.
806 M.mapToSelf(MD: N);
807 continue;
808 }
809
810 // Remember whether this node had a placeholder.
811 bool HadPlaceholder(D.Placeholder);
812
813 // Clone the uniqued node and remap the operands.
814 TempMDNode ClonedN = D.Placeholder ? std::move(D.Placeholder) : N->clone();
815 remapOperands(N&: *ClonedN, mapOperand: [this, &D, &G](Metadata *Old) {
816 if (std::optional<Metadata *> MappedOp = getMappedOp(Op: Old))
817 return *MappedOp;
818 (void)D;
819 assert(G.Info[Old].ID > D.ID && "Expected a forward reference");
820 return &G.getFwdReference(Op&: *cast<MDNode>(Val: Old));
821 });
822
823 auto *NewN = MDNode::replaceWithUniqued(N: std::move(ClonedN));
824 if (N && NewN && N != NewN) {
825 LLVM_DEBUG(dbgs() << "\nMap " << *N << "\n"
826 << "To " << *NewN << "\n\n");
827 }
828
829 M.mapToMetadata(Key: N, Val: NewN);
830
831 // Nodes that were referenced out of order in the POT are involved in a
832 // uniquing cycle.
833 if (HadPlaceholder)
834 CyclicNodes.push_back(Elt: NewN);
835 }
836
837 // Resolve cycles.
838 for (auto *N : CyclicNodes)
839 if (!N->isResolved())
840 N->resolveCycles();
841}
842
843Metadata *MDNodeMapper::map(const MDNode &N) {
844 assert(DistinctWorklist.empty() && "MDNodeMapper::map is not recursive");
845 assert(!(M.Flags & RF_NoModuleLevelChanges) &&
846 "MDNodeMapper::map assumes module-level changes");
847
848 // Require resolved nodes whenever metadata might be remapped.
849 assert(N.isResolved() && "Unexpected unresolved node");
850
851 Metadata *MappedN =
852 N.isUniqued() ? mapTopLevelUniquedNode(FirstN: N) : mapDistinctNode(N);
853 while (!DistinctWorklist.empty())
854 remapOperands(N&: *DistinctWorklist.pop_back_val(), mapOperand: [this](Metadata *Old) {
855 if (std::optional<Metadata *> MappedOp = tryToMapOperand(Op: Old))
856 return *MappedOp;
857 return mapTopLevelUniquedNode(FirstN: *cast<MDNode>(Val: Old));
858 });
859 return MappedN;
860}
861
862Metadata *MDNodeMapper::mapTopLevelUniquedNode(const MDNode &FirstN) {
863 assert(FirstN.isUniqued() && "Expected uniqued node");
864
865 // Create a post-order traversal of uniqued nodes under FirstN.
866 UniquedGraph G;
867 if (!createPOT(G, FirstN)) {
868 // Return early if no nodes have changed.
869 for (const MDNode *N : G.POT)
870 M.mapToSelf(MD: N);
871 return &const_cast<MDNode &>(FirstN);
872 }
873
874 // Update graph with all nodes that have changed.
875 G.propagateChanges();
876
877 // Map all the nodes in the graph.
878 mapNodesInPOT(G);
879
880 // Return the original node, remapped.
881 return *getMappedOp(Op: &FirstN);
882}
883
884std::optional<Metadata *> Mapper::mapSimpleMetadata(const Metadata *MD) {
885 // If the value already exists in the map, use it.
886 if (std::optional<Metadata *> NewMD = getVM().getMappedMD(MD))
887 return *NewMD;
888
889 if (isa<MDString>(Val: MD))
890 return const_cast<Metadata *>(MD);
891
892 // This is a module-level metadata. If nothing at the module level is
893 // changing, use an identity mapping.
894 if ((Flags & RF_NoModuleLevelChanges))
895 return const_cast<Metadata *>(MD);
896
897 if (auto *CMD = dyn_cast<ConstantAsMetadata>(Val: MD)) {
898 // Don't memoize ConstantAsMetadata. Instead of lasting until the
899 // LLVMContext is destroyed, they can be deleted when the GlobalValue they
900 // reference is destructed. These aren't super common, so the extra
901 // indirection isn't that expensive.
902 return wrapConstantAsMetadata(CMD: *CMD, MappedV: mapValue(V: CMD->getValue()));
903 }
904
905 assert(isa<MDNode>(MD) && "Expected a metadata node");
906
907 return std::nullopt;
908}
909
910Metadata *Mapper::mapMetadata(const Metadata *MD) {
911 assert(MD && "Expected valid metadata");
912 assert(!isa<LocalAsMetadata>(MD) && "Unexpected local metadata");
913
914 if (std::optional<Metadata *> NewMD = mapSimpleMetadata(MD))
915 return *NewMD;
916
917 return MDNodeMapper(*this).map(N: *cast<MDNode>(Val: MD));
918}
919
920void Mapper::flush() {
921 // Flush out the worklist of global values.
922 while (!Worklist.empty()) {
923 WorklistEntry E = Worklist.pop_back_val();
924 CurrentMCID = E.MCID;
925 switch (E.Kind) {
926 case WorklistEntry::MapGlobalInit:
927 E.Data.GVInit.GV->setInitializer(mapConstant(C: E.Data.GVInit.Init));
928 remapGlobalObjectMetadata(GO&: *E.Data.GVInit.GV);
929 break;
930 case WorklistEntry::MapAppendingVar: {
931 unsigned PrefixSize = AppendingInits.size() - E.AppendingGVNumNewMembers;
932 // mapAppendingVariable call can change AppendingInits if initalizer for
933 // the variable depends on another appending global, because of that inits
934 // need to be extracted and updated before the call.
935 SmallVector<Constant *, 8> NewInits(
936 drop_begin(RangeOrContainer&: AppendingInits, N: PrefixSize));
937 AppendingInits.resize(N: PrefixSize);
938 mapAppendingVariable(GV&: *E.Data.AppendingGV.GV,
939 InitPrefix: E.Data.AppendingGV.InitPrefix,
940 IsOldCtorDtor: E.AppendingGVIsOldCtorDtor, NewMembers: ArrayRef(NewInits));
941 break;
942 }
943 case WorklistEntry::MapAliasOrIFunc: {
944 GlobalValue *GV = E.Data.AliasOrIFunc.GV;
945 Constant *Target = mapConstant(C: E.Data.AliasOrIFunc.Target);
946 if (auto *GA = dyn_cast<GlobalAlias>(Val: GV))
947 GA->setAliasee(Target);
948 else if (auto *GI = dyn_cast<GlobalIFunc>(Val: GV))
949 GI->setResolver(Target);
950 else
951 llvm_unreachable("Not alias or ifunc");
952 break;
953 }
954 case WorklistEntry::RemapFunction:
955 remapFunction(F&: *E.Data.RemapF);
956 break;
957 }
958 }
959 CurrentMCID = 0;
960
961 // Finish logic for block addresses now that all global values have been
962 // handled.
963 while (!DelayedBBs.empty()) {
964 DelayedBasicBlock DBB = DelayedBBs.pop_back_val();
965 BasicBlock *BB = cast_or_null<BasicBlock>(Val: mapValue(V: DBB.OldBB));
966 DBB.TempBB->replaceAllUsesWith(V: BB ? BB : DBB.OldBB);
967 }
968}
969
970void Mapper::remapInstruction(Instruction *I) {
971 // Remap operands.
972 for (Use &Op : I->operands()) {
973 Value *V = mapValue(V: Op);
974 // If we aren't ignoring missing entries, assert that something happened.
975 if (V)
976 Op = V;
977 else
978 assert((Flags & RF_IgnoreMissingLocals) &&
979 "Referenced value not in value map!");
980 }
981
982 // Remap phi nodes' incoming blocks.
983 if (PHINode *PN = dyn_cast<PHINode>(Val: I)) {
984 for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
985 Value *V = mapValue(V: PN->getIncomingBlock(i));
986 // If we aren't ignoring missing entries, assert that something happened.
987 if (V)
988 PN->setIncomingBlock(i, BB: cast<BasicBlock>(Val: V));
989 else
990 assert((Flags & RF_IgnoreMissingLocals) &&
991 "Referenced block not in value map!");
992 }
993 }
994
995 // Remap attached metadata.
996 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
997 I->getAllMetadata(MDs);
998 for (const auto &MI : MDs) {
999 MDNode *Old = MI.second;
1000 MDNode *New = cast_or_null<MDNode>(Val: mapMetadata(MD: Old));
1001 if (New != Old)
1002 I->setMetadata(KindID: MI.first, Node: New);
1003 }
1004
1005 if (!TypeMapper)
1006 return;
1007
1008 // If the instruction's type is being remapped, do so now.
1009 if (auto *CB = dyn_cast<CallBase>(Val: I)) {
1010 SmallVector<Type *, 3> Tys;
1011 FunctionType *FTy = CB->getFunctionType();
1012 Tys.reserve(N: FTy->getNumParams());
1013 for (Type *Ty : FTy->params())
1014 Tys.push_back(Elt: TypeMapper->remapType(SrcTy: Ty));
1015 CB->mutateFunctionType(FTy: FunctionType::get(
1016 Result: TypeMapper->remapType(SrcTy: I->getType()), Params: Tys, isVarArg: FTy->isVarArg()));
1017
1018 LLVMContext &C = CB->getContext();
1019 AttributeList Attrs = CB->getAttributes();
1020 for (unsigned i = 0; i < Attrs.getNumAttrSets(); ++i) {
1021 for (int AttrIdx = Attribute::FirstTypeAttr;
1022 AttrIdx <= Attribute::LastTypeAttr; AttrIdx++) {
1023 Attribute::AttrKind TypedAttr = (Attribute::AttrKind)AttrIdx;
1024 if (Type *Ty =
1025 Attrs.getAttributeAtIndex(Index: i, Kind: TypedAttr).getValueAsType()) {
1026 Attrs = Attrs.replaceAttributeTypeAtIndex(C, ArgNo: i, Kind: TypedAttr,
1027 ReplacementTy: TypeMapper->remapType(SrcTy: Ty));
1028 break;
1029 }
1030 }
1031 }
1032 CB->setAttributes(Attrs);
1033 return;
1034 }
1035 if (auto *AI = dyn_cast<AllocaInst>(Val: I))
1036 AI->setAllocatedType(TypeMapper->remapType(SrcTy: AI->getAllocatedType()));
1037 if (auto *GEP = dyn_cast<GetElementPtrInst>(Val: I)) {
1038 GEP->setSourceElementType(
1039 TypeMapper->remapType(SrcTy: GEP->getSourceElementType()));
1040 GEP->setResultElementType(
1041 TypeMapper->remapType(SrcTy: GEP->getResultElementType()));
1042 }
1043 I->mutateType(Ty: TypeMapper->remapType(SrcTy: I->getType()));
1044}
1045
1046void Mapper::remapGlobalObjectMetadata(GlobalObject &GO) {
1047 SmallVector<std::pair<unsigned, MDNode *>, 8> MDs;
1048 GO.getAllMetadata(MDs);
1049 GO.clearMetadata();
1050 for (const auto &I : MDs)
1051 GO.addMetadata(KindID: I.first, MD&: *cast<MDNode>(Val: mapMetadata(MD: I.second)));
1052}
1053
1054void Mapper::remapFunction(Function &F) {
1055 // Remap the operands.
1056 for (Use &Op : F.operands())
1057 if (Op)
1058 Op = mapValue(V: Op);
1059
1060 // Remap the metadata attachments.
1061 remapGlobalObjectMetadata(GO&: F);
1062
1063 // Remap the argument types.
1064 if (TypeMapper)
1065 for (Argument &A : F.args())
1066 A.mutateType(Ty: TypeMapper->remapType(SrcTy: A.getType()));
1067
1068 // Remap the instructions.
1069 for (BasicBlock &BB : F) {
1070 for (Instruction &I : BB) {
1071 remapInstruction(I: &I);
1072 for (DbgRecord &DR : I.getDbgRecordRange())
1073 remapDbgRecord(DR);
1074 }
1075 }
1076}
1077
1078void Mapper::mapAppendingVariable(GlobalVariable &GV, Constant *InitPrefix,
1079 bool IsOldCtorDtor,
1080 ArrayRef<Constant *> NewMembers) {
1081 SmallVector<Constant *, 16> Elements;
1082 if (InitPrefix) {
1083 unsigned NumElements =
1084 cast<ArrayType>(Val: InitPrefix->getType())->getNumElements();
1085 for (unsigned I = 0; I != NumElements; ++I)
1086 Elements.push_back(Elt: InitPrefix->getAggregateElement(Elt: I));
1087 }
1088
1089 PointerType *VoidPtrTy;
1090 Type *EltTy;
1091 if (IsOldCtorDtor) {
1092 // FIXME: This upgrade is done during linking to support the C API. See
1093 // also IRLinker::linkAppendingVarProto() in IRMover.cpp.
1094 VoidPtrTy = PointerType::getUnqual(C&: GV.getContext());
1095 auto &ST = *cast<StructType>(Val: NewMembers.front()->getType());
1096 Type *Tys[3] = {ST.getElementType(N: 0), ST.getElementType(N: 1), VoidPtrTy};
1097 EltTy = StructType::get(Context&: GV.getContext(), Elements: Tys, isPacked: false);
1098 }
1099
1100 for (auto *V : NewMembers) {
1101 Constant *NewV;
1102 if (IsOldCtorDtor) {
1103 auto *S = cast<ConstantStruct>(Val: V);
1104 auto *E1 = cast<Constant>(Val: mapValue(V: S->getOperand(i_nocapture: 0)));
1105 auto *E2 = cast<Constant>(Val: mapValue(V: S->getOperand(i_nocapture: 1)));
1106 Constant *Null = Constant::getNullValue(Ty: VoidPtrTy);
1107 NewV = ConstantStruct::get(T: cast<StructType>(Val: EltTy), Vs: E1, Vs: E2, Vs: Null);
1108 } else {
1109 NewV = cast_or_null<Constant>(Val: mapValue(V));
1110 }
1111 Elements.push_back(Elt: NewV);
1112 }
1113
1114 GV.setInitializer(
1115 ConstantArray::get(T: cast<ArrayType>(Val: GV.getValueType()), V: Elements));
1116}
1117
1118void Mapper::scheduleMapGlobalInitializer(GlobalVariable &GV, Constant &Init,
1119 unsigned MCID) {
1120 assert(AlreadyScheduled.insert(&GV).second && "Should not reschedule");
1121 assert(MCID < MCs.size() && "Invalid mapping context");
1122
1123 WorklistEntry WE;
1124 WE.Kind = WorklistEntry::MapGlobalInit;
1125 WE.MCID = MCID;
1126 WE.Data.GVInit.GV = &GV;
1127 WE.Data.GVInit.Init = &Init;
1128 Worklist.push_back(Elt: WE);
1129}
1130
1131void Mapper::scheduleMapAppendingVariable(GlobalVariable &GV,
1132 Constant *InitPrefix,
1133 bool IsOldCtorDtor,
1134 ArrayRef<Constant *> NewMembers,
1135 unsigned MCID) {
1136 assert(AlreadyScheduled.insert(&GV).second && "Should not reschedule");
1137 assert(MCID < MCs.size() && "Invalid mapping context");
1138
1139 WorklistEntry WE;
1140 WE.Kind = WorklistEntry::MapAppendingVar;
1141 WE.MCID = MCID;
1142 WE.Data.AppendingGV.GV = &GV;
1143 WE.Data.AppendingGV.InitPrefix = InitPrefix;
1144 WE.AppendingGVIsOldCtorDtor = IsOldCtorDtor;
1145 WE.AppendingGVNumNewMembers = NewMembers.size();
1146 Worklist.push_back(Elt: WE);
1147 AppendingInits.append(in_start: NewMembers.begin(), in_end: NewMembers.end());
1148}
1149
1150void Mapper::scheduleMapAliasOrIFunc(GlobalValue &GV, Constant &Target,
1151 unsigned MCID) {
1152 assert(AlreadyScheduled.insert(&GV).second && "Should not reschedule");
1153 assert((isa<GlobalAlias>(GV) || isa<GlobalIFunc>(GV)) &&
1154 "Should be alias or ifunc");
1155 assert(MCID < MCs.size() && "Invalid mapping context");
1156
1157 WorklistEntry WE;
1158 WE.Kind = WorklistEntry::MapAliasOrIFunc;
1159 WE.MCID = MCID;
1160 WE.Data.AliasOrIFunc.GV = &GV;
1161 WE.Data.AliasOrIFunc.Target = &Target;
1162 Worklist.push_back(Elt: WE);
1163}
1164
1165void Mapper::scheduleRemapFunction(Function &F, unsigned MCID) {
1166 assert(AlreadyScheduled.insert(&F).second && "Should not reschedule");
1167 assert(MCID < MCs.size() && "Invalid mapping context");
1168
1169 WorklistEntry WE;
1170 WE.Kind = WorklistEntry::RemapFunction;
1171 WE.MCID = MCID;
1172 WE.Data.RemapF = &F;
1173 Worklist.push_back(Elt: WE);
1174}
1175
1176void Mapper::addFlags(RemapFlags Flags) {
1177 assert(!hasWorkToDo() && "Expected to have flushed the worklist");
1178 this->Flags = this->Flags | Flags;
1179}
1180
1181static Mapper *getAsMapper(void *pImpl) {
1182 return reinterpret_cast<Mapper *>(pImpl);
1183}
1184
1185namespace {
1186
1187class FlushingMapper {
1188 Mapper &M;
1189
1190public:
1191 explicit FlushingMapper(void *pImpl) : M(*getAsMapper(pImpl)) {
1192 assert(!M.hasWorkToDo() && "Expected to be flushed");
1193 }
1194
1195 ~FlushingMapper() { M.flush(); }
1196
1197 Mapper *operator->() const { return &M; }
1198};
1199
1200} // end anonymous namespace
1201
1202ValueMapper::ValueMapper(ValueToValueMapTy &VM, RemapFlags Flags,
1203 ValueMapTypeRemapper *TypeMapper,
1204 ValueMaterializer *Materializer)
1205 : pImpl(new Mapper(VM, Flags, TypeMapper, Materializer)) {}
1206
1207ValueMapper::~ValueMapper() { delete getAsMapper(pImpl); }
1208
1209unsigned
1210ValueMapper::registerAlternateMappingContext(ValueToValueMapTy &VM,
1211 ValueMaterializer *Materializer) {
1212 return getAsMapper(pImpl)->registerAlternateMappingContext(VM, Materializer);
1213}
1214
1215void ValueMapper::addFlags(RemapFlags Flags) {
1216 FlushingMapper(pImpl)->addFlags(Flags);
1217}
1218
1219Value *ValueMapper::mapValue(const Value &V) {
1220 return FlushingMapper(pImpl)->mapValue(V: &V);
1221}
1222
1223Constant *ValueMapper::mapConstant(const Constant &C) {
1224 return cast_or_null<Constant>(Val: mapValue(V: C));
1225}
1226
1227Metadata *ValueMapper::mapMetadata(const Metadata &MD) {
1228 return FlushingMapper(pImpl)->mapMetadata(MD: &MD);
1229}
1230
1231MDNode *ValueMapper::mapMDNode(const MDNode &N) {
1232 return cast_or_null<MDNode>(Val: mapMetadata(MD: N));
1233}
1234
1235void ValueMapper::remapInstruction(Instruction &I) {
1236 FlushingMapper(pImpl)->remapInstruction(I: &I);
1237}
1238
1239void ValueMapper::remapDbgRecord(Module *M, DbgRecord &DR) {
1240 FlushingMapper(pImpl)->remapDbgRecord(DR);
1241}
1242
1243void ValueMapper::remapDbgRecordRange(
1244 Module *M, iterator_range<DbgRecord::self_iterator> Range) {
1245 for (DbgRecord &DR : Range) {
1246 remapDbgRecord(M, DR);
1247 }
1248}
1249
1250void ValueMapper::remapFunction(Function &F) {
1251 FlushingMapper(pImpl)->remapFunction(F);
1252}
1253
1254void ValueMapper::remapGlobalObjectMetadata(GlobalObject &GO) {
1255 FlushingMapper(pImpl)->remapGlobalObjectMetadata(GO);
1256}
1257
1258void ValueMapper::scheduleMapGlobalInitializer(GlobalVariable &GV,
1259 Constant &Init,
1260 unsigned MCID) {
1261 getAsMapper(pImpl)->scheduleMapGlobalInitializer(GV, Init, MCID);
1262}
1263
1264void ValueMapper::scheduleMapAppendingVariable(GlobalVariable &GV,
1265 Constant *InitPrefix,
1266 bool IsOldCtorDtor,
1267 ArrayRef<Constant *> NewMembers,
1268 unsigned MCID) {
1269 getAsMapper(pImpl)->scheduleMapAppendingVariable(
1270 GV, InitPrefix, IsOldCtorDtor, NewMembers, MCID);
1271}
1272
1273void ValueMapper::scheduleMapGlobalAlias(GlobalAlias &GA, Constant &Aliasee,
1274 unsigned MCID) {
1275 getAsMapper(pImpl)->scheduleMapAliasOrIFunc(GV&: GA, Target&: Aliasee, MCID);
1276}
1277
1278void ValueMapper::scheduleMapGlobalIFunc(GlobalIFunc &GI, Constant &Resolver,
1279 unsigned MCID) {
1280 getAsMapper(pImpl)->scheduleMapAliasOrIFunc(GV&: GI, Target&: Resolver, MCID);
1281}
1282
1283void ValueMapper::scheduleRemapFunction(Function &F, unsigned MCID) {
1284 getAsMapper(pImpl)->scheduleRemapFunction(F, MCID);
1285}
1286