151cbcbf435d1aaa1a5269d62b5d0b31b57316b4aChris Lattner//===- ValueMapper.cpp - Interface shared by lib/Transforms/Utils ---------===// 2fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman// 3b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// The LLVM Compiler Infrastructure 4b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 7fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman// 8b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell//===----------------------------------------------------------------------===// 951cbcbf435d1aaa1a5269d62b5d0b31b57316b4aChris Lattner// 1051cbcbf435d1aaa1a5269d62b5d0b31b57316b4aChris Lattner// This file defines the MapValue function, which is shared by various parts of 1151cbcbf435d1aaa1a5269d62b5d0b31b57316b4aChris Lattner// the lib/Transforms/Utils library. 1251cbcbf435d1aaa1a5269d62b5d0b31b57316b4aChris Lattner// 1351cbcbf435d1aaa1a5269d62b5d0b31b57316b4aChris Lattner//===----------------------------------------------------------------------===// 1451cbcbf435d1aaa1a5269d62b5d0b31b57316b4aChris Lattner 1505ea54e8869a81b8dd846397175f218f97968907Dan Gohman#include "llvm/Transforms/Utils/ValueMapper.h" 160b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Constants.h" 170b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Function.h" 180b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/InlineAsm.h" 190b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Instructions.h" 200b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Metadata.h" 21f7703df4968084c18c248c1feea9961c19a32e6aChris Lattnerusing namespace llvm; 2251cbcbf435d1aaa1a5269d62b5d0b31b57316b4aChris Lattner 231afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner// Out of line method to get vtable etc for class. 244bb51cc83badd77bdc482b0594b72cb177f052f6Craig Toppervoid ValueMapTypeRemapper::anchor() {} 25a84a83bbcdfaecadfc6574094272fd3edc429a23James Molloyvoid ValueMaterializer::anchor() {} 261afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 271afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris LattnerValue *llvm::MapValue(const Value *V, ValueToValueMapTy &VM, RemapFlags Flags, 28a84a83bbcdfaecadfc6574094272fd3edc429a23James Molloy ValueMapTypeRemapper *TypeMapper, 29a84a83bbcdfaecadfc6574094272fd3edc429a23James Molloy ValueMaterializer *Materializer) { 30b5fa5fcecc97168a72c9533c84cf297c018b957cChris Lattner ValueToValueMapTy::iterator I = VM.find(V); 31b5fa5fcecc97168a72c9533c84cf297c018b957cChris Lattner 32b5fa5fcecc97168a72c9533c84cf297c018b957cChris Lattner // If the value already exists in the map, use it. 33b5fa5fcecc97168a72c9533c84cf297c018b957cChris Lattner if (I != VM.end() && I->second) return I->second; 345e665f559419c7f58a4fd9360cd488f065505c44Chris Lattner 35a84a83bbcdfaecadfc6574094272fd3edc429a23James Molloy // If we have a materializer and it can materialize a value, use that. 36a84a83bbcdfaecadfc6574094272fd3edc429a23James Molloy if (Materializer) { 37a84a83bbcdfaecadfc6574094272fd3edc429a23James Molloy if (Value *NewV = Materializer->materializeValueFor(const_cast<Value*>(V))) 38a84a83bbcdfaecadfc6574094272fd3edc429a23James Molloy return VM[V] = NewV; 39a84a83bbcdfaecadfc6574094272fd3edc429a23James Molloy } 40a84a83bbcdfaecadfc6574094272fd3edc429a23James Molloy 416cb8c23db1c3becdce6dfbf1b7f1677faca4251eDan Gohman // Global values do not need to be seeded into the VM if they 426cb8c23db1c3becdce6dfbf1b7f1677faca4251eDan Gohman // are using the identity mapping. 43ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (isa<GlobalValue>(V)) 44b5fa5fcecc97168a72c9533c84cf297c018b957cChris Lattner return VM[V] = const_cast<Value*>(V); 457305c55a806e550020c0fd78239b587da222f600Chris Lattner 467305c55a806e550020c0fd78239b587da222f600Chris Lattner if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) { 477305c55a806e550020c0fd78239b587da222f600Chris Lattner // Inline asm may need *type* remapping. 487305c55a806e550020c0fd78239b587da222f600Chris Lattner FunctionType *NewTy = IA->getFunctionType(); 497305c55a806e550020c0fd78239b587da222f600Chris Lattner if (TypeMapper) { 507305c55a806e550020c0fd78239b587da222f600Chris Lattner NewTy = cast<FunctionType>(TypeMapper->remapType(NewTy)); 517305c55a806e550020c0fd78239b587da222f600Chris Lattner 527305c55a806e550020c0fd78239b587da222f600Chris Lattner if (NewTy != IA->getFunctionType()) 537305c55a806e550020c0fd78239b587da222f600Chris Lattner V = InlineAsm::get(NewTy, IA->getAsmString(), IA->getConstraintString(), 547305c55a806e550020c0fd78239b587da222f600Chris Lattner IA->hasSideEffects(), IA->isAlignStack()); 557305c55a806e550020c0fd78239b587da222f600Chris Lattner } 567305c55a806e550020c0fd78239b587da222f600Chris Lattner 577305c55a806e550020c0fd78239b587da222f600Chris Lattner return VM[V] = const_cast<Value*>(V); 587305c55a806e550020c0fd78239b587da222f600Chris Lattner } 595f92e2b11f68624f9003e710f44e3bc324cbf89aChris Lattner 60ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (const auto *MDV = dyn_cast<MetadataAsValue>(V)) { 61ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const Metadata *MD = MDV->getMetadata(); 62b5fa5fcecc97168a72c9533c84cf297c018b957cChris Lattner // If this is a module-level metadata and we know that nothing at the module 63b5fa5fcecc97168a72c9533c84cf297c018b957cChris Lattner // level is changing, then use an identity mapping. 64ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (!isa<LocalAsMetadata>(MD) && (Flags & RF_NoModuleLevelChanges)) 65ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return VM[V] = const_cast<Value *>(V); 666cb8c23db1c3becdce6dfbf1b7f1677faca4251eDan Gohman 67ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines auto *MappedMD = MapMetadata(MD, VM, Flags, TypeMapper, Materializer); 68ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (MD == MappedMD || (!MappedMD && (Flags & RF_IgnoreMissingEntries))) 69ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return VM[V] = const_cast<Value *>(V); 7051e62f0f73b2d2a32c2a5b98402114e4c71dc14fChris Lattner 71ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // FIXME: This assert crashes during bootstrap, but I think it should be 72ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // correct. For now, just match behaviour from before the metadata/value 73ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // split. 74ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // 75ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // assert(MappedMD && "Referenced metadata value not in value map"); 76ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return VM[V] = MetadataAsValue::get(V->getContext(), MappedMD); 77f58c34d5315a35d489c5c203ae45430ccb53f973Victor Hernandez } 78f58c34d5315a35d489c5c203ae45430ccb53f973Victor Hernandez 79b5fa5fcecc97168a72c9533c84cf297c018b957cChris Lattner // Okay, this either must be a constant (which may or may not be mappable) or 80b5fa5fcecc97168a72c9533c84cf297c018b957cChris Lattner // is something that is not in the mapping table. 8177488ccc6305760af485c884872368c7a490ab84Chris Lattner Constant *C = const_cast<Constant*>(dyn_cast<Constant>(V)); 82dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!C) 83dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 8477488ccc6305760af485c884872368c7a490ab84Chris Lattner 85b5fa5fcecc97168a72c9533c84cf297c018b957cChris Lattner if (BlockAddress *BA = dyn_cast<BlockAddress>(C)) { 861afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Function *F = 87a84a83bbcdfaecadfc6574094272fd3edc429a23James Molloy cast<Function>(MapValue(BA->getFunction(), VM, Flags, TypeMapper, Materializer)); 88b5fa5fcecc97168a72c9533c84cf297c018b957cChris Lattner BasicBlock *BB = cast_or_null<BasicBlock>(MapValue(BA->getBasicBlock(), VM, 89a84a83bbcdfaecadfc6574094272fd3edc429a23James Molloy Flags, TypeMapper, Materializer)); 90b5fa5fcecc97168a72c9533c84cf297c018b957cChris Lattner return VM[V] = BlockAddress::get(F, BB ? BB : BA->getBasicBlock()); 9177488ccc6305760af485c884872368c7a490ab84Chris Lattner } 9277488ccc6305760af485c884872368c7a490ab84Chris Lattner 931afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Otherwise, we have some other constant to remap. Start by checking to see 941afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // if all operands have an identity remapping. 951afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner unsigned OpNo = 0, NumOperands = C->getNumOperands(); 96dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *Mapped = nullptr; 971afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner for (; OpNo != NumOperands; ++OpNo) { 981afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Value *Op = C->getOperand(OpNo); 99a84a83bbcdfaecadfc6574094272fd3edc429a23James Molloy Mapped = MapValue(Op, VM, Flags, TypeMapper, Materializer); 1001afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (Mapped != C) break; 1011afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner } 1021afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 1031afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // See if the type mapper wants to remap the type as well. 1041afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Type *NewTy = C->getType(); 1051afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (TypeMapper) 1061afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner NewTy = TypeMapper->remapType(NewTy); 1071afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 1081afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // If the result type and all operands match up, then just insert an identity 1091afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // mapping. 1101afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (OpNo == NumOperands && NewTy == C->getType()) 1111afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return VM[V] = C; 1121afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 1131afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Okay, we need to create a new constant. We've already processed some or 1141afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // all of the operands, set them all up now. 1151afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner SmallVector<Constant*, 8> Ops; 1161afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Ops.reserve(NumOperands); 1171afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner for (unsigned j = 0; j != OpNo; ++j) 1181afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Ops.push_back(cast<Constant>(C->getOperand(j))); 1191afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 1201afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // If one of the operands mismatch, push it and the other mapped operands. 1211afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (OpNo != NumOperands) { 122b5fa5fcecc97168a72c9533c84cf297c018b957cChris Lattner Ops.push_back(cast<Constant>(Mapped)); 1231afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 124b5fa5fcecc97168a72c9533c84cf297c018b957cChris Lattner // Map the rest of the operands that aren't processed yet. 1251afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner for (++OpNo; OpNo != NumOperands; ++OpNo) 1261afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Ops.push_back(MapValue(cast<Constant>(C->getOperand(OpNo)), VM, 127a84a83bbcdfaecadfc6574094272fd3edc429a23James Molloy Flags, TypeMapper, Materializer)); 1281bb95911de8d0821aff16bf0cb1e1dfe43856bf1Chris Lattner } 1291afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 1301afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) 1311afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return VM[V] = CE->getWithOperands(Ops, NewTy); 1321afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (isa<ConstantArray>(C)) 1331afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return VM[V] = ConstantArray::get(cast<ArrayType>(NewTy), Ops); 1341afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (isa<ConstantStruct>(C)) 1351afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return VM[V] = ConstantStruct::get(cast<StructType>(NewTy), Ops); 1361afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (isa<ConstantVector>(C)) 1371afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return VM[V] = ConstantVector::get(Ops); 1381afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // If this is a no-operand constant, it must be because the type was remapped. 1391afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (isa<UndefValue>(C)) 1401afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return VM[V] = UndefValue::get(NewTy); 1411afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (isa<ConstantAggregateZero>(C)) 1421afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return VM[V] = ConstantAggregateZero::get(NewTy); 1431afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner assert(isa<ConstantPointerNull>(C)); 1441afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return VM[V] = ConstantPointerNull::get(cast<PointerType>(NewTy)); 14551cbcbf435d1aaa1a5269d62b5d0b31b57316b4aChris Lattner} 1466129af3fb14d1050f9fb4800c787e6f930b910d1Brian Gaeke 147ebe69fe11e48d322045d5949c83283927a0d790bStephen Hinesstatic Metadata *mapToMetadata(ValueToValueMapTy &VM, const Metadata *Key, 148ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Metadata *Val) { 149ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines VM.MD()[Key].reset(Val); 150ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return Val; 151ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines} 152ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 153ebe69fe11e48d322045d5949c83283927a0d790bStephen Hinesstatic Metadata *mapToSelf(ValueToValueMapTy &VM, const Metadata *MD) { 154ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return mapToMetadata(VM, MD, const_cast<Metadata *>(MD)); 155ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines} 156ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 157ebe69fe11e48d322045d5949c83283927a0d790bStephen Hinesstatic Metadata *MapMetadataImpl(const Metadata *MD, 158ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines SmallVectorImpl<MDNode *> &Cycles, 159ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ValueToValueMapTy &VM, RemapFlags Flags, 160ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ValueMapTypeRemapper *TypeMapper, 161ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ValueMaterializer *Materializer); 162ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 163ebe69fe11e48d322045d5949c83283927a0d790bStephen Hinesstatic Metadata *mapMetadataOp(Metadata *Op, SmallVectorImpl<MDNode *> &Cycles, 164ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ValueToValueMapTy &VM, RemapFlags Flags, 165ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ValueMapTypeRemapper *TypeMapper, 166ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ValueMaterializer *Materializer) { 167ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (!Op) 168ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return nullptr; 169ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (Metadata *MappedOp = 170ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines MapMetadataImpl(Op, Cycles, VM, Flags, TypeMapper, Materializer)) 171ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return MappedOp; 172ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Use identity map if MappedOp is null and we can ignore missing entries. 173ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (Flags & RF_IgnoreMissingEntries) 174ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return Op; 175ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 176ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // FIXME: This assert crashes during bootstrap, but I think it should be 177ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // correct. For now, just match behaviour from before the metadata/value 178ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // split. 179ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // 180ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // llvm_unreachable("Referenced metadata not in value map!"); 181ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return nullptr; 182ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines} 183ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 184ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines/// \brief Remap nodes. 185ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines/// 186ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines/// Insert \c NewNode in the value map, and then remap \c OldNode's operands. 187ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines/// Assumes that \c NewNode is already a clone of \c OldNode. 188ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines/// 189ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines/// \pre \c NewNode is a clone of \c OldNode. 190ebe69fe11e48d322045d5949c83283927a0d790bStephen Hinesstatic bool remap(const MDNode *OldNode, MDNode *NewNode, 191ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines SmallVectorImpl<MDNode *> &Cycles, ValueToValueMapTy &VM, 192ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines RemapFlags Flags, ValueMapTypeRemapper *TypeMapper, 193ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ValueMaterializer *Materializer) { 194ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines assert(OldNode->getNumOperands() == NewNode->getNumOperands() && 195ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines "Expected nodes to match"); 196ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines assert(OldNode->isResolved() && "Expected resolved node"); 197ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines assert(!NewNode->isUniqued() && "Expected non-uniqued node"); 198ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 199ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Map the node upfront so it's available for cyclic references. 200ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines mapToMetadata(VM, OldNode, NewNode); 201ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines bool AnyChanged = false; 202ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines for (unsigned I = 0, E = OldNode->getNumOperands(); I != E; ++I) { 203ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Metadata *Old = OldNode->getOperand(I); 204ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines assert(NewNode->getOperand(I) == Old && 205ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines "Expected old operands to already be in place"); 206ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 207ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Metadata *New = mapMetadataOp(OldNode->getOperand(I), Cycles, VM, Flags, 208ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines TypeMapper, Materializer); 209ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (Old != New) { 210ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines AnyChanged = true; 211ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines NewNode->replaceOperandWith(I, New); 212ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 213ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 214ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 215ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return AnyChanged; 216ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines} 217ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 218ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines/// \brief Map a distinct MDNode. 219ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines/// 220ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines/// Distinct nodes are not uniqued, so they must always recreated. 221ebe69fe11e48d322045d5949c83283927a0d790bStephen Hinesstatic Metadata *mapDistinctNode(const MDNode *Node, 222ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines SmallVectorImpl<MDNode *> &Cycles, 223ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ValueToValueMapTy &VM, RemapFlags Flags, 224ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ValueMapTypeRemapper *TypeMapper, 225ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ValueMaterializer *Materializer) { 226ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines assert(Node->isDistinct() && "Expected distinct node"); 227ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 228ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines MDNode *NewMD = MDNode::replaceWithDistinct(Node->clone()); 229ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines remap(Node, NewMD, Cycles, VM, Flags, TypeMapper, Materializer); 230ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 231ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Track any cycles beneath this node. 232ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines for (Metadata *Op : NewMD->operands()) 233ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (auto *Node = dyn_cast_or_null<MDNode>(Op)) 234ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (!Node->isResolved()) 235ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Cycles.push_back(Node); 236ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 237ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return NewMD; 238ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines} 239ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 240ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines/// \brief Map a uniqued MDNode. 241ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines/// 242ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines/// Uniqued nodes may not need to be recreated (they may map to themselves). 243ebe69fe11e48d322045d5949c83283927a0d790bStephen Hinesstatic Metadata *mapUniquedNode(const MDNode *Node, 244ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines SmallVectorImpl<MDNode *> &Cycles, 245ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ValueToValueMapTy &VM, RemapFlags Flags, 246ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ValueMapTypeRemapper *TypeMapper, 247ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ValueMaterializer *Materializer) { 248ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines assert(Node->isUniqued() && "Expected uniqued node"); 249ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 250ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Create a temporary node upfront in case we have a metadata cycle. 251ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines auto ClonedMD = Node->clone(); 252ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (!remap(Node, ClonedMD.get(), Cycles, VM, Flags, TypeMapper, Materializer)) 253ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // No operands changed, so use the identity mapping. 254ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return mapToSelf(VM, Node); 255ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 256ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // At least one operand has changed, so uniquify the cloned node. 257ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return mapToMetadata(VM, Node, 258ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines MDNode::replaceWithUniqued(std::move(ClonedMD))); 259ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines} 260ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 261ebe69fe11e48d322045d5949c83283927a0d790bStephen Hinesstatic Metadata *MapMetadataImpl(const Metadata *MD, 262ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines SmallVectorImpl<MDNode *> &Cycles, 263ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ValueToValueMapTy &VM, RemapFlags Flags, 264ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ValueMapTypeRemapper *TypeMapper, 265ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ValueMaterializer *Materializer) { 266ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // If the value already exists in the map, use it. 267ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (Metadata *NewMD = VM.MD().lookup(MD).get()) 268ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return NewMD; 269ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 270ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (isa<MDString>(MD)) 271ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return mapToSelf(VM, MD); 272ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 273ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (isa<ConstantAsMetadata>(MD)) 274ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if ((Flags & RF_NoModuleLevelChanges)) 275ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return mapToSelf(VM, MD); 276ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 277ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (const auto *VMD = dyn_cast<ValueAsMetadata>(MD)) { 278ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Value *MappedV = 279ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines MapValue(VMD->getValue(), VM, Flags, TypeMapper, Materializer); 280ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (VMD->getValue() == MappedV || 281ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines (!MappedV && (Flags & RF_IgnoreMissingEntries))) 282ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return mapToSelf(VM, MD); 283ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 284ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // FIXME: This assert crashes during bootstrap, but I think it should be 285ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // correct. For now, just match behaviour from before the metadata/value 286ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // split. 287ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // 288ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // assert(MappedV && "Referenced metadata not in value map!"); 289ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (MappedV) 290ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return mapToMetadata(VM, MD, ValueAsMetadata::get(MappedV)); 291ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return nullptr; 292ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 293ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 2944c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar // Note: this cast precedes the Flags check so we always get its associated 2954c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar // assertion. 296ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const MDNode *Node = cast<MDNode>(MD); 297ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 298ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // If this is a module-level metadata and we know that nothing at the 299ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // module level is changing, then use an identity mapping. 300ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (Flags & RF_NoModuleLevelChanges) 301ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return mapToSelf(VM, MD); 302ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 3034c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar // Require resolved nodes whenever metadata might be remapped. 3044c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar assert(Node->isResolved() && "Unexpected unresolved node"); 3054c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar 306ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (Node->isDistinct()) 307ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return mapDistinctNode(Node, Cycles, VM, Flags, TypeMapper, Materializer); 308ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 309ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return mapUniquedNode(Node, Cycles, VM, Flags, TypeMapper, Materializer); 310ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines} 311ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 312ebe69fe11e48d322045d5949c83283927a0d790bStephen HinesMetadata *llvm::MapMetadata(const Metadata *MD, ValueToValueMapTy &VM, 313ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines RemapFlags Flags, ValueMapTypeRemapper *TypeMapper, 314ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ValueMaterializer *Materializer) { 315ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines SmallVector<MDNode *, 8> Cycles; 316ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Metadata *NewMD = 317ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines MapMetadataImpl(MD, Cycles, VM, Flags, TypeMapper, Materializer); 318ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 319ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Resolve cycles underneath MD. 320ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (NewMD && NewMD != MD) { 321ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (auto *N = dyn_cast<MDNode>(NewMD)) 322ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (!N->isResolved()) 323ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines N->resolveCycles(); 324ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 325ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines for (MDNode *N : Cycles) 326ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (!N->isResolved()) 327ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines N->resolveCycles(); 328ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } else { 329ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Shouldn't get unresolved cycles if nothing was remapped. 330ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines assert(Cycles.empty() && "Expected no unresolved cycles"); 331ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 332ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 333ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return NewMD; 334ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines} 335ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 336ebe69fe11e48d322045d5949c83283927a0d790bStephen HinesMDNode *llvm::MapMetadata(const MDNode *MD, ValueToValueMapTy &VM, 337ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines RemapFlags Flags, ValueMapTypeRemapper *TypeMapper, 338ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ValueMaterializer *Materializer) { 339ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return cast<MDNode>(MapMetadata(static_cast<const Metadata *>(MD), VM, Flags, 340ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines TypeMapper, Materializer)); 341ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines} 342ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 3436129af3fb14d1050f9fb4800c787e6f930b910d1Brian Gaeke/// RemapInstruction - Convert the instruction operands from referencing the 34429d3dd8a64791031eea00ffbae51843dc9982df9Devang Patel/// current values into those specified by VMap. 3456129af3fb14d1050f9fb4800c787e6f930b910d1Brian Gaeke/// 3466cb8c23db1c3becdce6dfbf1b7f1677faca4251eDan Gohmanvoid llvm::RemapInstruction(Instruction *I, ValueToValueMapTy &VMap, 347a84a83bbcdfaecadfc6574094272fd3edc429a23James Molloy RemapFlags Flags, ValueMapTypeRemapper *TypeMapper, 348a84a83bbcdfaecadfc6574094272fd3edc429a23James Molloy ValueMaterializer *Materializer){ 3496cb8c23db1c3becdce6dfbf1b7f1677faca4251eDan Gohman // Remap operands. 350ba2c4874244f449ce04a72b542144d5c3f7ff50dGabor Greif for (User::op_iterator op = I->op_begin(), E = I->op_end(); op != E; ++op) { 351a84a83bbcdfaecadfc6574094272fd3edc429a23James Molloy Value *V = MapValue(*op, VMap, Flags, TypeMapper, Materializer); 352b5fa5fcecc97168a72c9533c84cf297c018b957cChris Lattner // If we aren't ignoring missing entries, assert that something happened. 353dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (V) 354b5fa5fcecc97168a72c9533c84cf297c018b957cChris Lattner *op = V; 355b5fa5fcecc97168a72c9533c84cf297c018b957cChris Lattner else 356b5fa5fcecc97168a72c9533c84cf297c018b957cChris Lattner assert((Flags & RF_IgnoreMissingEntries) && 357b5fa5fcecc97168a72c9533c84cf297c018b957cChris Lattner "Referenced value not in value map!"); 3586129af3fb14d1050f9fb4800c787e6f930b910d1Brian Gaeke } 359fd406f1ee2d94bafcb4943e4b21c2f4ea4bd8f3aDaniel Dunbar 36095c3e48f9557adb6064d580684bb14cacec2f826Jay Foad // Remap phi nodes' incoming blocks. 36195c3e48f9557adb6064d580684bb14cacec2f826Jay Foad if (PHINode *PN = dyn_cast<PHINode>(I)) { 36295c3e48f9557adb6064d580684bb14cacec2f826Jay Foad for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) { 36395c3e48f9557adb6064d580684bb14cacec2f826Jay Foad Value *V = MapValue(PN->getIncomingBlock(i), VMap, Flags); 36495c3e48f9557adb6064d580684bb14cacec2f826Jay Foad // If we aren't ignoring missing entries, assert that something happened. 365dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (V) 36695c3e48f9557adb6064d580684bb14cacec2f826Jay Foad PN->setIncomingBlock(i, cast<BasicBlock>(V)); 36795c3e48f9557adb6064d580684bb14cacec2f826Jay Foad else 36895c3e48f9557adb6064d580684bb14cacec2f826Jay Foad assert((Flags & RF_IgnoreMissingEntries) && 36995c3e48f9557adb6064d580684bb14cacec2f826Jay Foad "Referenced block not in value map!"); 37095c3e48f9557adb6064d580684bb14cacec2f826Jay Foad } 37195c3e48f9557adb6064d580684bb14cacec2f826Jay Foad } 37295c3e48f9557adb6064d580684bb14cacec2f826Jay Foad 3731f35b178858c693261b08ab41022f92e250e08b4Devang Patel // Remap attached metadata. 3746cb8c23db1c3becdce6dfbf1b7f1677faca4251eDan Gohman SmallVector<std::pair<unsigned, MDNode *>, 4> MDs; 3751f35b178858c693261b08ab41022f92e250e08b4Devang Patel I->getAllMetadata(MDs); 37637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines for (SmallVectorImpl<std::pair<unsigned, MDNode *>>::iterator 37737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines MI = MDs.begin(), 37837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines ME = MDs.end(); 37937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines MI != ME; ++MI) { 3801afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner MDNode *Old = MI->second; 381ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines MDNode *New = MapMetadata(Old, VMap, Flags, TypeMapper, Materializer); 3826cb8c23db1c3becdce6dfbf1b7f1677faca4251eDan Gohman if (New != Old) 3831afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner I->setMetadata(MI->first, New); 3846cb8c23db1c3becdce6dfbf1b7f1677faca4251eDan Gohman } 3851afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 3861afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // If the instruction's type is being remapped, do so now. 3871afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (TypeMapper) 3881afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner I->mutateType(TypeMapper->remapType(I->getType())); 3896cb8c23db1c3becdce6dfbf1b7f1677faca4251eDan Gohman} 390