contrib/llvm-project/llvm/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/GlobalAlias.h"
  31 #include "llvm/IR/GlobalObject.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     MapGlobalAliasee,
  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 GlobalAliaseeTy {
  81     GlobalAlias *GA;
  82     Constant *Aliasee;
  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     GlobalAliaseeTy GlobalAliasee;
  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 scheduleMapGlobalAliasee(GlobalAlias &GA, Constant &Aliasee,
 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 mapGlobalAliasee(GlobalAlias &GA, Constant &Aliasee);
 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 namespace {
 778
 779 struct MapMetadataDisabler {
 780   ValueToValueMapTy &VM;
 781
 782   MapMetadataDisabler(ValueToValueMapTy &VM) : VM(VM) {
 783     VM.disableMapMetadata();
 784   }
 785
 786   ~MapMetadataDisabler() { VM.enableMapMetadata(); }
 787 };
 788
 789 } // end anonymous namespace
 790
 791 Optional<Metadata *> Mapper::mapSimpleMetadata(const Metadata *MD) {
 792   // If the value already exists in the map, use it.
 793   if (Optional<Metadata *> NewMD = getVM().getMappedMD(MD))
 794     return *NewMD;
 795
 796   if (isa<MDString>(MD))
 797     return const_cast<Metadata *>(MD);
 798
 799   // This is a module-level metadata.  If nothing at the module level is
 800   // changing, use an identity mapping.
 801   if ((Flags & RF_NoModuleLevelChanges))
 802     return const_cast<Metadata *>(MD);
 803
 804   if (auto *CMD = dyn_cast<ConstantAsMetadata>(MD)) {
 805     // Disallow recursion into metadata mapping through mapValue.
 806     MapMetadataDisabler MMD(getVM());
 807
 808     // Don't memoize ConstantAsMetadata.  Instead of lasting until the
 809     // LLVMContext is destroyed, they can be deleted when the GlobalValue they
 810     // reference is destructed.  These aren't super common, so the extra
 811     // indirection isn't that expensive.
 812     return wrapConstantAsMetadata(*CMD, mapValue(CMD->getValue()));
 813   }
 814
 815   assert(isa<MDNode>(MD) && "Expected a metadata node");
 816
 817   return None;
 818 }
 819
 820 Metadata *Mapper::mapMetadata(const Metadata *MD) {
 821   assert(MD && "Expected valid metadata");
 822   assert(!isa<LocalAsMetadata>(MD) && "Unexpected local metadata");
 823
 824   if (Optional<Metadata *> NewMD = mapSimpleMetadata(MD))
 825     return *NewMD;
 826
 827   return MDNodeMapper(*this).map(*cast<MDNode>(MD));
 828 }
 829
 830 void Mapper::flush() {
 831   // Flush out the worklist of global values.
 832   while (!Worklist.empty()) {
 833     WorklistEntry E = Worklist.pop_back_val();
 834     CurrentMCID = E.MCID;
 835     switch (E.Kind) {
 836     case WorklistEntry::MapGlobalInit:
 837       E.Data.GVInit.GV->setInitializer(mapConstant(E.Data.GVInit.Init));
 838       remapGlobalObjectMetadata(*E.Data.GVInit.GV);
 839       break;
 840     case WorklistEntry::MapAppendingVar: {
 841       unsigned PrefixSize = AppendingInits.size() - E.AppendingGVNumNewMembers;
 842       mapAppendingVariable(*E.Data.AppendingGV.GV,
 843                            E.Data.AppendingGV.InitPrefix,
 844                            E.AppendingGVIsOldCtorDtor,
 845                            makeArrayRef(AppendingInits).slice(PrefixSize));
 846       AppendingInits.resize(PrefixSize);
 847       break;
 848     }
 849     case WorklistEntry::MapGlobalAliasee:
 850       E.Data.GlobalAliasee.GA->setAliasee(
 851           mapConstant(E.Data.GlobalAliasee.Aliasee));
 852       break;
 853     case WorklistEntry::RemapFunction:
 854       remapFunction(*E.Data.RemapF);
 855       break;
 856     }
 857   }
 858   CurrentMCID = 0;
 859
 860   // Finish logic for block addresses now that all global values have been
 861   // handled.
 862   while (!DelayedBBs.empty()) {
 863     DelayedBasicBlock DBB = DelayedBBs.pop_back_val();
 864     BasicBlock *BB = cast_or_null<BasicBlock>(mapValue(DBB.OldBB));
 865     DBB.TempBB->replaceAllUsesWith(BB ? BB : DBB.OldBB);
 866   }
 867 }
 868
 869 void Mapper::remapInstruction(Instruction *I) {
 870   // Remap operands.
 871   for (Use &Op : I->operands()) {
 872     Value *V = mapValue(Op);
 873     // If we aren't ignoring missing entries, assert that something happened.
 874     if (V)
 875       Op = V;
 876     else
 877       assert((Flags & RF_IgnoreMissingLocals) &&
 878              "Referenced value not in value map!");
 879   }
 880
 881   // Remap phi nodes' incoming blocks.
 882   if (PHINode *PN = dyn_cast<PHINode>(I)) {
 883     for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
 884       Value *V = mapValue(PN->getIncomingBlock(i));
 885       // If we aren't ignoring missing entries, assert that something happened.
 886       if (V)
 887         PN->setIncomingBlock(i, cast<BasicBlock>(V));
 888       else
 889         assert((Flags & RF_IgnoreMissingLocals) &&
 890                "Referenced block not in value map!");
 891     }
 892   }
 893
 894   // Remap attached metadata.
 895   SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
 896   I->getAllMetadata(MDs);
 897   for (const auto &MI : MDs) {
 898     MDNode *Old = MI.second;
 899     MDNode *New = cast_or_null<MDNode>(mapMetadata(Old));
 900     if (New != Old)
 901       I->setMetadata(MI.first, New);
 902   }
 903
 904   if (!TypeMapper)
 905     return;
 906
 907   // If the instruction's type is being remapped, do so now.
 908   if (auto CS = CallSite(I)) {
 909     SmallVector<Type *, 3> Tys;
 910     FunctionType *FTy = CS.getFunctionType();
 911     Tys.reserve(FTy->getNumParams());
 912     for (Type *Ty : FTy->params())
 913       Tys.push_back(TypeMapper->remapType(Ty));
 914     CS.mutateFunctionType(FunctionType::get(
 915         TypeMapper->remapType(I->getType()), Tys, FTy->isVarArg()));
 916
 917     LLVMContext &C = CS->getContext();
 918     AttributeList Attrs = CS.getAttributes();
 919     for (unsigned i = 0; i < Attrs.getNumAttrSets(); ++i) {
 920       if (Attrs.hasAttribute(i, Attribute::ByVal)) {
 921         Type *Ty = Attrs.getAttribute(i, Attribute::ByVal).getValueAsType();
 922         if (!Ty)
 923           continue;
 924
 925         Attrs = Attrs.removeAttribute(C, i, Attribute::ByVal);
 926         Attrs = Attrs.addAttribute(
 927             C, i, Attribute::getWithByValType(C, TypeMapper->remapType(Ty)));
 928       }
 929     }
 930     CS.setAttributes(Attrs);
 931     return;
 932   }
 933   if (auto *AI = dyn_cast<AllocaInst>(I))
 934     AI->setAllocatedType(TypeMapper->remapType(AI->getAllocatedType()));
 935   if (auto *GEP = dyn_cast<GetElementPtrInst>(I)) {
 936     GEP->setSourceElementType(
 937         TypeMapper->remapType(GEP->getSourceElementType()));
 938     GEP->setResultElementType(
 939         TypeMapper->remapType(GEP->getResultElementType()));
 940   }
 941   I->mutateType(TypeMapper->remapType(I->getType()));
 942 }
 943
 944 void Mapper::remapGlobalObjectMetadata(GlobalObject &GO) {
 945   SmallVector<std::pair<unsigned, MDNode *>, 8> MDs;
 946   GO.getAllMetadata(MDs);
 947   GO.clearMetadata();
 948   for (const auto &I : MDs)
 949     GO.addMetadata(I.first, *cast<MDNode>(mapMetadata(I.second)));
 950 }
 951
 952 void Mapper::remapFunction(Function &F) {
 953   // Remap the operands.
 954   for (Use &Op : F.operands())
 955     if (Op)
 956       Op = mapValue(Op);
 957
 958   // Remap the metadata attachments.
 959   remapGlobalObjectMetadata(F);
 960
 961   // Remap the argument types.
 962   if (TypeMapper)
 963     for (Argument &A : F.args())
 964       A.mutateType(TypeMapper->remapType(A.getType()));
 965
 966   // Remap the instructions.
 967   for (BasicBlock &BB : F)
 968     for (Instruction &I : BB)
 969       remapInstruction(&I);
 970 }
 971
 972 void Mapper::mapAppendingVariable(GlobalVariable &GV, Constant *InitPrefix,
 973                                   bool IsOldCtorDtor,
 974                                   ArrayRef<Constant *> NewMembers) {
 975   SmallVector<Constant *, 16> Elements;
 976   if (InitPrefix) {
 977     unsigned NumElements =
 978         cast<ArrayType>(InitPrefix->getType())->getNumElements();
 979     for (unsigned I = 0; I != NumElements; ++I)
 980       Elements.push_back(InitPrefix->getAggregateElement(I));
 981   }
 982
 983   PointerType *VoidPtrTy;
 984   Type *EltTy;
 985   if (IsOldCtorDtor) {
 986     // FIXME: This upgrade is done during linking to support the C API.  See
 987     // also IRLinker::linkAppendingVarProto() in IRMover.cpp.
 988     VoidPtrTy = Type::getInt8Ty(GV.getContext())->getPointerTo();
 989     auto &ST = *cast<StructType>(NewMembers.front()->getType());
 990     Type *Tys[3] = {ST.getElementType(0), ST.getElementType(1), VoidPtrTy};
 991     EltTy = StructType::get(GV.getContext(), Tys, false);
 992   }
 993
 994   for (auto *V : NewMembers) {
 995     Constant *NewV;
 996     if (IsOldCtorDtor) {
 997       auto *S = cast<ConstantStruct>(V);
 998       auto *E1 = cast<Constant>(mapValue(S->getOperand(0)));
 999       auto *E2 = cast<Constant>(mapValue(S->getOperand(1)));
1000       Constant *Null = Constant::getNullValue(VoidPtrTy);
1001       NewV = ConstantStruct::get(cast<StructType>(EltTy), E1, E2, Null);
1002     } else {
1003       NewV = cast_or_null<Constant>(mapValue(V));
1004     }
1005     Elements.push_back(NewV);
1006   }
1007
1008   GV.setInitializer(ConstantArray::get(
1009       cast<ArrayType>(GV.getType()->getElementType()), Elements));
1010 }
1011
1012 void Mapper::scheduleMapGlobalInitializer(GlobalVariable &GV, Constant &Init,
1013                                           unsigned MCID) {
1014   assert(AlreadyScheduled.insert(&GV).second && "Should not reschedule");
1015   assert(MCID < MCs.size() && "Invalid mapping context");
1016
1017   WorklistEntry WE;
1018   WE.Kind = WorklistEntry::MapGlobalInit;
1019   WE.MCID = MCID;
1020   WE.Data.GVInit.GV = &GV;
1021   WE.Data.GVInit.Init = &Init;
1022   Worklist.push_back(WE);
1023 }
1024
1025 void Mapper::scheduleMapAppendingVariable(GlobalVariable &GV,
1026                                           Constant *InitPrefix,
1027                                           bool IsOldCtorDtor,
1028                                           ArrayRef<Constant *> NewMembers,
1029                                           unsigned MCID) {
1030   assert(AlreadyScheduled.insert(&GV).second && "Should not reschedule");
1031   assert(MCID < MCs.size() && "Invalid mapping context");
1032
1033   WorklistEntry WE;
1034   WE.Kind = WorklistEntry::MapAppendingVar;
1035   WE.MCID = MCID;
1036   WE.Data.AppendingGV.GV = &GV;
1037   WE.Data.AppendingGV.InitPrefix = InitPrefix;
1038   WE.AppendingGVIsOldCtorDtor = IsOldCtorDtor;
1039   WE.AppendingGVNumNewMembers = NewMembers.size();
1040   Worklist.push_back(WE);
1041   AppendingInits.append(NewMembers.begin(), NewMembers.end());
1042 }
1043
1044 void Mapper::scheduleMapGlobalAliasee(GlobalAlias &GA, Constant &Aliasee,
1045                                       unsigned MCID) {
1046   assert(AlreadyScheduled.insert(&GA).second && "Should not reschedule");
1047   assert(MCID < MCs.size() && "Invalid mapping context");
1048
1049   WorklistEntry WE;
1050   WE.Kind = WorklistEntry::MapGlobalAliasee;
1051   WE.MCID = MCID;
1052   WE.Data.GlobalAliasee.GA = &GA;
1053   WE.Data.GlobalAliasee.Aliasee = &Aliasee;
1054   Worklist.push_back(WE);
1055 }
1056
1057 void Mapper::scheduleRemapFunction(Function &F, unsigned MCID) {
1058   assert(AlreadyScheduled.insert(&F).second && "Should not reschedule");
1059   assert(MCID < MCs.size() && "Invalid mapping context");
1060
1061   WorklistEntry WE;
1062   WE.Kind = WorklistEntry::RemapFunction;
1063   WE.MCID = MCID;
1064   WE.Data.RemapF = &F;
1065   Worklist.push_back(WE);
1066 }
1067
1068 void Mapper::addFlags(RemapFlags Flags) {
1069   assert(!hasWorkToDo() && "Expected to have flushed the worklist");
1070   this->Flags = this->Flags | Flags;
1071 }
1072
1073 static Mapper *getAsMapper(void *pImpl) {
1074   return reinterpret_cast<Mapper *>(pImpl);
1075 }
1076
1077 namespace {
1078
1079 class FlushingMapper {
1080   Mapper &M;
1081
1082 public:
1083   explicit FlushingMapper(void *pImpl) : M(*getAsMapper(pImpl)) {
1084     assert(!M.hasWorkToDo() && "Expected to be flushed");
1085   }
1086
1087   ~FlushingMapper() { M.flush(); }
1088
1089   Mapper *operator->() const { return &M; }
1090 };
1091
1092 } // end anonymous namespace
1093
1094 ValueMapper::ValueMapper(ValueToValueMapTy &VM, RemapFlags Flags,
1095                          ValueMapTypeRemapper *TypeMapper,
1096                          ValueMaterializer *Materializer)
1097     : pImpl(new Mapper(VM, Flags, TypeMapper, Materializer)) {}
1098
1099 ValueMapper::~ValueMapper() { delete getAsMapper(pImpl); }
1100
1101 unsigned
1102 ValueMapper::registerAlternateMappingContext(ValueToValueMapTy &VM,
1103                                              ValueMaterializer *Materializer) {
1104   return getAsMapper(pImpl)->registerAlternateMappingContext(VM, Materializer);
1105 }
1106
1107 void ValueMapper::addFlags(RemapFlags Flags) {
1108   FlushingMapper(pImpl)->addFlags(Flags);
1109 }
1110
1111 Value *ValueMapper::mapValue(const Value &V) {
1112   return FlushingMapper(pImpl)->mapValue(&V);
1113 }
1114
1115 Constant *ValueMapper::mapConstant(const Constant &C) {
1116   return cast_or_null<Constant>(mapValue(C));
1117 }
1118
1119 Metadata *ValueMapper::mapMetadata(const Metadata &MD) {
1120   return FlushingMapper(pImpl)->mapMetadata(&MD);
1121 }
1122
1123 MDNode *ValueMapper::mapMDNode(const MDNode &N) {
1124   return cast_or_null<MDNode>(mapMetadata(N));
1125 }
1126
1127 void ValueMapper::remapInstruction(Instruction &I) {
1128   FlushingMapper(pImpl)->remapInstruction(&I);
1129 }
1130
1131 void ValueMapper::remapFunction(Function &F) {
1132   FlushingMapper(pImpl)->remapFunction(F);
1133 }
1134
1135 void ValueMapper::scheduleMapGlobalInitializer(GlobalVariable &GV,
1136                                                Constant &Init,
1137                                                unsigned MCID) {
1138   getAsMapper(pImpl)->scheduleMapGlobalInitializer(GV, Init, MCID);
1139 }
1140
1141 void ValueMapper::scheduleMapAppendingVariable(GlobalVariable &GV,
1142                                                Constant *InitPrefix,
1143                                                bool IsOldCtorDtor,
1144                                                ArrayRef<Constant *> NewMembers,
1145                                                unsigned MCID) {
1146   getAsMapper(pImpl)->scheduleMapAppendingVariable(
1147       GV, InitPrefix, IsOldCtorDtor, NewMembers, MCID);
1148 }
1149
1150 void ValueMapper::scheduleMapGlobalAliasee(GlobalAlias &GA, Constant &Aliasee,
1151                                            unsigned MCID) {
1152   getAsMapper(pImpl)->scheduleMapGlobalAliasee(GA, Aliasee, MCID);
1153 }
1154
1155 void ValueMapper::scheduleRemapFunction(Function &F, unsigned MCID) {
1156   getAsMapper(pImpl)->scheduleRemapFunction(F, MCID);
1157 }