ValueMapper.cpp revision ec9186bcf975c9ffa3ec7ca97867f0ec6eb55115
1//===- ValueMapper.cpp - Interface shared by lib/Transforms/Utils ---------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file defines the MapValue function, which is shared by various parts of 11// the lib/Transforms/Utils library. 12// 13//===----------------------------------------------------------------------===// 14 15#include "llvm/Transforms/Utils/ValueMapper.h" 16#include "llvm/Type.h" 17#include "llvm/Constants.h" 18#include "llvm/Function.h" 19#include "llvm/Metadata.h" 20#include "llvm/ADT/SmallVector.h" 21using namespace llvm; 22 23Value *llvm::MapValue(const Value *V, ValueToValueMapTy &VM, 24 RemapFlags Flags) { 25 ValueToValueMapTy::iterator I = VM.find(V); 26 27 // If the value already exists in the map, use it. 28 if (I != VM.end() && I->second) return I->second; 29 30 // Global values do not need to be seeded into the VM if they 31 // are using the identity mapping. 32 if (isa<GlobalValue>(V) || isa<InlineAsm>(V) || isa<MDString>(V)) 33 return VM[V] = const_cast<Value*>(V); 34 35 if (const MDNode *MD = dyn_cast<MDNode>(V)) { 36 // If this is a module-level metadata and we know that nothing at the module 37 // level is changing, then use an identity mapping. 38 if (!MD->isFunctionLocal() && (Flags & RF_NoModuleLevelChanges)) 39 return VM[V] = const_cast<Value*>(V); 40 41 // Create a dummy node in case we have a metadata cycle. 42 MDNode *Dummy = MDNode::getTemporary(V->getContext(), ArrayRef<Value*>()); 43 VM[V] = Dummy; 44 45 // Check all operands to see if any need to be remapped. 46 for (unsigned i = 0, e = MD->getNumOperands(); i != e; ++i) { 47 Value *OP = MD->getOperand(i); 48 if (OP == 0 || MapValue(OP, VM, Flags) == OP) continue; 49 50 // Ok, at least one operand needs remapping. 51 SmallVector<Value*, 4> Elts; 52 Elts.reserve(MD->getNumOperands()); 53 for (i = 0; i != e; ++i) { 54 Value *Op = MD->getOperand(i); 55 Elts.push_back(Op ? MapValue(Op, VM, Flags) : 0); 56 } 57 MDNode *NewMD = MDNode::get(V->getContext(), Elts); 58 Dummy->replaceAllUsesWith(NewMD); 59 VM[V] = NewMD; 60 MDNode::deleteTemporary(Dummy); 61 return NewMD; 62 } 63 64 VM[V] = const_cast<Value*>(V); 65 MDNode::deleteTemporary(Dummy); 66 67 // No operands needed remapping. Use an identity mapping. 68 return const_cast<Value*>(V); 69 } 70 71 // Okay, this either must be a constant (which may or may not be mappable) or 72 // is something that is not in the mapping table. 73 Constant *C = const_cast<Constant*>(dyn_cast<Constant>(V)); 74 if (C == 0) 75 return 0; 76 77 if (BlockAddress *BA = dyn_cast<BlockAddress>(C)) { 78 Function *F = cast<Function>(MapValue(BA->getFunction(), VM, Flags)); 79 BasicBlock *BB = cast_or_null<BasicBlock>(MapValue(BA->getBasicBlock(), VM, 80 Flags)); 81 return VM[V] = BlockAddress::get(F, BB ? BB : BA->getBasicBlock()); 82 } 83 84 for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) { 85 Value *Op = C->getOperand(i); 86 Value *Mapped = MapValue(Op, VM, Flags); 87 if (Mapped == C) continue; 88 89 // Okay, the operands don't all match. We've already processed some or all 90 // of the operands, set them up now. 91 std::vector<Constant*> Ops; 92 Ops.reserve(C->getNumOperands()); 93 for (unsigned j = 0; j != i; ++j) 94 Ops.push_back(cast<Constant>(C->getOperand(i))); 95 Ops.push_back(cast<Constant>(Mapped)); 96 97 // Map the rest of the operands that aren't processed yet. 98 for (++i; i != e; ++i) 99 Ops.push_back(cast<Constant>(MapValue(C->getOperand(i), VM, Flags))); 100 101 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) 102 return VM[V] = CE->getWithOperands(Ops); 103 if (ConstantArray *CA = dyn_cast<ConstantArray>(C)) 104 return VM[V] = ConstantArray::get(CA->getType(), Ops); 105 if (ConstantStruct *CS = dyn_cast<ConstantStruct>(C)) 106 return VM[V] = ConstantStruct::get(CS->getType(), Ops); 107 assert(isa<ConstantVector>(C) && "Unknown mapped constant type"); 108 return VM[V] = ConstantVector::get(Ops); 109 } 110 111 // If we reach here, all of the operands of the constant match. 112 return VM[V] = C; 113} 114 115/// RemapInstruction - Convert the instruction operands from referencing the 116/// current values into those specified by VMap. 117/// 118void llvm::RemapInstruction(Instruction *I, ValueToValueMapTy &VMap, 119 RemapFlags Flags) { 120 // Remap operands. 121 for (User::op_iterator op = I->op_begin(), E = I->op_end(); op != E; ++op) { 122 Value *V = MapValue(*op, VMap, Flags); 123 // If we aren't ignoring missing entries, assert that something happened. 124 if (V != 0) 125 *op = V; 126 else 127 assert((Flags & RF_IgnoreMissingEntries) && 128 "Referenced value not in value map!"); 129 } 130 131 // Remap attached metadata. 132 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs; 133 I->getAllMetadata(MDs); 134 for (SmallVectorImpl<std::pair<unsigned, MDNode *> >::iterator 135 MI = MDs.begin(), ME = MDs.end(); MI != ME; ++MI) { 136 Value *Old = MI->second; 137 Value *New = MapValue(Old, VMap, Flags); 138 if (New != Old) 139 I->setMetadata(MI->first, cast<MDNode>(New)); 140 } 141} 142