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