mirror of
https://github.com/RPCSX/llvm.git
synced 2025-02-07 13:09:52 +00:00
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. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@266507 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Duncan P. N. Exon Smith
parent
992b34c001
commit
86a7a5ada2
@ -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<Constant *> 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<Constant>(
|
||||
MapValue((const Value *)V, VM, Flags, TypeMapper, Materializer));
|
||||
}
|
||||
|
||||
} // End llvm namespace
|
||||
|
||||
@ -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<Module> SrcM, ArrayRef<GlobalValue *> ValuesToLink,
|
||||
std::function<void(GlobalValue &, IRMover::ValueAdder)> 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<ArrayType>(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<ArrayType>(DstGV->getValueType());
|
||||
DstNumElements = DstTy->getNumElements();
|
||||
|
||||
if (!SrcGV->hasAppendingLinkage() || !DstGV->hasAppendingLinkage()) {
|
||||
emitError(
|
||||
@ -785,6 +774,10 @@ Constant *IRLinker::linkAppendingVarProto(GlobalVariable *DstGV,
|
||||
}
|
||||
}
|
||||
|
||||
SmallVector<Constant *, 16> DstElements;
|
||||
if (DstGV)
|
||||
getArrayElements(DstGV->getInitializer(), DstElements);
|
||||
|
||||
SmallVector<Constant *, 16> 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<ConstantStruct>(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<StructType>(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
|
||||
|
||||
@ -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<GlobalValue *>(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<MappingContext, 2> MCs;
|
||||
SmallVector<WorklistEntry, 4> Worklist;
|
||||
ValueMaterializer *Materializer;
|
||||
|
||||
SmallVector<DelayedGlobalValueInit, 8> DelayedInits;
|
||||
SmallVector<DelayedBasicBlock, 1> DelayedBBs;
|
||||
SmallVector<Constant *, 16> 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<Constant>(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<Constant *> 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<Constant *> 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<Value *>(V))) {
|
||||
getVM()[V] = NewV;
|
||||
if (auto *NewGV = dyn_cast<GlobalValue>(NewV))
|
||||
Materializer->materializeInitFor(
|
||||
NewGV, cast<GlobalValue>(const_cast<Value *>(V)));
|
||||
DelayedInits.push_back(
|
||||
DelayedGlobalValueInit(cast<GlobalValue>(V), NewGV));
|
||||
return NewV;
|
||||
}
|
||||
}
|
||||
@ -750,6 +684,12 @@ Optional<Metadata *> 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<MDNode>(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<BasicBlock>(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<MDNode>(MapMetadata(static_cast<const Metadata *>(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<Constant *> NewMembers) {
|
||||
SmallVector<Constant *, 16> Elements;
|
||||
if (InitPrefix) {
|
||||
unsigned NumElements =
|
||||
cast<ArrayType>(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<StructType>(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<ConstantStruct>(V);
|
||||
auto *E1 = mapValue(S->getOperand(0));
|
||||
auto *E2 = mapValue(S->getOperand(1));
|
||||
Value *Null = Constant::getNullValue(VoidPtrTy);
|
||||
NewV =
|
||||
ConstantStruct::get(cast<StructType>(EltTy), E1, E2, Null, nullptr);
|
||||
} else {
|
||||
NewV = cast_or_null<Constant>(mapValue(V));
|
||||
}
|
||||
Elements.push_back(NewV);
|
||||
}
|
||||
|
||||
GV.setInitializer(ConstantArray::get(
|
||||
cast<ArrayType>(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<Constant *> 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<Mapper *>(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<Constant>(mapValue(C));
|
||||
}
|
||||
|
||||
Metadata *ValueMapper::mapMetadata(const Metadata &MD) {
|
||||
return FlushingMapper(pImpl)->mapMetadata(&MD);
|
||||
}
|
||||
|
||||
MDNode *ValueMapper::mapMDNode(const MDNode &N) {
|
||||
return cast_or_null<MDNode>(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<Constant *> 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);
|
||||
}
|
||||
|
||||
@ -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<GlobalVariable> G0 = llvm::make_unique<GlobalVariable>(
|
||||
@ -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<Function> 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<ConstantAsMetadata>(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<LocalAsMetadata>(MDA->getMetadata()));
|
||||
EXPECT_TRUE(isa<ConstantAsMetadata>(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
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user