From 6fe1ff260b0461437523ac731008a24c9b63b1bc Mon Sep 17 00:00:00 2001 From: "Duncan P. N. Exon Smith" Date: Sat, 16 Apr 2016 02:05:33 +0000 Subject: [PATCH] Revert "ValueMapper: Eliminate cross-file co-recursion, NFC" This reverts commit r266503, in case it's the root cause of this bot failure: http://lab.llvm.org:8011/builders/lld-x86_64-freebsd/builds/16810 I'm also reverting r266505 -- "ValueMapper: Use API from r266503 in unit tests, NFC" -- since it's in the way. llvm-svn: 266507 --- llvm/include/llvm/Transforms/Utils/ValueMapper.h | 140 ++------ llvm/lib/Linker/IRMover.cpp | 62 ++-- llvm/lib/Transforms/Utils/ValueMapper.cpp | 364 ++++----------------- .../unittests/Transforms/Utils/ValueMapperTest.cpp | 104 +++--- 4 files changed, 174 insertions(+), 496 deletions(-) diff --git a/llvm/include/llvm/Transforms/Utils/ValueMapper.h b/llvm/include/llvm/Transforms/Utils/ValueMapper.h index 4d8da32..295c187 100644 --- a/llvm/include/llvm/Transforms/Utils/ValueMapper.h +++ b/llvm/include/llvm/Transforms/Utils/ValueMapper.h @@ -98,92 +98,6 @@ static inline RemapFlags operator|(RemapFlags LHS, RemapFlags RHS) { return RemapFlags(unsigned(LHS) | unsigned(RHS)); } -class ValueMapperImpl; - -/// Context for (re-)mapping values (and metadata). -/// -/// A shared context used for mapping and remapping of Value and Metadata -/// instances using \a ValueToValueMapTy, \a RemapFlags, \a -/// ValueMapTypeRemapper, and \a ValueMaterializer. -/// -/// There are a number of top-level entry points: -/// - \a mapValue() (and \a mapConstant()); -/// - \a mapMetadata() (and \a mapMDNode()); -/// - \a remapInstruction(); and -/// - \a remapFunction(). -/// -/// The \a ValueMaterializer can be used as a callback, but cannot invoke any -/// of these top-level functions recursively. Instead, callbacks should use -/// one of the following to schedule work lazily in the \a ValueMapper -/// instance: -/// - \a scheduleMapGlobalInitializer() -/// - \a scheduleMapAppendingVariable() -/// - \a scheduleMapGlobalAliasee() -/// - \a scheduleRemapFunction() -/// -/// Sometimes a callback needs a diferent mapping context. Such a context can -/// be registered using \a registerAlternateMappingContext(), which takes an -/// alternate \a ValueToValueMapTy and \a ValueMaterializer and returns a ID to -/// pass into the schedule*() functions. -/// -/// TODO: lib/Linker really doesn't need the \a ValueHandle in the \a -/// ValueToValueMapTy. We should template \a ValueMapper (and its -/// implementation classes), and explicitly instantiate on two concrete -/// instances of \a ValueMap (one as \a ValueToValueMap, and one with raw \a -/// Value pointers). It may be viable to do away with \a TrackingMDRef in the -/// \a Metadata side map for the lib/Linker case as well, in which case we'll -/// need a new template parameter on \a ValueMap. -/// -/// TODO: Update callers of \a RemapInstruction() and \a MapValue() (etc.) to -/// use \a ValueMapper directly. -class ValueMapper { - void *pImpl; - - ValueMapper(ValueMapper &&) = delete; - ValueMapper(const ValueMapper &) = delete; - ValueMapper &operator=(ValueMapper &&) = delete; - ValueMapper &operator=(const ValueMapper &) = delete; - -public: - ValueMapper(ValueToValueMapTy &VM, RemapFlags Flags = RF_None, - ValueMapTypeRemapper *TypeMapper = nullptr, - ValueMaterializer *Materializer = nullptr); - ~ValueMapper(); - - /// Register an alternate mapping context. - /// - /// Returns a MappingContextID that can be used with the various schedule*() - /// API to switch in a different value map on-the-fly. - unsigned - registerAlternateMappingContext(ValueToValueMapTy &VM, - ValueMaterializer *Materializer = nullptr); - - /// Add to the current \a RemapFlags. - /// - /// \note Like the top-level mapping functions, \a addFlags() must be called - /// at the top level, not during a callback in a \a ValueMaterializer. - void addFlags(RemapFlags Flags); - - Metadata *mapMetadata(const Metadata &MD); - MDNode *mapMDNode(const MDNode &N); - - Value *mapValue(const Value &V); - Constant *mapConstant(const Constant &C); - - void remapInstruction(Instruction &I); - void remapFunction(Function &F); - - void scheduleMapGlobalInitializer(GlobalVariable &GV, Constant &Init, - unsigned MappingContextID = 0); - void scheduleMapAppendingVariable(GlobalVariable &GV, Constant *InitPrefix, - bool IsOldCtorDtor, - ArrayRef NewMembers, - unsigned MappingContextID = 0); - void scheduleMapGlobalAliasee(GlobalAlias &GA, Constant &Aliasee, - unsigned MappingContextID = 0); - void scheduleRemapFunction(Function &F, unsigned MappingContextID = 0); -}; - /// Look up or compute a value in the value map. /// /// Return a mapped value for a function-local value (Argument, Instruction, @@ -201,12 +115,10 @@ public: /// 6. Else if \c V is a \a MetadataAsValue, rewrap the return of \a /// MapMetadata(). /// 7. Else, compute the equivalent constant, and return it. -inline Value *MapValue(const Value *V, ValueToValueMapTy &VM, - RemapFlags Flags = RF_None, - ValueMapTypeRemapper *TypeMapper = nullptr, - ValueMaterializer *Materializer = nullptr) { - return ValueMapper(VM, Flags, TypeMapper, Materializer).mapValue(*V); -} +Value *MapValue(const Value *V, ValueToValueMapTy &VM, + RemapFlags Flags = RF_None, + ValueMapTypeRemapper *TypeMapper = nullptr, + ValueMaterializer *Materializer = nullptr); /// Lookup or compute a mapping for a piece of metadata. /// @@ -223,20 +135,16 @@ inline Value *MapValue(const Value *V, ValueToValueMapTy &VM, /// /// \note \a LocalAsMetadata is completely unsupported by \a MapMetadata. /// Instead, use \a MapValue() with its wrapping \a MetadataAsValue instance. -inline Metadata *MapMetadata(const Metadata *MD, ValueToValueMapTy &VM, - RemapFlags Flags = RF_None, - ValueMapTypeRemapper *TypeMapper = nullptr, - ValueMaterializer *Materializer = nullptr) { - return ValueMapper(VM, Flags, TypeMapper, Materializer).mapMetadata(*MD); -} +Metadata *MapMetadata(const Metadata *MD, ValueToValueMapTy &VM, + RemapFlags Flags = RF_None, + ValueMapTypeRemapper *TypeMapper = nullptr, + ValueMaterializer *Materializer = nullptr); /// Version of MapMetadata with type safety for MDNode. -inline MDNode *MapMetadata(const MDNode *MD, ValueToValueMapTy &VM, - RemapFlags Flags = RF_None, - ValueMapTypeRemapper *TypeMapper = nullptr, - ValueMaterializer *Materializer = nullptr) { - return ValueMapper(VM, Flags, TypeMapper, Materializer).mapMDNode(*MD); -} +MDNode *MapMetadata(const MDNode *MD, ValueToValueMapTy &VM, + RemapFlags Flags = RF_None, + ValueMapTypeRemapper *TypeMapper = nullptr, + ValueMaterializer *Materializer = nullptr); /// Convert the instruction operands from referencing the current values into /// those specified by VM. @@ -246,12 +154,10 @@ inline MDNode *MapMetadata(const MDNode *MD, ValueToValueMapTy &VM, /// /// Note that \a MapValue() only returns \c nullptr for SSA values missing from /// \c VM. -inline void RemapInstruction(Instruction *I, ValueToValueMapTy &VM, - RemapFlags Flags = RF_None, - ValueMapTypeRemapper *TypeMapper = nullptr, - ValueMaterializer *Materializer = nullptr) { - ValueMapper(VM, Flags, TypeMapper, Materializer).remapInstruction(*I); -} +void RemapInstruction(Instruction *I, ValueToValueMapTy &VM, + RemapFlags Flags = RF_None, + ValueMapTypeRemapper *TypeMapper = nullptr, + ValueMaterializer *Materializer = nullptr); /// Remap the operands, metadata, arguments, and instructions of a function. /// @@ -259,19 +165,19 @@ inline void RemapInstruction(Instruction *I, ValueToValueMapTy &VM, /// function; calls \a MapMetadata() on each attached MDNode; remaps the /// argument types using the provided \c TypeMapper; and calls \a /// RemapInstruction() on every instruction. -inline void RemapFunction(Function &F, ValueToValueMapTy &VM, - RemapFlags Flags = RF_None, - ValueMapTypeRemapper *TypeMapper = nullptr, - ValueMaterializer *Materializer = nullptr) { - ValueMapper(VM, Flags, TypeMapper, Materializer).remapFunction(F); -} +void RemapFunction(Function &F, ValueToValueMapTy &VM, + RemapFlags Flags = RF_None, + ValueMapTypeRemapper *TypeMapper = nullptr, + ValueMaterializer *Materializer = nullptr); /// Version of MapValue with type safety for Constant. inline Constant *MapValue(const Constant *V, ValueToValueMapTy &VM, RemapFlags Flags = RF_None, ValueMapTypeRemapper *TypeMapper = nullptr, ValueMaterializer *Materializer = nullptr) { - return ValueMapper(VM, Flags, TypeMapper, Materializer).mapConstant(*V); + // This can be null for RF_NullMapMissingGlobalValues. + return cast_or_null( + MapValue((const Value *)V, VM, Flags, TypeMapper, Materializer)); } } // End llvm namespace diff --git a/llvm/lib/Linker/IRMover.cpp b/llvm/lib/Linker/IRMover.cpp index 64c7323..e4121fe 100644 --- a/llvm/lib/Linker/IRMover.cpp +++ b/llvm/lib/Linker/IRMover.cpp @@ -397,9 +397,8 @@ class IRLinker { bool HasError = false; - /// Entry point for mapping values and alternate context for mapping aliases. - ValueMapper Mapper; - unsigned AliasMCID; + /// Flags to pass to value mapper invocations. + RemapFlags ValueMapperFlags = RF_MoveDistinctMDs | RF_IgnoreMissingLocals; /// Handles cloning of a global values from the source module into /// the destination module, including setting the attributes and visibility. @@ -471,11 +470,7 @@ public: std::unique_ptr SrcM, ArrayRef ValuesToLink, std::function AddLazyFor) : DstM(DstM), SrcM(std::move(SrcM)), AddLazyFor(AddLazyFor), TypeMap(Set), - GValMaterializer(*this), LValMaterializer(*this), - Mapper(ValueMap, RF_MoveDistinctMDs | RF_IgnoreMissingLocals, &TypeMap, - &GValMaterializer), - AliasMCID(Mapper.registerAlternateMappingContext(AliasValueMap, - &LValMaterializer)) { + GValMaterializer(*this), LValMaterializer(*this) { for (GlobalValue *GV : ValuesToLink) maybeAdd(GV); } @@ -717,10 +712,6 @@ Constant *IRLinker::linkAppendingVarProto(GlobalVariable *DstGV, Type *EltTy = cast(TypeMap.get(SrcGV->getValueType())) ->getElementType(); - // FIXME: This upgrade is done during linking to support the C API. Once the - // old form is deprecated, we should move this upgrade to - // llvm::UpgradeGlobalVariable() and simplify the logic here and in - // Mapper::mapAppendingVariable() in ValueMapper.cpp. StringRef Name = SrcGV->getName(); bool IsNewStructor = false; bool IsOldStructor = false; @@ -738,10 +729,8 @@ Constant *IRLinker::linkAppendingVarProto(GlobalVariable *DstGV, EltTy = StructType::get(SrcGV->getContext(), Tys, false); } - uint64_t DstNumElements = 0; if (DstGV) { ArrayType *DstTy = cast(DstGV->getValueType()); - DstNumElements = DstTy->getNumElements(); if (!SrcGV->hasAppendingLinkage() || !DstGV->hasAppendingLinkage()) { emitError( @@ -785,6 +774,10 @@ Constant *IRLinker::linkAppendingVarProto(GlobalVariable *DstGV, } } + SmallVector DstElements; + if (DstGV) + getArrayElements(DstGV->getInitializer(), DstElements); + SmallVector SrcElements; getArrayElements(SrcGV->getInitializer(), SrcElements); @@ -800,7 +793,7 @@ Constant *IRLinker::linkAppendingVarProto(GlobalVariable *DstGV, return !shouldLink(DGV, *Key); }), SrcElements.end()); - uint64_t NewSize = DstNumElements + SrcElements.size(); + uint64_t NewSize = DstElements.size() + SrcElements.size(); ArrayType *NewType = ArrayType::get(EltTy, NewSize); // Create the new global variable. @@ -817,9 +810,25 @@ Constant *IRLinker::linkAppendingVarProto(GlobalVariable *DstGV, // Stop recursion. ValueMap[SrcGV] = Ret; - Mapper.scheduleMapAppendingVariable(*NG, - DstGV ? DstGV->getInitializer() : nullptr, - IsOldStructor, SrcElements); + for (auto *V : SrcElements) { + Constant *NewV; + if (IsOldStructor) { + auto *S = cast(V); + auto *E1 = MapValue(S->getOperand(0), ValueMap, ValueMapperFlags, + &TypeMap, &GValMaterializer); + auto *E2 = MapValue(S->getOperand(1), ValueMap, ValueMapperFlags, + &TypeMap, &GValMaterializer); + Value *Null = Constant::getNullValue(VoidPtrTy); + NewV = + ConstantStruct::get(cast(EltTy), E1, E2, Null, nullptr); + } else { + NewV = + MapValue(V, ValueMap, ValueMapperFlags, &TypeMap, &GValMaterializer); + } + DstElements.push_back(NewV); + } + + NG->setInitializer(ConstantArray::get(NewType, DstElements)); // Replace any uses of the two global variables with uses of the new // global. @@ -926,7 +935,8 @@ Constant *IRLinker::linkGlobalValueProto(GlobalValue *SGV, bool ForAlias) { /// referenced are in Dest. void IRLinker::linkGlobalInit(GlobalVariable &Dst, GlobalVariable &Src) { // Figure out what the initializer looks like in the dest module. - Mapper.scheduleMapGlobalInitializer(Dst, *Src.getInitializer()); + Dst.setInitializer(MapValue(Src.getInitializer(), ValueMap, ValueMapperFlags, + &TypeMap, &GValMaterializer)); } /// Copy the source function over into the dest function and fix up references @@ -958,12 +968,15 @@ bool IRLinker::linkFunctionBody(Function &Dst, Function &Src) { Dst.getBasicBlockList().splice(Dst.end(), Src.getBasicBlockList()); // Everything has been moved over. Remap it. - Mapper.scheduleRemapFunction(Dst); + RemapFunction(Dst, ValueMap, ValueMapperFlags, &TypeMap, &GValMaterializer); return false; } void IRLinker::linkAliasBody(GlobalAlias &Dst, GlobalAlias &Src) { - Mapper.scheduleMapGlobalAliasee(Dst, *Src.getAliasee(), AliasMCID); + Constant *Aliasee = Src.getAliasee(); + Constant *Val = MapValue(Aliasee, AliasValueMap, ValueMapperFlags, &TypeMap, + &LValMaterializer); + Dst.setAliasee(Val); } bool IRLinker::linkGlobalValueBody(GlobalValue &Dst, GlobalValue &Src) { @@ -987,7 +1000,9 @@ void IRLinker::linkNamedMDNodes() { NamedMDNode *DestNMD = DstM.getOrInsertNamedMetadata(NMD.getName()); // Add Src elements into Dest node. for (const MDNode *Op : NMD.operands()) - DestNMD->addOperand(Mapper.mapMDNode(*Op)); + DestNMD->addOperand(MapMetadata( + Op, ValueMap, ValueMapperFlags | RF_NullMapMissingGlobalValues, + &TypeMap, &GValMaterializer)); } } @@ -1227,7 +1242,7 @@ bool IRLinker::run() { continue; assert(!GV->isDeclaration()); - Mapper.mapValue(*GV); + MapValue(GV, ValueMap, ValueMapperFlags, &TypeMap, &GValMaterializer); if (HasError) return true; } @@ -1235,7 +1250,6 @@ bool IRLinker::run() { // Note that we are done linking global value bodies. This prevents // metadata linking from creating new references. DoneLinkingBodies = true; - Mapper.addFlags(RF_NullMapMissingGlobalValues); // Remap all of the named MDNodes in Src into the DstM module. We do this // after linking GlobalValues so that MDNodes that reference GlobalValues diff --git a/llvm/lib/Transforms/Utils/ValueMapper.cpp b/llvm/lib/Transforms/Utils/ValueMapper.cpp index db984ee..102f641 100644 --- a/llvm/lib/Transforms/Utils/ValueMapper.cpp +++ b/llvm/lib/Transforms/Utils/ValueMapper.cpp @@ -16,8 +16,6 @@ #include "llvm/IR/CallSite.h" #include "llvm/IR/Constants.h" #include "llvm/IR/Function.h" -#include "llvm/IR/GlobalAlias.h" -#include "llvm/IR/GlobalVariable.h" #include "llvm/IR/InlineAsm.h" #include "llvm/IR/Instructions.h" #include "llvm/IR/Metadata.h" @@ -32,6 +30,14 @@ void ValueMaterializer::materializeInitFor(GlobalValue *New, GlobalValue *Old) { namespace { +/// A GlobalValue whose initializer needs to be materialized. +struct DelayedGlobalValueInit { + GlobalValue *Old; + GlobalValue *New; + DelayedGlobalValueInit(const GlobalValue *Old, GlobalValue *New) + : Old(const_cast(Old)), New(New) {} +}; + /// A basic block used in a BlockAddress whose function body is not yet /// materialized. struct DelayedBasicBlock { @@ -52,88 +58,30 @@ struct DelayedBasicBlock { TempBB(BasicBlock::Create(Old.getContext())) {} }; -struct WorklistEntry { - enum EntryKind { - MapGlobalInit, - MapAppendingVar, - MapGlobalAliasee, - RemapFunction - }; - struct GVInitTy { - GlobalVariable *GV; - Constant *Init; - }; - struct AppendingGVTy { - GlobalVariable *GV; - Constant *InitPrefix; - }; - struct GlobalAliaseeTy { - GlobalAlias *GA; - Constant *Aliasee; - }; - - unsigned Kind : 2; - unsigned MCID : 29; - unsigned AppendingGVIsOldCtorDtor : 1; - unsigned AppendingGVNumNewMembers; - union { - GVInitTy GVInit; - AppendingGVTy AppendingGV; - GlobalAliaseeTy GlobalAliasee; - Function *RemapF; - } Data; -}; - -struct MappingContext { - ValueToValueMapTy *VM; - ValueMaterializer *Materializer = nullptr; - - /// Construct a MappingContext with a value map and materializer. - explicit MappingContext(ValueToValueMapTy &VM, - ValueMaterializer *Materializer = nullptr) - : VM(&VM), Materializer(Materializer) {} -}; - class MDNodeMapper; class Mapper { friend class MDNodeMapper; + ValueToValueMapTy *VM; RemapFlags Flags; ValueMapTypeRemapper *TypeMapper; - unsigned CurrentMCID = 0; - SmallVector MCs; - SmallVector Worklist; + ValueMaterializer *Materializer; + + SmallVector DelayedInits; SmallVector DelayedBBs; - SmallVector AppendingInits; public: Mapper(ValueToValueMapTy &VM, RemapFlags Flags, ValueMapTypeRemapper *TypeMapper, ValueMaterializer *Materializer) - : Flags(Flags), TypeMapper(TypeMapper), - MCs(1, MappingContext(VM, Materializer)) {} + : VM(&VM), Flags(Flags), TypeMapper(TypeMapper), + Materializer(Materializer) {} - /// ValueMapper should explicitly call \a flush() before destruction. - ~Mapper() { assert(!hasWorkToDo() && "Expected to be flushed"); } - - bool hasWorkToDo() const { return !Worklist.empty(); } - - unsigned - registerAlternateMappingContext(ValueToValueMapTy &VM, - ValueMaterializer *Materializer = nullptr) { - MCs.push_back(MappingContext(VM, Materializer)); - return MCs.size() - 1; - } - - void addFlags(RemapFlags Flags); + ~Mapper(); Value *mapValue(const Value *V); void remapInstruction(Instruction *I); void remapFunction(Function &F); - Constant *mapConstant(const Constant *C) { - return cast_or_null(mapValue(C)); - } - /// Map metadata. /// /// Find the mapping for MD. Guarantees that the return will be resolved @@ -154,28 +102,8 @@ public: // through metadata operands, always return nullptr on unmapped locals. Metadata *mapLocalAsMetadata(const LocalAsMetadata &LAM); - void scheduleMapGlobalInitializer(GlobalVariable &GV, Constant &Init, - unsigned MCID); - void scheduleMapAppendingVariable(GlobalVariable &GV, Constant *InitPrefix, - bool IsOldCtorDtor, - ArrayRef NewMembers, - unsigned MCID); - void scheduleMapGlobalAliasee(GlobalAlias &GA, Constant &Aliasee, - unsigned MCID); - void scheduleRemapFunction(Function &F, unsigned MCID); - - void flush(); - private: - void mapGlobalInitializer(GlobalVariable &GV, Constant &Init); - void mapAppendingVariable(GlobalVariable &GV, Constant *InitPrefix, - bool IsOldCtorDtor, - ArrayRef NewMembers); - void mapGlobalAliasee(GlobalAlias &GA, Constant &Aliasee); - void remapFunction(Function &F, ValueToValueMapTy &VM); - - ValueToValueMapTy &getVM() { return *MCs[CurrentMCID].VM; } - ValueMaterializer *getMaterializer() { return MCs[CurrentMCID].Materializer; } + ValueToValueMapTy &getVM() { return *VM; } Value *mapBlockAddress(const BlockAddress &BA); @@ -336,6 +264,12 @@ private: } // end namespace +Value *llvm::MapValue(const Value *V, ValueToValueMapTy &VM, RemapFlags Flags, + ValueMapTypeRemapper *TypeMapper, + ValueMaterializer *Materializer) { + return Mapper(VM, Flags, TypeMapper, Materializer).mapValue(V); +} + Value *Mapper::mapValue(const Value *V) { ValueToValueMapTy::iterator I = getVM().find(V); @@ -344,13 +278,13 @@ Value *Mapper::mapValue(const Value *V) { return I->second; // If we have a materializer and it can materialize a value, use that. - if (auto *Materializer = getMaterializer()) { + if (Materializer) { if (Value *NewV = Materializer->materializeDeclFor(const_cast(V))) { getVM()[V] = NewV; if (auto *NewGV = dyn_cast(NewV)) - Materializer->materializeInitFor( - NewGV, cast(const_cast(V))); + DelayedInits.push_back( + DelayedGlobalValueInit(cast(V), NewGV)); return NewV; } } @@ -750,6 +684,12 @@ Optional Mapper::mapSimpleMetadata(const Metadata *MD) { return None; } +Metadata *llvm::MapMetadata(const Metadata *MD, ValueToValueMapTy &VM, + RemapFlags Flags, ValueMapTypeRemapper *TypeMapper, + ValueMaterializer *Materializer) { + return Mapper(VM, Flags, TypeMapper, Materializer).mapMetadata(MD); +} + Metadata *Mapper::mapLocalAsMetadata(const LocalAsMetadata &LAM) { // Lookup the mapping for the value itself, and return the appropriate // metadata. @@ -776,42 +716,36 @@ Metadata *Mapper::mapMetadata(const Metadata *MD) { return MDNodeMapper(*this).map(*cast(MD)); } -void Mapper::flush() { - // Flush out the worklist of global values. - while (!Worklist.empty()) { - WorklistEntry E = Worklist.pop_back_val(); - CurrentMCID = E.MCID; - switch (E.Kind) { - case WorklistEntry::MapGlobalInit: - E.Data.GVInit.GV->setInitializer(mapConstant(E.Data.GVInit.Init)); - break; - case WorklistEntry::MapAppendingVar: { - unsigned PrefixSize = AppendingInits.size() - E.AppendingGVNumNewMembers; - mapAppendingVariable(*E.Data.AppendingGV.GV, - E.Data.AppendingGV.InitPrefix, - E.AppendingGVIsOldCtorDtor, - makeArrayRef(AppendingInits).slice(PrefixSize)); - AppendingInits.resize(PrefixSize); - break; - } - case WorklistEntry::MapGlobalAliasee: - E.Data.GlobalAliasee.GA->setAliasee( - mapConstant(E.Data.GlobalAliasee.Aliasee)); - break; - case WorklistEntry::RemapFunction: - remapFunction(*E.Data.RemapF); - break; - } +Mapper::~Mapper() { + // Materialize global initializers. + while (!DelayedInits.empty()) { + auto Init = DelayedInits.pop_back_val(); + Materializer->materializeInitFor(Init.New, Init.Old); } - CurrentMCID = 0; - // Finish logic for block addresses now that all global values have been - // handled. + // Process block addresses delayed until global inits. while (!DelayedBBs.empty()) { DelayedBasicBlock DBB = DelayedBBs.pop_back_val(); BasicBlock *BB = cast_or_null(mapValue(DBB.OldBB)); DBB.TempBB->replaceAllUsesWith(BB ? BB : DBB.OldBB); } + + // We don't expect these to grow after clearing. + assert(DelayedInits.empty()); + assert(DelayedBBs.empty()); +} + +MDNode *llvm::MapMetadata(const MDNode *MD, ValueToValueMapTy &VM, + RemapFlags Flags, ValueMapTypeRemapper *TypeMapper, + ValueMaterializer *Materializer) { + return cast_or_null(MapMetadata(static_cast(MD), VM, + Flags, TypeMapper, Materializer)); +} + +void llvm::RemapInstruction(Instruction *I, ValueToValueMapTy &VM, + RemapFlags Flags, ValueMapTypeRemapper *TypeMapper, + ValueMaterializer *Materializer) { + Mapper(VM, Flags, TypeMapper, Materializer).remapInstruction(I); } void Mapper::remapInstruction(Instruction *I) { @@ -848,7 +782,7 @@ void Mapper::remapInstruction(Instruction *I) { if (New != Old) I->setMetadata(MI.first, New); } - + if (!TypeMapper) return; @@ -874,6 +808,12 @@ void Mapper::remapInstruction(Instruction *I) { I->mutateType(TypeMapper->remapType(I->getType())); } +void llvm::RemapFunction(Function &F, ValueToValueMapTy &VM, RemapFlags Flags, + ValueMapTypeRemapper *TypeMapper, + ValueMaterializer *Materializer) { + Mapper(VM, Flags, TypeMapper, Materializer).remapFunction(F); +} + void Mapper::remapFunction(Function &F) { // Remap the operands. for (Use &Op : F.operands()) @@ -896,185 +836,3 @@ void Mapper::remapFunction(Function &F) { for (Instruction &I : BB) remapInstruction(&I); } - -void Mapper::mapAppendingVariable(GlobalVariable &GV, Constant *InitPrefix, - bool IsOldCtorDtor, - ArrayRef NewMembers) { - SmallVector Elements; - if (InitPrefix) { - unsigned NumElements = - cast(InitPrefix->getType())->getNumElements(); - for (unsigned I = 0; I != NumElements; ++I) - Elements.push_back(InitPrefix->getAggregateElement(I)); - } - - PointerType *VoidPtrTy; - Type *EltTy; - if (IsOldCtorDtor) { - // FIXME: This upgrade is done during linking to support the C API. See - // also IRLinker::linkAppendingVarProto() in IRMover.cpp. - VoidPtrTy = Type::getInt8Ty(GV.getContext())->getPointerTo(); - auto &ST = *cast(NewMembers.front()->getType()); - Type *Tys[3] = {ST.getElementType(0), ST.getElementType(1), VoidPtrTy}; - EltTy = StructType::get(GV.getContext(), Tys, false); - } - - for (auto *V : NewMembers) { - Constant *NewV; - if (IsOldCtorDtor) { - auto *S = cast(V); - auto *E1 = mapValue(S->getOperand(0)); - auto *E2 = mapValue(S->getOperand(1)); - Value *Null = Constant::getNullValue(VoidPtrTy); - NewV = - ConstantStruct::get(cast(EltTy), E1, E2, Null, nullptr); - } else { - NewV = cast_or_null(mapValue(V)); - } - Elements.push_back(NewV); - } - - GV.setInitializer(ConstantArray::get( - cast(GV.getType()->getElementType()), Elements)); -} - -void Mapper::scheduleMapGlobalInitializer(GlobalVariable &GV, Constant &Init, - unsigned MCID) { - assert(MCID < MCs.size() && "Invalid mapping context"); - - WorklistEntry WE; - WE.Kind = WorklistEntry::MapGlobalInit; - WE.MCID = MCID; - WE.Data.GVInit.GV = &GV; - WE.Data.GVInit.Init = &Init; - Worklist.push_back(WE); -} - -void Mapper::scheduleMapAppendingVariable(GlobalVariable &GV, - Constant *InitPrefix, - bool IsOldCtorDtor, - ArrayRef NewMembers, - unsigned MCID) { - assert(MCID < MCs.size() && "Invalid mapping context"); - - WorklistEntry WE; - WE.Kind = WorklistEntry::MapAppendingVar; - WE.MCID = MCID; - WE.Data.AppendingGV.GV = &GV; - WE.Data.AppendingGV.InitPrefix = InitPrefix; - WE.AppendingGVIsOldCtorDtor = IsOldCtorDtor; - WE.AppendingGVNumNewMembers = NewMembers.size(); - Worklist.push_back(WE); - AppendingInits.append(NewMembers.begin(), NewMembers.end()); -} - -void Mapper::scheduleMapGlobalAliasee(GlobalAlias &GA, Constant &Aliasee, - unsigned MCID) { - assert(MCID < MCs.size() && "Invalid mapping context"); - - WorklistEntry WE; - WE.Kind = WorklistEntry::MapGlobalAliasee; - WE.MCID = MCID; - WE.Data.GlobalAliasee.GA = &GA; - WE.Data.GlobalAliasee.Aliasee = &Aliasee; - Worklist.push_back(WE); -} - -void Mapper::scheduleRemapFunction(Function &F, unsigned MCID) { - assert(MCID < MCs.size() && "Invalid mapping context"); - - WorklistEntry WE; - WE.Kind = WorklistEntry::RemapFunction; - WE.MCID = MCID; - WE.Data.RemapF = &F; - Worklist.push_back(WE); -} - -void Mapper::addFlags(RemapFlags Flags) { - assert(!hasWorkToDo() && "Expected to have flushed the worklist"); - this->Flags = this->Flags | Flags; -} - -static Mapper *getAsMapper(void *pImpl) { - return reinterpret_cast(pImpl); -} - -namespace { - -class FlushingMapper { - Mapper &M; - -public: - explicit FlushingMapper(void *pImpl) : M(*getAsMapper(pImpl)) { - assert(!M.hasWorkToDo() && "Expected to be flushed"); - } - ~FlushingMapper() { M.flush(); } - Mapper *operator->() const { return &M; } -}; - -} // end namespace - -ValueMapper::ValueMapper(ValueToValueMapTy &VM, RemapFlags Flags, - ValueMapTypeRemapper *TypeMapper, - ValueMaterializer *Materializer) - : pImpl(new Mapper(VM, Flags, TypeMapper, Materializer)) {} - -ValueMapper::~ValueMapper() { delete getAsMapper(pImpl); } - -unsigned -ValueMapper::registerAlternateMappingContext(ValueToValueMapTy &VM, - ValueMaterializer *Materializer) { - return getAsMapper(pImpl)->registerAlternateMappingContext(VM, Materializer); -} - -void ValueMapper::addFlags(RemapFlags Flags) { - FlushingMapper(pImpl)->addFlags(Flags); -} - -Value *ValueMapper::mapValue(const Value &V) { - return FlushingMapper(pImpl)->mapValue(&V); -} - -Constant *ValueMapper::mapConstant(const Constant &C) { - return cast_or_null(mapValue(C)); -} - -Metadata *ValueMapper::mapMetadata(const Metadata &MD) { - return FlushingMapper(pImpl)->mapMetadata(&MD); -} - -MDNode *ValueMapper::mapMDNode(const MDNode &N) { - return cast_or_null(mapMetadata(N)); -} - -void ValueMapper::remapInstruction(Instruction &I) { - FlushingMapper(pImpl)->remapInstruction(&I); -} - -void ValueMapper::remapFunction(Function &F) { - FlushingMapper(pImpl)->remapFunction(F); -} - -void ValueMapper::scheduleMapGlobalInitializer(GlobalVariable &GV, - Constant &Init, - unsigned MCID) { - getAsMapper(pImpl)->scheduleMapGlobalInitializer(GV, Init, MCID); -} - -void ValueMapper::scheduleMapAppendingVariable(GlobalVariable &GV, - Constant *InitPrefix, - bool IsOldCtorDtor, - ArrayRef NewMembers, - unsigned MCID) { - getAsMapper(pImpl)->scheduleMapAppendingVariable( - GV, InitPrefix, IsOldCtorDtor, NewMembers, MCID); -} - -void ValueMapper::scheduleMapGlobalAliasee(GlobalAlias &GA, Constant &Aliasee, - unsigned MCID) { - getAsMapper(pImpl)->scheduleMapGlobalAliasee(GA, Aliasee, MCID); -} - -void ValueMapper::scheduleRemapFunction(Function &F, unsigned MCID) { - getAsMapper(pImpl)->scheduleRemapFunction(F, MCID); -} diff --git a/llvm/unittests/Transforms/Utils/ValueMapperTest.cpp b/llvm/unittests/Transforms/Utils/ValueMapperTest.cpp index 2c6d45a..d66bd80 100644 --- a/llvm/unittests/Transforms/Utils/ValueMapperTest.cpp +++ b/llvm/unittests/Transforms/Utils/ValueMapperTest.cpp @@ -19,16 +19,16 @@ using namespace llvm; namespace { -TEST(ValueMapperTest, mapMDNode) { +TEST(ValueMapperTest, MapMetadata) { LLVMContext Context; auto *U = MDTuple::get(Context, None); // The node should be unchanged. ValueToValueMapTy VM; - EXPECT_EQ(U, ValueMapper(VM).mapMDNode(*U)); + EXPECT_EQ(U, MapMetadata(U, VM, RF_None)); } -TEST(ValueMapperTest, mapMDNodeCycle) { +TEST(ValueMapperTest, MapMetadataCycle) { LLVMContext Context; MDNode *U0; MDNode *U1; @@ -52,19 +52,19 @@ TEST(ValueMapperTest, mapMDNodeCycle) { // Cycles shouldn't be duplicated. { ValueToValueMapTy VM; - EXPECT_EQ(U0, ValueMapper(VM).mapMDNode(*U0)); - EXPECT_EQ(U1, ValueMapper(VM).mapMDNode(*U1)); + EXPECT_EQ(U0, MapMetadata(U0, VM, RF_None)); + EXPECT_EQ(U1, MapMetadata(U1, VM, RF_None)); } // Check the other order. { ValueToValueMapTy VM; - EXPECT_EQ(U1, ValueMapper(VM).mapMDNode(*U1)); - EXPECT_EQ(U0, ValueMapper(VM).mapMDNode(*U0)); + EXPECT_EQ(U1, MapMetadata(U1, VM, RF_None)); + EXPECT_EQ(U0, MapMetadata(U0, VM, RF_None)); } } -TEST(ValueMapperTest, mapMDNodeDuplicatedCycle) { +TEST(ValueMapperTest, MapMetadataDuplicatedCycle) { LLVMContext Context; auto *PtrTy = Type::getInt8Ty(Context)->getPointerTo(); std::unique_ptr G0 = llvm::make_unique( @@ -94,8 +94,8 @@ TEST(ValueMapperTest, mapMDNodeDuplicatedCycle) { // have new nodes that reference G1 (instead of G0). ValueToValueMapTy VM; VM[G0.get()] = G1.get(); - MDNode *MappedN0 = ValueMapper(VM).mapMDNode(*N0); - MDNode *MappedN1 = ValueMapper(VM).mapMDNode(*N1); + MDNode *MappedN0 = MapMetadata(N0, VM); + MDNode *MappedN1 = MapMetadata(N1, VM); EXPECT_NE(N0, MappedN0); EXPECT_NE(N1, MappedN1); EXPECT_EQ(ConstantAsMetadata::get(G1.get()), MappedN1->getOperand(1)); @@ -105,31 +105,31 @@ TEST(ValueMapperTest, mapMDNodeDuplicatedCycle) { EXPECT_TRUE(MappedN1->isResolved()); } -TEST(ValueMapperTest, mapMDNodeUnresolved) { +TEST(ValueMapperTest, MapMetadataUnresolved) { LLVMContext Context; TempMDTuple T = MDTuple::getTemporary(Context, None); ValueToValueMapTy VM; - EXPECT_EQ(T.get(), ValueMapper(VM, RF_NoModuleLevelChanges).mapMDNode(*T)); + EXPECT_EQ(T.get(), MapMetadata(T.get(), VM, RF_NoModuleLevelChanges)); } -TEST(ValueMapperTest, mapMDNodeDistinct) { +TEST(ValueMapperTest, MapMetadataDistinct) { LLVMContext Context; auto *D = MDTuple::getDistinct(Context, None); { // The node should be cloned. ValueToValueMapTy VM; - EXPECT_NE(D, ValueMapper(VM).mapMDNode(*D)); + EXPECT_NE(D, MapMetadata(D, VM, RF_None)); } { // The node should be moved. ValueToValueMapTy VM; - EXPECT_EQ(D, ValueMapper(VM, RF_MoveDistinctMDs).mapMDNode(*D)); + EXPECT_EQ(D, MapMetadata(D, VM, RF_MoveDistinctMDs)); } } -TEST(ValueMapperTest, mapMDNodeDistinctOperands) { +TEST(ValueMapperTest, MapMetadataDistinctOperands) { LLVMContext Context; Metadata *Old = MDTuple::getDistinct(Context, None); auto *D = MDTuple::getDistinct(Context, Old); @@ -140,11 +140,11 @@ TEST(ValueMapperTest, mapMDNodeDistinctOperands) { VM.MD()[Old].reset(New); // Make sure operands are updated. - EXPECT_EQ(D, ValueMapper(VM, RF_MoveDistinctMDs).mapMDNode(*D)); + EXPECT_EQ(D, MapMetadata(D, VM, RF_MoveDistinctMDs)); EXPECT_EQ(New, D->getOperand(0)); } -TEST(ValueMapperTest, mapMDNodeSeeded) { +TEST(ValueMapperTest, MapMetadataSeeded) { LLVMContext Context; auto *D = MDTuple::getDistinct(Context, None); @@ -154,10 +154,10 @@ TEST(ValueMapperTest, mapMDNodeSeeded) { VM.MD().insert(std::make_pair(D, TrackingMDRef(D))); EXPECT_EQ(D, *VM.getMappedMD(D)); - EXPECT_EQ(D, ValueMapper(VM).mapMDNode(*D)); + EXPECT_EQ(D, MapMetadata(D, VM, RF_None)); } -TEST(ValueMapperTest, mapMDNodeSeededWithNull) { +TEST(ValueMapperTest, MapMetadataSeededWithNull) { LLVMContext Context; auto *D = MDTuple::getDistinct(Context, None); @@ -167,10 +167,10 @@ TEST(ValueMapperTest, mapMDNodeSeededWithNull) { VM.MD().insert(std::make_pair(D, TrackingMDRef())); EXPECT_EQ(nullptr, *VM.getMappedMD(D)); - EXPECT_EQ(nullptr, ValueMapper(VM).mapMDNode(*D)); + EXPECT_EQ(nullptr, MapMetadata(D, VM, RF_None)); } -TEST(ValueMapperTest, mapMetadataNullMapGlobalWithIgnoreMissingLocals) { +TEST(ValueMapperTest, MapMetadataNullMapGlobalWithIgnoreMissingLocals) { LLVMContext C; FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), Type::getInt8Ty(C), false); @@ -179,25 +179,25 @@ TEST(ValueMapperTest, mapMetadataNullMapGlobalWithIgnoreMissingLocals) { ValueToValueMapTy VM; RemapFlags Flags = RF_IgnoreMissingLocals | RF_NullMapMissingGlobalValues; - EXPECT_EQ(nullptr, ValueMapper(VM, Flags).mapValue(*F)); + EXPECT_EQ(nullptr, MapValue(F.get(), VM, Flags)); } -TEST(ValueMapperTest, mapMetadataMDString) { +TEST(ValueMapperTest, MapMetadataMDString) { LLVMContext C; auto *S1 = MDString::get(C, "S1"); ValueToValueMapTy VM; // Make sure S1 maps to itself, but isn't memoized. - EXPECT_EQ(S1, ValueMapper(VM).mapMetadata(*S1)); + EXPECT_EQ(S1, MapMetadata(S1, VM)); EXPECT_EQ(None, VM.getMappedMD(S1)); // We still expect VM.MD() to be respected. auto *S2 = MDString::get(C, "S2"); VM.MD()[S1].reset(S2); - EXPECT_EQ(S2, ValueMapper(VM).mapMetadata(*S1)); + EXPECT_EQ(S2, MapMetadata(S1, VM)); } -TEST(ValueMapperTest, mapMetadataGetMappedMD) { +TEST(ValueMapperTest, MapMetadataGetMappedMD) { LLVMContext C; auto *N0 = MDTuple::get(C, None); auto *N1 = MDTuple::get(C, N0); @@ -205,8 +205,8 @@ TEST(ValueMapperTest, mapMetadataGetMappedMD) { // Make sure hasMD and getMappedMD work correctly. ValueToValueMapTy VM; EXPECT_FALSE(VM.hasMD()); - EXPECT_EQ(N0, ValueMapper(VM).mapMetadata(*N0)); - EXPECT_EQ(N1, ValueMapper(VM).mapMetadata(*N1)); + EXPECT_EQ(N0, MapMetadata(N0, VM)); + EXPECT_EQ(N1, MapMetadata(N1, VM)); EXPECT_TRUE(VM.hasMD()); ASSERT_NE(None, VM.getMappedMD(N0)); ASSERT_NE(None, VM.getMappedMD(N1)); @@ -214,7 +214,7 @@ TEST(ValueMapperTest, mapMetadataGetMappedMD) { EXPECT_EQ(N1, *VM.getMappedMD(N1)); } -TEST(ValueMapperTest, mapMetadataNoModuleLevelChanges) { +TEST(ValueMapperTest, MapMetadataNoModuleLevelChanges) { LLVMContext C; auto *N0 = MDTuple::get(C, None); auto *N1 = MDTuple::get(C, N0); @@ -222,14 +222,14 @@ TEST(ValueMapperTest, mapMetadataNoModuleLevelChanges) { // Nothing should be memoized when RF_NoModuleLevelChanges. ValueToValueMapTy VM; EXPECT_FALSE(VM.hasMD()); - EXPECT_EQ(N0, ValueMapper(VM, RF_NoModuleLevelChanges).mapMetadata(*N0)); - EXPECT_EQ(N1, ValueMapper(VM, RF_NoModuleLevelChanges).mapMetadata(*N1)); + EXPECT_EQ(N0, MapMetadata(N0, VM, RF_NoModuleLevelChanges)); + EXPECT_EQ(N1, MapMetadata(N1, VM, RF_NoModuleLevelChanges)); EXPECT_FALSE(VM.hasMD()); EXPECT_EQ(None, VM.getMappedMD(N0)); EXPECT_EQ(None, VM.getMappedMD(N1)); } -TEST(ValueMapperTest, mapMetadataConstantAsMetadata) { +TEST(ValueMapperTest, MapMetadataConstantAsMetadata) { LLVMContext C; FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), Type::getInt8Ty(C), false); @@ -239,23 +239,23 @@ TEST(ValueMapperTest, mapMetadataConstantAsMetadata) { auto *CAM = ConstantAsMetadata::get(F.get()); { ValueToValueMapTy VM; - EXPECT_EQ(CAM, ValueMapper(VM).mapMetadata(*CAM)); + EXPECT_EQ(CAM, MapMetadata(CAM, VM)); EXPECT_TRUE(VM.MD().count(CAM)); VM.MD().erase(CAM); - EXPECT_EQ(CAM, ValueMapper(VM, RF_IgnoreMissingLocals).mapMetadata(*CAM)); + EXPECT_EQ(CAM, MapMetadata(CAM, VM, RF_IgnoreMissingLocals)); EXPECT_TRUE(VM.MD().count(CAM)); auto *N = MDTuple::get(C, None); VM.MD()[CAM].reset(N); - EXPECT_EQ(N, ValueMapper(VM).mapMetadata(*CAM)); - EXPECT_EQ(N, ValueMapper(VM, RF_IgnoreMissingLocals).mapMetadata(*CAM)); + EXPECT_EQ(N, MapMetadata(CAM, VM)); + EXPECT_EQ(N, MapMetadata(CAM, VM, RF_IgnoreMissingLocals)); } std::unique_ptr F2( Function::Create(FTy, GlobalValue::ExternalLinkage, "F2")); ValueToValueMapTy VM; VM[F.get()] = F2.get(); - auto *F2MD = ValueMapper(VM).mapMetadata(*CAM); + auto *F2MD = MapMetadata(CAM, VM); EXPECT_TRUE(VM.MD().count(CAM)); EXPECT_TRUE(F2MD); EXPECT_EQ(F2.get(), cast(F2MD)->getValue()); @@ -263,7 +263,7 @@ TEST(ValueMapperTest, mapMetadataConstantAsMetadata) { #ifdef GTEST_HAS_DEATH_TEST #ifndef NDEBUG -TEST(ValueMapperTest, mapMetadataLocalAsMetadata) { +TEST(ValueMapperTest, MapMetadataLocalAsMetadata) { LLVMContext C; FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), Type::getInt8Ty(C), false); @@ -271,18 +271,18 @@ TEST(ValueMapperTest, mapMetadataLocalAsMetadata) { Function::Create(FTy, GlobalValue::ExternalLinkage, "F")); Argument &A = *F->arg_begin(); - // mapMetadata doesn't support LocalAsMetadata. The only valid container for + // MapMetadata doesn't support LocalAsMetadata. The only valid container for // LocalAsMetadata is a MetadataAsValue instance, so use it directly. auto *LAM = LocalAsMetadata::get(&A); ValueToValueMapTy VM; - EXPECT_DEATH(ValueMapper(VM).mapMetadata(*LAM), "Unexpected local metadata"); - EXPECT_DEATH(ValueMapper(VM, RF_IgnoreMissingLocals).mapMetadata(*LAM), + EXPECT_DEATH(MapMetadata(LAM, VM), "Unexpected local metadata"); + EXPECT_DEATH(MapMetadata(LAM, VM, RF_IgnoreMissingLocals), "Unexpected local metadata"); } #endif #endif -TEST(ValueMapperTest, mapValueLocalAsMetadata) { +TEST(ValueMapperTest, MapValueLocalAsMetadata) { LLVMContext C; FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), Type::getInt8Ty(C), false); @@ -305,26 +305,26 @@ TEST(ValueMapperTest, mapValueLocalAsMetadata) { auto *N0 = MDTuple::get(C, None); auto *N0AV = MetadataAsValue::get(C, N0); ValueToValueMapTy VM; - EXPECT_EQ(N0AV, ValueMapper(VM).mapValue(*MAV)); - EXPECT_EQ(nullptr, ValueMapper(VM, RF_IgnoreMissingLocals).mapValue(*MAV)); + EXPECT_EQ(N0AV, MapValue(MAV, VM)); + EXPECT_EQ(nullptr, MapValue(MAV, VM, RF_IgnoreMissingLocals)); EXPECT_FALSE(VM.count(MAV)); EXPECT_FALSE(VM.count(&A)); EXPECT_EQ(None, VM.getMappedMD(LAM)); VM[MAV] = MAV; - EXPECT_EQ(MAV, ValueMapper(VM).mapValue(*MAV)); - EXPECT_EQ(MAV, ValueMapper(VM, RF_IgnoreMissingLocals).mapValue(*MAV)); + EXPECT_EQ(MAV, MapValue(MAV, VM)); + EXPECT_EQ(MAV, MapValue(MAV, VM, RF_IgnoreMissingLocals)); EXPECT_TRUE(VM.count(MAV)); EXPECT_FALSE(VM.count(&A)); VM[MAV] = &A; - EXPECT_EQ(&A, ValueMapper(VM).mapValue(*MAV)); - EXPECT_EQ(&A, ValueMapper(VM, RF_IgnoreMissingLocals).mapValue(*MAV)); + EXPECT_EQ(&A, MapValue(MAV, VM)); + EXPECT_EQ(&A, MapValue(MAV, VM, RF_IgnoreMissingLocals)); EXPECT_TRUE(VM.count(MAV)); EXPECT_FALSE(VM.count(&A)); } -TEST(ValueMapperTest, mapValueLocalAsMetadataToConstant) { +TEST(ValueMapperTest, MapValueLocalAsMetadataToConstant) { LLVMContext Context; auto *Int8 = Type::getInt8Ty(Context); FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context), Int8, false); @@ -342,8 +342,8 @@ TEST(ValueMapperTest, mapValueLocalAsMetadataToConstant) { auto *MDC = MetadataAsValue::get(Context, ValueAsMetadata::get(&C)); EXPECT_TRUE(isa(MDA->getMetadata())); EXPECT_TRUE(isa(MDC->getMetadata())); - EXPECT_EQ(&C, ValueMapper(VM).mapValue(A)); - EXPECT_EQ(MDC, ValueMapper(VM).mapValue(*MDA)); + EXPECT_EQ(&C, MapValue(&A, VM)); + EXPECT_EQ(MDC, MapValue(MDA, VM)); } } // end namespace -- 2.7.4