lib/Transforms/Utils/ValueMapper.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-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/None.h"
  19 #include "llvm/ADT/Optional.h"
  20 #include "llvm/ADT/STLExtras.h"
  21 #include "llvm/ADT/SmallVector.h"
  22 #include "llvm/IR/Argument.h"
  23 #include "llvm/IR/BasicBlock.h"
  24 #include "llvm/IR/CallSite.h"
  25 #include "llvm/IR/Constant.h"
  26 #include "llvm/IR/Constants.h"
  27 #include "llvm/IR/DebugInfoMetadata.h"
  28 #include "llvm/IR/DerivedTypes.h"
  29 #include "llvm/IR/Function.h"
  30 #include "llvm/IR/GlobalObject.h"
  31 #include "llvm/IR/GlobalIndirectSymbol.h"
  32 #include "llvm/IR/GlobalVariable.h"
  33 #include "llvm/IR/InlineAsm.h"
  34 #include "llvm/IR/Instruction.h"
  35 #include "llvm/IR/Instructions.h"
  36 #include "llvm/IR/Metadata.h"
  37 #include "llvm/IR/Operator.h"
  38 #include "llvm/IR/Type.h"
  39 #include "llvm/IR/Value.h"
  40 #include "llvm/Support/Casting.h"
  41 #include <cassert>
  42 #include <limits>
  43 #include <memory>
  44 #include <utility>
  45
  46 using namespace llvm;
  47
  48 // Out of line method to get vtable etc for class.
  49 void ValueMapTypeRemapper::anchor() {}
  50 void ValueMaterializer::anchor() {}
  51
  52 namespace {
  53
  54 /// A basic block used in a BlockAddress whose function body is not yet
  55 /// materialized.
  56 struct DelayedBasicBlock {
  57   BasicBlock *OldBB;
  58   std::unique_ptr<BasicBlock> TempBB;
  59
  60   DelayedBasicBlock(const BlockAddress &Old)
  61       : OldBB(Old.getBasicBlock()),
  62         TempBB(BasicBlock::Create(Old.getContext())) {}
  63 };
  64
  65 struct WorklistEntry {
  66   enum EntryKind {
  67     MapGlobalInit,
  68     MapAppendingVar,
  69     MapGlobalIndirectSymbol,
  70     RemapFunction
  71   };
  72   struct GVInitTy {
  73     GlobalVariable *GV;
  74     Constant *Init;
  75   };
  76   struct AppendingGVTy {
  77     GlobalVariable *GV;
  78     Constant *InitPrefix;
  79   };
  80   struct GlobalIndirectSymbolTy {
  81     GlobalIndirectSymbol *GIS;
  82     Constant *Target;
  83   };
  84
  85   unsigned Kind : 2;
  86   unsigned MCID : 29;
  87   unsigned AppendingGVIsOldCtorDtor : 1;
  88   unsigned AppendingGVNumNewMembers;
  89   union {
  90     GVInitTy GVInit;
  91     AppendingGVTy AppendingGV;
  92     GlobalIndirectSymbolTy GlobalIndirectSymbol;
  93     Function *RemapF;
  94   } Data;
  95 };
  96
  97 struct MappingContext {
  98   ValueToValueMapTy *VM;
  99   ValueMaterializer *Materializer = nullptr;
 100
 101   /// Construct a MappingContext with a value map and materializer.
 102   explicit MappingContext(ValueToValueMapTy &VM,
 103                           ValueMaterializer *Materializer = nullptr)
 104       : VM(&VM), Materializer(Materializer) {}
 105 };
 106
 107 class Mapper {
 108   friend class MDNodeMapper;
 109
 110 #ifndef NDEBUG
 111   DenseSet<GlobalValue *> AlreadyScheduled;
 112 #endif
 113
 114   RemapFlags Flags;
 115   ValueMapTypeRemapper *TypeMapper;
 116   unsigned CurrentMCID = 0;
 117   SmallVector<MappingContext, 2> MCs;
 118   SmallVector<WorklistEntry, 4> Worklist;
 119   SmallVector<DelayedBasicBlock, 1> DelayedBBs;
 120   SmallVector<Constant *, 16> AppendingInits;
 121
 122 public:
 123   Mapper(ValueToValueMapTy &VM, RemapFlags Flags,
 124          ValueMapTypeRemapper *TypeMapper, ValueMaterializer *Materializer)
 125       : Flags(Flags), TypeMapper(TypeMapper),
 126         MCs(1, MappingContext(VM, Materializer)) {}
 127
 128   /// ValueMapper should explicitly call \a flush() before destruction.
 129   ~Mapper() { assert(!hasWorkToDo() && "Expected to be flushed"); }
 130
 131   bool hasWorkToDo() const { return !Worklist.empty(); }
 132
 133   unsigned
 134   registerAlternateMappingContext(ValueToValueMapTy &VM,
 135                                   ValueMaterializer *Materializer = nullptr) {
 136     MCs.push_back(MappingContext(VM, Materializer));
 137     return MCs.size() - 1;
 138   }
 139
 140   void addFlags(RemapFlags Flags);
 141
 142   void remapGlobalObjectMetadata(GlobalObject &GO);
 143
 144   Value *mapValue(const Value *V);
 145   void remapInstruction(Instruction *I);
 146   void remapFunction(Function &F);
 147
 148   Constant *mapConstant(const Constant *C) {
 149     return cast_or_null<Constant>(mapValue(C));
 150   }
 151
 152   /// Map metadata.
 153   ///
 154   /// Find the mapping for MD.  Guarantees that the return will be resolved
 155   /// (not an MDNode, or MDNode::isResolved() returns true).
 156   Metadata *mapMetadata(const Metadata *MD);
 157
 158   void scheduleMapGlobalInitializer(GlobalVariable &GV, Constant &Init,
 159                                     unsigned MCID);
 160   void scheduleMapAppendingVariable(GlobalVariable &GV, Constant *InitPrefix,
 161                                     bool IsOldCtorDtor,
 162                                     ArrayRef<Constant *> NewMembers,
 163                                     unsigned MCID);
 164   void scheduleMapGlobalIndirectSymbol(GlobalIndirectSymbol &GIS, Constant &Target,
 165                                        unsigned MCID);
 166   void scheduleRemapFunction(Function &F, unsigned MCID);
 167
 168   void flush();
 169
 170 private:
 171   void mapGlobalInitializer(GlobalVariable &GV, Constant &Init);
 172   void mapAppendingVariable(GlobalVariable &GV, Constant *InitPrefix,
 173                             bool IsOldCtorDtor,
 174                             ArrayRef<Constant *> NewMembers);
 175   void mapGlobalIndirectSymbol(GlobalIndirectSymbol &GIS, Constant &Target);
 176   void remapFunction(Function &F, ValueToValueMapTy &VM);
 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   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 None if \c Op is an unmapped uniqued \a MDNode.
 274   /// \post getMappedOp(Op) only returns None if this returns None.
 275   Optional<Metadata *> tryToMapOperand(const Metadata *Op);
 276
 277   /// Map a distinct node.
 278   ///
 279   /// Return the mapping for the distinct node \c N, saving the result in \a
 280   /// DistinctWorklist for later remapping.
 281   ///
 282   /// \pre \c N is not yet mapped.
 283   /// \pre \c N.isDistinct().
 284   MDNode *mapDistinctNode(const MDNode &N);
 285
 286   /// Get a previously mapped node.
 287   Optional<Metadata *> getMappedOp(const Metadata *Op) const;
 288
 289   /// Create a post-order traversal of an unmapped uniqued node subgraph.
 290   ///
 291   /// This traverses the metadata graph deeply enough to map \c FirstN.  It
 292   /// uses \a tryToMapOperand() (via \a Mapper::mapSimplifiedNode()), so any
 293   /// metadata that has already been mapped will not be part of the POT.
 294   ///
 295   /// Each node that has a changed operand from outside the graph (e.g., a
 296   /// distinct node, an already-mapped uniqued node, or \a ConstantAsMetadata)
 297   /// is marked with \a Data::HasChanged.
 298   ///
 299   /// \return \c true if any nodes in \c G have \a Data::HasChanged.
 300   /// \post \c G.POT is a post-order traversal ending with \c FirstN.
 301   /// \post \a Data::hasChanged in \c G.Info indicates whether any node needs
 302   /// to change because of operands outside the graph.
 303   bool createPOT(UniquedGraph &G, const MDNode &FirstN);
 304
 305   /// Visit the operands of a uniqued node in the POT.
 306   ///
 307   /// Visit the operands in the range from \c I to \c E, returning the first
 308   /// uniqued node we find that isn't yet in \c G.  \c I is always advanced to
 309   /// where to continue the loop through the operands.
 310   ///
 311   /// This sets \c HasChanged if any of the visited operands change.
 312   MDNode *visitOperands(UniquedGraph &G, MDNode::op_iterator &I,
 313                         MDNode::op_iterator E, bool &HasChanged);
 314
 315   /// Map all the nodes in the given uniqued graph.
 316   ///
 317   /// This visits all the nodes in \c G in post-order, using the identity
 318   /// mapping or creating a new node depending on \a Data::HasChanged.
 319   ///
 320   /// \pre \a getMappedOp() returns None for nodes in \c G, but not for any of
 321   /// their operands outside of \c G.
 322   /// \pre \a Data::HasChanged is true for a node in \c G iff any of its
 323   /// operands have changed.
 324   /// \post \a 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     }
 374
 375     return getVM()[V] = const_cast<Value *>(V);
 376   }
 377
 378   if (const auto *MDV = dyn_cast<MetadataAsValue>(V)) {
 379     const Metadata *MD = MDV->getMetadata();
 380
 381     if (auto *LAM = dyn_cast<LocalAsMetadata>(MD)) {
 382       // Look through to grab the local value.
 383       if (Value *LV = mapValue(LAM->getValue())) {
 384         if (V == LAM->getValue())
 385           return const_cast<Value *>(V);
 386         return MetadataAsValue::get(V->getContext(), ValueAsMetadata::get(LV));
 387       }
 388
 389       // FIXME: always return nullptr once Verifier::verifyDominatesUse()
 390       // ensures metadata operands only reference defined SSA values.
 391       return (Flags & RF_IgnoreMissingLocals)
 392                  ? nullptr
 393                  : MetadataAsValue::get(V->getContext(),
 394                                         MDTuple::get(V->getContext(), None));
 395     }
 396
 397     // If this is a module-level metadata and we know that nothing at the module
 398     // level is changing, then use an identity mapping.
 399     if (Flags & RF_NoModuleLevelChanges)
 400       return getVM()[V] = const_cast<Value *>(V);
 401
 402     // Map the metadata and turn it into a value.
 403     auto *MappedMD = mapMetadata(MD);
 404     if (MD == MappedMD)
 405       return getVM()[V] = const_cast<Value *>(V);
 406     return getVM()[V] = MetadataAsValue::get(V->getContext(), MappedMD);
 407   }
 408
 409   // Okay, this either must be a constant (which may or may not be mappable) or
 410   // is something that is not in the mapping table.
 411   Constant *C = const_cast<Constant*>(dyn_cast<Constant>(V));
 412   if (!C)
 413     return nullptr;
 414
 415   if (BlockAddress *BA = dyn_cast<BlockAddress>(C))
 416     return mapBlockAddress(*BA);
 417
 418   auto mapValueOrNull = [this](Value *V) {
 419     auto Mapped = mapValue(V);
 420     assert((Mapped || (Flags & RF_NullMapMissingGlobalValues)) &&
 421            "Unexpected null mapping for constant operand without "
 422            "NullMapMissingGlobalValues flag");
 423     return Mapped;
 424   };
 425
 426   // Otherwise, we have some other constant to remap.  Start by checking to see
 427   // if all operands have an identity remapping.
 428   unsigned OpNo = 0, NumOperands = C->getNumOperands();
 429   Value *Mapped = nullptr;
 430   for (; OpNo != NumOperands; ++OpNo) {
 431     Value *Op = C->getOperand(OpNo);
 432     Mapped = mapValueOrNull(Op);
 433     if (!Mapped)
 434       return nullptr;
 435     if (Mapped != Op)
 436       break;
 437   }
 438
 439   // See if the type mapper wants to remap the type as well.
 440   Type *NewTy = C->getType();
 441   if (TypeMapper)
 442     NewTy = TypeMapper->remapType(NewTy);
 443
 444   // If the result type and all operands match up, then just insert an identity
 445   // mapping.
 446   if (OpNo == NumOperands && NewTy == C->getType())
 447     return getVM()[V] = C;
 448
 449   // Okay, we need to create a new constant.  We've already processed some or
 450   // all of the operands, set them all up now.
 451   SmallVector<Constant*, 8> Ops;
 452   Ops.reserve(NumOperands);
 453   for (unsigned j = 0; j != OpNo; ++j)
 454     Ops.push_back(cast<Constant>(C->getOperand(j)));
 455
 456   // If one of the operands mismatch, push it and the other mapped operands.
 457   if (OpNo != NumOperands) {
 458     Ops.push_back(cast<Constant>(Mapped));
 459
 460     // Map the rest of the operands that aren't processed yet.
 461     for (++OpNo; OpNo != NumOperands; ++OpNo) {
 462       Mapped = mapValueOrNull(C->getOperand(OpNo));
 463       if (!Mapped)
 464         return nullptr;
 465       Ops.push_back(cast<Constant>(Mapped));
 466     }
 467   }
 468   Type *NewSrcTy = nullptr;
 469   if (TypeMapper)
 470     if (auto *GEPO = dyn_cast<GEPOperator>(C))
 471       NewSrcTy = TypeMapper->remapType(GEPO->getSourceElementType());
 472
 473   if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C))
 474     return getVM()[V] = CE->getWithOperands(Ops, NewTy, false, NewSrcTy);
 475   if (isa<ConstantArray>(C))
 476     return getVM()[V] = ConstantArray::get(cast<ArrayType>(NewTy), Ops);
 477   if (isa<ConstantStruct>(C))
 478     return getVM()[V] = ConstantStruct::get(cast<StructType>(NewTy), Ops);
 479   if (isa<ConstantVector>(C))
 480     return getVM()[V] = ConstantVector::get(Ops);
 481   // If this is a no-operand constant, it must be because the type was remapped.
 482   if (isa<UndefValue>(C))
 483     return getVM()[V] = UndefValue::get(NewTy);
 484   if (isa<ConstantAggregateZero>(C))
 485     return getVM()[V] = ConstantAggregateZero::get(NewTy);
 486   assert(isa<ConstantPointerNull>(C));
 487   return getVM()[V] = ConstantPointerNull::get(cast<PointerType>(NewTy));
 488 }
 489
 490 Value *Mapper::mapBlockAddress(const BlockAddress &BA) {
 491   Function *F = cast<Function>(mapValue(BA.getFunction()));
 492
 493   // F may not have materialized its initializer.  In that case, create a
 494   // dummy basic block for now, and replace it once we've materialized all
 495   // the initializers.
 496   BasicBlock *BB;
 497   if (F->empty()) {
 498     DelayedBBs.push_back(DelayedBasicBlock(BA));
 499     BB = DelayedBBs.back().TempBB.get();
 500   } else {
 501     BB = cast_or_null<BasicBlock>(mapValue(BA.getBasicBlock()));
 502   }
 503
 504   return getVM()[&BA] = BlockAddress::get(F, BB ? BB : BA.getBasicBlock());
 505 }
 506
 507 Metadata *Mapper::mapToMetadata(const Metadata *Key, Metadata *Val) {
 508   getVM().MD()[Key].reset(Val);
 509   return Val;
 510 }
 511
 512 Metadata *Mapper::mapToSelf(const Metadata *MD) {
 513   return mapToMetadata(MD, const_cast<Metadata *>(MD));
 514 }
 515
 516 Optional<Metadata *> MDNodeMapper::tryToMapOperand(const Metadata *Op) {
 517   if (!Op)
 518     return nullptr;
 519
 520   if (Optional<Metadata *> MappedOp = M.mapSimpleMetadata(Op)) {
 521 #ifndef NDEBUG
 522     if (auto *CMD = dyn_cast<ConstantAsMetadata>(Op))
 523       assert((!*MappedOp || M.getVM().count(CMD->getValue()) ||
 524               M.getVM().getMappedMD(Op)) &&
 525              "Expected Value to be memoized");
 526     else
 527       assert((isa<MDString>(Op) || M.getVM().getMappedMD(Op)) &&
 528              "Expected result to be memoized");
 529 #endif
 530     return *MappedOp;
 531   }
 532
 533   const MDNode &N = *cast<MDNode>(Op);
 534   if (N.isDistinct())
 535     return mapDistinctNode(N);
 536   return None;
 537 }
 538
 539 static Metadata *cloneOrBuildODR(const MDNode &N) {
 540   auto *CT = dyn_cast<DICompositeType>(&N);
 541   // If ODR type uniquing is enabled, we would have uniqued composite types
 542   // with identifiers during bitcode reading, so we can just use CT.
 543   if (CT && CT->getContext().isODRUniquingDebugTypes() &&
 544       CT->getIdentifier() != "")
 545     return const_cast<DICompositeType *>(CT);
 546   return MDNode::replaceWithDistinct(N.clone());
 547 }
 548
 549 MDNode *MDNodeMapper::mapDistinctNode(const MDNode &N) {
 550   assert(N.isDistinct() && "Expected a distinct node");
 551   assert(!M.getVM().getMappedMD(&N) && "Expected an unmapped node");
 552   DistinctWorklist.push_back(
 553       cast<MDNode>((M.Flags & RF_MoveDistinctMDs)
 554                        ? M.mapToSelf(&N)
 555                        : M.mapToMetadata(&N, cloneOrBuildODR(N))));
 556   return DistinctWorklist.back();
 557 }
 558
 559 static ConstantAsMetadata *wrapConstantAsMetadata(const ConstantAsMetadata &CMD,
 560                                                   Value *MappedV) {
 561   if (CMD.getValue() == MappedV)
 562     return const_cast<ConstantAsMetadata *>(&CMD);
 563   return MappedV ? ConstantAsMetadata::getConstant(MappedV) : nullptr;
 564 }
 565
 566 Optional<Metadata *> MDNodeMapper::getMappedOp(const Metadata *Op) const {
 567   if (!Op)
 568     return nullptr;
 569
 570   if (Optional<Metadata *> MappedOp = M.getVM().getMappedMD(Op))
 571     return *MappedOp;
 572
 573   if (isa<MDString>(Op))
 574     return const_cast<Metadata *>(Op);
 575
 576   if (auto *CMD = dyn_cast<ConstantAsMetadata>(Op))
 577     return wrapConstantAsMetadata(*CMD, M.getVM().lookup(CMD->getValue()));
 578
 579   return None;
 580 }
 581
 582 Metadata &MDNodeMapper::UniquedGraph::getFwdReference(MDNode &Op) {
 583   auto Where = Info.find(&Op);
 584   assert(Where != Info.end() && "Expected a valid reference");
 585
 586   auto &OpD = Where->second;
 587   if (!OpD.HasChanged)
 588     return Op;
 589
 590   // Lazily construct a temporary node.
 591   if (!OpD.Placeholder)
 592     OpD.Placeholder = Op.clone();
 593
 594   return *OpD.Placeholder;
 595 }
 596
 597 template <class OperandMapper>
 598 void MDNodeMapper::remapOperands(MDNode &N, OperandMapper mapOperand) {
 599   assert(!N.isUniqued() && "Expected distinct or temporary nodes");
 600   for (unsigned I = 0, E = N.getNumOperands(); I != E; ++I) {
 601     Metadata *Old = N.getOperand(I);
 602     Metadata *New = mapOperand(Old);
 603
 604     if (Old != New)
 605       N.replaceOperandWith(I, New);
 606   }
 607 }
 608
 609 namespace {
 610
 611 /// An entry in the worklist for the post-order traversal.
 612 struct POTWorklistEntry {
 613   MDNode *N;              ///< Current node.
 614   MDNode::op_iterator Op; ///< Current operand of \c N.
 615
 616   /// Keep a flag of whether operands have changed in the worklist to avoid
 617   /// hitting the map in \a UniquedGraph.
 618   bool HasChanged = false;
 619
 620   POTWorklistEntry(MDNode &N) : N(&N), Op(N.op_begin()) {}
 621 };
 622
 623 } // end anonymous namespace
 624
 625 bool MDNodeMapper::createPOT(UniquedGraph &G, const MDNode &FirstN) {
 626   assert(G.Info.empty() && "Expected a fresh traversal");
 627   assert(FirstN.isUniqued() && "Expected uniqued node in POT");
 628
 629   // Construct a post-order traversal of the uniqued subgraph under FirstN.
 630   bool AnyChanges = false;
 631   SmallVector<POTWorklistEntry, 16> Worklist;
 632   Worklist.push_back(POTWorklistEntry(const_cast<MDNode &>(FirstN)));
 633   (void)G.Info[&FirstN];
 634   while (!Worklist.empty()) {
 635     // Start or continue the traversal through the this node's operands.
 636     auto &WE = Worklist.back();
 637     if (MDNode *N = visitOperands(G, WE.Op, WE.N->op_end(), WE.HasChanged)) {
 638       // Push a new node to traverse first.
 639       Worklist.push_back(POTWorklistEntry(*N));
 640       continue;
 641     }
 642
 643     // Push the node onto the POT.
 644     assert(WE.N->isUniqued() && "Expected only uniqued nodes");
 645     assert(WE.Op == WE.N->op_end() && "Expected to visit all operands");
 646     auto &D = G.Info[WE.N];
 647     AnyChanges |= D.HasChanged = WE.HasChanged;
 648     D.ID = G.POT.size();
 649     G.POT.push_back(WE.N);
 650
 651     // Pop the node off the worklist.
 652     Worklist.pop_back();
 653   }
 654   return AnyChanges;
 655 }
 656
 657 MDNode *MDNodeMapper::visitOperands(UniquedGraph &G, MDNode::op_iterator &I,
 658                                     MDNode::op_iterator E, bool &HasChanged) {
 659   while (I != E) {
 660     Metadata *Op = *I++; // Increment even on early return.
 661     if (Optional<Metadata *> MappedOp = tryToMapOperand(Op)) {
 662       // Check if the operand changes.
 663       HasChanged |= Op != *MappedOp;
 664       continue;
 665     }
 666
 667     // A uniqued metadata node.
 668     MDNode &OpN = *cast<MDNode>(Op);
 669     assert(OpN.isUniqued() &&
 670            "Only uniqued operands cannot be mapped immediately");
 671     if (G.Info.insert(std::make_pair(&OpN, Data())).second)
 672       return &OpN; // This is a new one.  Return it.
 673   }
 674   return nullptr;
 675 }
 676
 677 void MDNodeMapper::UniquedGraph::propagateChanges() {
 678   bool AnyChanges;
 679   do {
 680     AnyChanges = false;
 681     for (MDNode *N : POT) {
 682       auto &D = Info[N];
 683       if (D.HasChanged)
 684         continue;
 685
 686       if (llvm::none_of(N->operands(), [&](const Metadata *Op) {
 687             auto Where = Info.find(Op);
 688             return Where != Info.end() && Where->second.HasChanged;
 689           }))
 690         continue;
 691
 692       AnyChanges = D.HasChanged = true;
 693     }
 694   } while (AnyChanges);
 695 }
 696
 697 void MDNodeMapper::mapNodesInPOT(UniquedGraph &G) {
 698   // Construct uniqued nodes, building forward references as necessary.
 699   SmallVector<MDNode *, 16> CyclicNodes;
 700   for (auto *N : G.POT) {
 701     auto &D = G.Info[N];
 702     if (!D.HasChanged) {
 703       // The node hasn't changed.
 704       M.mapToSelf(N);
 705       continue;
 706     }
 707
 708     // Remember whether this node had a placeholder.
 709     bool HadPlaceholder(D.Placeholder);
 710
 711     // Clone the uniqued node and remap the operands.
 712     TempMDNode ClonedN = D.Placeholder ? std::move(D.Placeholder) : N->clone();
 713     remapOperands(*ClonedN, [this, &D, &G](Metadata *Old) {
 714       if (Optional<Metadata *> MappedOp = getMappedOp(Old))
 715         return *MappedOp;
 716       (void)D;
 717       assert(G.Info[Old].ID > D.ID && "Expected a forward reference");
 718       return &G.getFwdReference(*cast<MDNode>(Old));
 719     });
 720
 721     auto *NewN = MDNode::replaceWithUniqued(std::move(ClonedN));
 722     M.mapToMetadata(N, NewN);
 723
 724     // Nodes that were referenced out of order in the POT are involved in a
 725     // uniquing cycle.
 726     if (HadPlaceholder)
 727       CyclicNodes.push_back(NewN);
 728   }
 729
 730   // Resolve cycles.
 731   for (auto *N : CyclicNodes)
 732     if (!N->isResolved())
 733       N->resolveCycles();
 734 }
 735
 736 Metadata *MDNodeMapper::map(const MDNode &N) {
 737   assert(DistinctWorklist.empty() && "MDNodeMapper::map is not recursive");
 738   assert(!(M.Flags & RF_NoModuleLevelChanges) &&
 739          "MDNodeMapper::map assumes module-level changes");
 740
 741   // Require resolved nodes whenever metadata might be remapped.
 742   assert(N.isResolved() && "Unexpected unresolved node");
 743
 744   Metadata *MappedN =
 745       N.isUniqued() ? mapTopLevelUniquedNode(N) : mapDistinctNode(N);
 746   while (!DistinctWorklist.empty())
 747     remapOperands(*DistinctWorklist.pop_back_val(), [this](Metadata *Old) {
 748       if (Optional<Metadata *> MappedOp = tryToMapOperand(Old))
 749         return *MappedOp;
 750       return mapTopLevelUniquedNode(*cast<MDNode>(Old));
 751     });
 752   return MappedN;
 753 }
 754
 755 Metadata *MDNodeMapper::mapTopLevelUniquedNode(const MDNode &FirstN) {
 756   assert(FirstN.isUniqued() && "Expected uniqued node");
 757
 758   // Create a post-order traversal of uniqued nodes under FirstN.
 759   UniquedGraph G;
 760   if (!createPOT(G, FirstN)) {
 761     // Return early if no nodes have changed.
 762     for (const MDNode *N : G.POT)
 763       M.mapToSelf(N);
 764     return &const_cast<MDNode &>(FirstN);
 765   }
 766
 767   // Update graph with all nodes that have changed.
 768   G.propagateChanges();
 769
 770   // Map all the nodes in the graph.
 771   mapNodesInPOT(G);
 772
 773   // Return the original node, remapped.
 774   return *getMappedOp(&FirstN);
 775 }
 776
 777 Optional<Metadata *> Mapper::mapSimpleMetadata(const Metadata *MD) {
 778   // If the value already exists in the map, use it.
 779   if (Optional<Metadata *> NewMD = getVM().getMappedMD(MD))
 780     return *NewMD;
 781
 782   if (isa<MDString>(MD))
 783     return const_cast<Metadata *>(MD);
 784
 785   // This is a module-level metadata.  If nothing at the module level is
 786   // changing, use an identity mapping.
 787   if ((Flags & RF_NoModuleLevelChanges))
 788     return const_cast<Metadata *>(MD);
 789
 790   if (auto *CMD = dyn_cast<ConstantAsMetadata>(MD)) {
 791     // Don't memoize ConstantAsMetadata.  Instead of lasting until the
 792     // LLVMContext is destroyed, they can be deleted when the GlobalValue they
 793     // reference is destructed.  These aren't super common, so the extra
 794     // indirection isn't that expensive.
 795     return wrapConstantAsMetadata(*CMD, mapValue(CMD->getValue()));
 796   }
 797
 798   assert(isa<MDNode>(MD) && "Expected a metadata node");
 799
 800   return None;
 801 }
 802
 803 Metadata *Mapper::mapMetadata(const Metadata *MD) {
 804   assert(MD && "Expected valid metadata");
 805   assert(!isa<LocalAsMetadata>(MD) && "Unexpected local metadata");
 806
 807   if (Optional<Metadata *> NewMD = mapSimpleMetadata(MD))
 808     return *NewMD;
 809
 810   return MDNodeMapper(*this).map(*cast<MDNode>(MD));
 811 }
 812
 813 void Mapper::flush() {
 814   // Flush out the worklist of global values.
 815   while (!Worklist.empty()) {
 816     WorklistEntry E = Worklist.pop_back_val();
 817     CurrentMCID = E.MCID;
 818     switch (E.Kind) {
 819     case WorklistEntry::MapGlobalInit:
 820       E.Data.GVInit.GV->setInitializer(mapConstant(E.Data.GVInit.Init));
 821       remapGlobalObjectMetadata(*E.Data.GVInit.GV);
 822       break;
 823     case WorklistEntry::MapAppendingVar: {
 824       unsigned PrefixSize = AppendingInits.size() - E.AppendingGVNumNewMembers;
 825       mapAppendingVariable(*E.Data.AppendingGV.GV,
 826                            E.Data.AppendingGV.InitPrefix,
 827                            E.AppendingGVIsOldCtorDtor,
 828                            makeArrayRef(AppendingInits).slice(PrefixSize));
 829       AppendingInits.resize(PrefixSize);
 830       break;
 831     }
 832     case WorklistEntry::MapGlobalIndirectSymbol:
 833       E.Data.GlobalIndirectSymbol.GIS->setIndirectSymbol(
 834           mapConstant(E.Data.GlobalIndirectSymbol.Target));
 835       break;
 836     case WorklistEntry::RemapFunction:
 837       remapFunction(*E.Data.RemapF);
 838       break;
 839     }
 840   }
 841   CurrentMCID = 0;
 842
 843   // Finish logic for block addresses now that all global values have been
 844   // handled.
 845   while (!DelayedBBs.empty()) {
 846     DelayedBasicBlock DBB = DelayedBBs.pop_back_val();
 847     BasicBlock *BB = cast_or_null<BasicBlock>(mapValue(DBB.OldBB));
 848     DBB.TempBB->replaceAllUsesWith(BB ? BB : DBB.OldBB);
 849   }
 850 }
 851
 852 void Mapper::remapInstruction(Instruction *I) {
 853   // Remap operands.
 854   for (Use &Op : I->operands()) {
 855     Value *V = mapValue(Op);
 856     // If we aren't ignoring missing entries, assert that something happened.
 857     if (V)
 858       Op = V;
 859     else
 860       assert((Flags & RF_IgnoreMissingLocals) &&
 861              "Referenced value not in value map!");
 862   }
 863
 864   // Remap phi nodes' incoming blocks.
 865   if (PHINode *PN = dyn_cast<PHINode>(I)) {
 866     for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
 867       Value *V = mapValue(PN->getIncomingBlock(i));
 868       // If we aren't ignoring missing entries, assert that something happened.
 869       if (V)
 870         PN->setIncomingBlock(i, cast<BasicBlock>(V));
 871       else
 872         assert((Flags & RF_IgnoreMissingLocals) &&
 873                "Referenced block not in value map!");
 874     }
 875   }
 876
 877   // Remap attached metadata.
 878   SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
 879   I->getAllMetadata(MDs);
 880   for (const auto &MI : MDs) {
 881     MDNode *Old = MI.second;
 882     MDNode *New = cast_or_null<MDNode>(mapMetadata(Old));
 883     if (New != Old)
 884       I->setMetadata(MI.first, New);
 885   }
 886
 887   if (!TypeMapper)
 888     return;
 889
 890   // If the instruction's type is being remapped, do so now.
 891   if (auto CS = CallSite(I)) {
 892     SmallVector<Type *, 3> Tys;
 893     FunctionType *FTy = CS.getFunctionType();
 894     Tys.reserve(FTy->getNumParams());
 895     for (Type *Ty : FTy->params())
 896       Tys.push_back(TypeMapper->remapType(Ty));
 897     CS.mutateFunctionType(FunctionType::get(
 898         TypeMapper->remapType(I->getType()), Tys, FTy->isVarArg()));
 899
 900     LLVMContext &C = CS->getContext();
 901     AttributeList Attrs = CS.getAttributes();
 902     for (unsigned i = 0; i < Attrs.getNumAttrSets(); ++i) {
 903       if (Attrs.hasAttribute(i, Attribute::ByVal)) {
 904         Type *Ty = Attrs.getAttribute(i, Attribute::ByVal).getValueAsType();
 905         if (!Ty)
 906           continue;
 907
 908         Attrs = Attrs.removeAttribute(C, i, Attribute::ByVal);
 909         Attrs = Attrs.addAttribute(
 910             C, i, Attribute::getWithByValType(C, TypeMapper->remapType(Ty)));
 911       }
 912     }
 913     CS.setAttributes(Attrs);
 914     return;
 915   }
 916   if (auto *AI = dyn_cast<AllocaInst>(I))
 917     AI->setAllocatedType(TypeMapper->remapType(AI->getAllocatedType()));
 918   if (auto *GEP = dyn_cast<GetElementPtrInst>(I)) {
 919     GEP->setSourceElementType(
 920         TypeMapper->remapType(GEP->getSourceElementType()));
 921     GEP->setResultElementType(
 922         TypeMapper->remapType(GEP->getResultElementType()));
 923   }
 924   I->mutateType(TypeMapper->remapType(I->getType()));
 925 }
 926
 927 void Mapper::remapGlobalObjectMetadata(GlobalObject &GO) {
 928   SmallVector<std::pair<unsigned, MDNode *>, 8> MDs;
 929   GO.getAllMetadata(MDs);
 930   GO.clearMetadata();
 931   for (const auto &I : MDs)
 932     GO.addMetadata(I.first, *cast<MDNode>(mapMetadata(I.second)));
 933 }
 934
 935 void Mapper::remapFunction(Function &F) {
 936   // Remap the operands.
 937   for (Use &Op : F.operands())
 938     if (Op)
 939       Op = mapValue(Op);
 940
 941   // Remap the metadata attachments.
 942   remapGlobalObjectMetadata(F);
 943
 944   // Remap the argument types.
 945   if (TypeMapper)
 946     for (Argument &A : F.args())
 947       A.mutateType(TypeMapper->remapType(A.getType()));
 948
 949   // Remap the instructions.
 950   for (BasicBlock &BB : F)
 951     for (Instruction &I : BB)
 952       remapInstruction(&I);
 953 }
 954
 955 void Mapper::mapAppendingVariable(GlobalVariable &GV, Constant *InitPrefix,
 956                                   bool IsOldCtorDtor,
 957                                   ArrayRef<Constant *> NewMembers) {
 958   SmallVector<Constant *, 16> Elements;
 959   if (InitPrefix) {
 960     unsigned NumElements =
 961         cast<ArrayType>(InitPrefix->getType())->getNumElements();
 962     for (unsigned I = 0; I != NumElements; ++I)
 963       Elements.push_back(InitPrefix->getAggregateElement(I));
 964   }
 965
 966   PointerType *VoidPtrTy;
 967   Type *EltTy;
 968   if (IsOldCtorDtor) {
 969     // FIXME: This upgrade is done during linking to support the C API.  See
 970     // also IRLinker::linkAppendingVarProto() in IRMover.cpp.
 971     VoidPtrTy = Type::getInt8Ty(GV.getContext())->getPointerTo();
 972     auto &ST = *cast<StructType>(NewMembers.front()->getType());
 973     Type *Tys[3] = {ST.getElementType(0), ST.getElementType(1), VoidPtrTy};
 974     EltTy = StructType::get(GV.getContext(), Tys, false);
 975   }
 976
 977   for (auto *V : NewMembers) {
 978     Constant *NewV;
 979     if (IsOldCtorDtor) {
 980       auto *S = cast<ConstantStruct>(V);
 981       auto *E1 = cast<Constant>(mapValue(S->getOperand(0)));
 982       auto *E2 = cast<Constant>(mapValue(S->getOperand(1)));
 983       Constant *Null = Constant::getNullValue(VoidPtrTy);
 984       NewV = ConstantStruct::get(cast<StructType>(EltTy), E1, E2, Null);
 985     } else {
 986       NewV = cast_or_null<Constant>(mapValue(V));
 987     }
 988     Elements.push_back(NewV);
 989   }
 990
 991   GV.setInitializer(ConstantArray::get(
 992       cast<ArrayType>(GV.getType()->getElementType()), Elements));
 993 }
 994
 995 void Mapper::scheduleMapGlobalInitializer(GlobalVariable &GV, Constant &Init,
 996                                           unsigned MCID) {
 997   assert(AlreadyScheduled.insert(&GV).second && "Should not reschedule");
 998   assert(MCID < MCs.size() && "Invalid mapping context");
 999
1000   WorklistEntry WE;
1001   WE.Kind = WorklistEntry::MapGlobalInit;
1002   WE.MCID = MCID;
1003   WE.Data.GVInit.GV = &GV;
1004   WE.Data.GVInit.Init = &Init;
1005   Worklist.push_back(WE);
1006 }
1007
1008 void Mapper::scheduleMapAppendingVariable(GlobalVariable &GV,
1009                                           Constant *InitPrefix,
1010                                           bool IsOldCtorDtor,
1011                                           ArrayRef<Constant *> NewMembers,
1012                                           unsigned MCID) {
1013   assert(AlreadyScheduled.insert(&GV).second && "Should not reschedule");
1014   assert(MCID < MCs.size() && "Invalid mapping context");
1015
1016   WorklistEntry WE;
1017   WE.Kind = WorklistEntry::MapAppendingVar;
1018   WE.MCID = MCID;
1019   WE.Data.AppendingGV.GV = &GV;
1020   WE.Data.AppendingGV.InitPrefix = InitPrefix;
1021   WE.AppendingGVIsOldCtorDtor = IsOldCtorDtor;
1022   WE.AppendingGVNumNewMembers = NewMembers.size();
1023   Worklist.push_back(WE);
1024   AppendingInits.append(NewMembers.begin(), NewMembers.end());
1025 }
1026
1027 void Mapper::scheduleMapGlobalIndirectSymbol(GlobalIndirectSymbol &GIS,
1028                                              Constant &Target, unsigned MCID) {
1029   assert(AlreadyScheduled.insert(&GIS).second && "Should not reschedule");
1030   assert(MCID < MCs.size() && "Invalid mapping context");
1031
1032   WorklistEntry WE;
1033   WE.Kind = WorklistEntry::MapGlobalIndirectSymbol;
1034   WE.MCID = MCID;
1035   WE.Data.GlobalIndirectSymbol.GIS = &GIS;
1036   WE.Data.GlobalIndirectSymbol.Target = &Target;
1037   Worklist.push_back(WE);
1038 }
1039
1040 void Mapper::scheduleRemapFunction(Function &F, unsigned MCID) {
1041   assert(AlreadyScheduled.insert(&F).second && "Should not reschedule");
1042   assert(MCID < MCs.size() && "Invalid mapping context");
1043
1044   WorklistEntry WE;
1045   WE.Kind = WorklistEntry::RemapFunction;
1046   WE.MCID = MCID;
1047   WE.Data.RemapF = &F;
1048   Worklist.push_back(WE);
1049 }
1050
1051 void Mapper::addFlags(RemapFlags Flags) {
1052   assert(!hasWorkToDo() && "Expected to have flushed the worklist");
1053   this->Flags = this->Flags | Flags;
1054 }
1055
1056 static Mapper *getAsMapper(void *pImpl) {
1057   return reinterpret_cast<Mapper *>(pImpl);
1058 }
1059
1060 namespace {
1061
1062 class FlushingMapper {
1063   Mapper &M;
1064
1065 public:
1066   explicit FlushingMapper(void *pImpl) : M(*getAsMapper(pImpl)) {
1067     assert(!M.hasWorkToDo() && "Expected to be flushed");
1068   }
1069
1070   ~FlushingMapper() { M.flush(); }
1071
1072   Mapper *operator->() const { return &M; }
1073 };
1074
1075 } // end anonymous namespace
1076
1077 ValueMapper::ValueMapper(ValueToValueMapTy &VM, RemapFlags Flags,
1078                          ValueMapTypeRemapper *TypeMapper,
1079                          ValueMaterializer *Materializer)
1080     : pImpl(new Mapper(VM, Flags, TypeMapper, Materializer)) {}
1081
1082 ValueMapper::~ValueMapper() { delete getAsMapper(pImpl); }
1083
1084 unsigned
1085 ValueMapper::registerAlternateMappingContext(ValueToValueMapTy &VM,
1086                                              ValueMaterializer *Materializer) {
1087   return getAsMapper(pImpl)->registerAlternateMappingContext(VM, Materializer);
1088 }
1089
1090 void ValueMapper::addFlags(RemapFlags Flags) {
1091   FlushingMapper(pImpl)->addFlags(Flags);
1092 }
1093
1094 Value *ValueMapper::mapValue(const Value &V) {
1095   return FlushingMapper(pImpl)->mapValue(&V);
1096 }
1097
1098 Constant *ValueMapper::mapConstant(const Constant &C) {
1099   return cast_or_null<Constant>(mapValue(C));
1100 }
1101
1102 Metadata *ValueMapper::mapMetadata(const Metadata &MD) {
1103   return FlushingMapper(pImpl)->mapMetadata(&MD);
1104 }
1105
1106 MDNode *ValueMapper::mapMDNode(const MDNode &N) {
1107   return cast_or_null<MDNode>(mapMetadata(N));
1108 }
1109
1110 void ValueMapper::remapInstruction(Instruction &I) {
1111   FlushingMapper(pImpl)->remapInstruction(&I);
1112 }
1113
1114 void ValueMapper::remapFunction(Function &F) {
1115   FlushingMapper(pImpl)->remapFunction(F);
1116 }
1117
1118 void ValueMapper::scheduleMapGlobalInitializer(GlobalVariable &GV,
1119                                                Constant &Init,
1120                                                unsigned MCID) {
1121   getAsMapper(pImpl)->scheduleMapGlobalInitializer(GV, Init, MCID);
1122 }
1123
1124 void ValueMapper::scheduleMapAppendingVariable(GlobalVariable &GV,
1125                                                Constant *InitPrefix,
1126                                                bool IsOldCtorDtor,
1127                                                ArrayRef<Constant *> NewMembers,
1128                                                unsigned MCID) {
1129   getAsMapper(pImpl)->scheduleMapAppendingVariable(
1130       GV, InitPrefix, IsOldCtorDtor, NewMembers, MCID);
1131 }
1132
1133 void ValueMapper::scheduleMapGlobalIndirectSymbol(GlobalIndirectSymbol &GIS,
1134                                                   Constant &Target,
1135                                                   unsigned MCID) {
1136   getAsMapper(pImpl)->scheduleMapGlobalIndirectSymbol(GIS, Target, MCID);
1137 }
1138
1139 void ValueMapper::scheduleRemapFunction(Function &F, unsigned MCID) {
1140   getAsMapper(pImpl)->scheduleRemapFunction(F, MCID);
1141 }