ValueMapper.cpp revision 1229c0cb10e1c3640253ece03670621d96762e75
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/IR/Constants.h" 17#include "llvm/IR/Function.h" 18#include "llvm/IR/InlineAsm.h" 19#include "llvm/IR/Instructions.h" 20#include "llvm/IR/Metadata.h" 21using namespace llvm; 22 23// Out of line method to get vtable etc for class. 24void ValueMapTypeRemapper::anchor() {} 25 26Value *llvm::MapValue(const Value *V, ValueToValueMapTy &VM, RemapFlags Flags, 27 ValueMapTypeRemapper *TypeMapper) { 28 ValueToValueMapTy::iterator I = VM.find(V); 29 30 // If the value already exists in the map, use it. 31 if (I != VM.end() && I->second) return I->second; 32 33 // Global values do not need to be seeded into the VM if they 34 // are using the identity mapping. 35 if (isa<GlobalValue>(V) || isa<MDString>(V)) 36 return VM[V] = const_cast<Value*>(V); 37 38 if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) { 39 // Inline asm may need *type* remapping. 40 FunctionType *NewTy = IA->getFunctionType(); 41 if (TypeMapper) { 42 NewTy = cast<FunctionType>(TypeMapper->remapType(NewTy)); 43 44 if (NewTy != IA->getFunctionType()) 45 V = InlineAsm::get(NewTy, IA->getAsmString(), IA->getConstraintString(), 46 IA->hasSideEffects(), IA->isAlignStack()); 47 } 48 49 return VM[V] = const_cast<Value*>(V); 50 } 51 52 53 if (const MDNode *MD = dyn_cast<MDNode>(V)) { 54 // If this is a module-level metadata and we know that nothing at the module 55 // level is changing, then use an identity mapping. 56 if (!MD->isFunctionLocal() && (Flags & RF_NoModuleLevelChanges)) 57 return VM[V] = const_cast<Value*>(V); 58 59 // Create a dummy node in case we have a metadata cycle. 60 MDNode *Dummy = MDNode::getTemporary(V->getContext(), ArrayRef<Value*>()); 61 VM[V] = Dummy; 62 63 // Check all operands to see if any need to be remapped. 64 for (unsigned i = 0, e = MD->getNumOperands(); i != e; ++i) { 65 Value *OP = MD->getOperand(i); 66 if (OP == 0) continue; 67 Value *Mapped_OP = MapValue(OP, VM, Flags, TypeMapper); 68 // If Mapped_Op is null, we should use indentity map. 69 if (Mapped_OP == OP || Mapped_OP == 0) continue; 70 71 // Ok, at least one operand needs remapping. 72 SmallVector<Value*, 4> Elts; 73 Elts.reserve(MD->getNumOperands()); 74 for (i = 0; i != e; ++i) { 75 Value *Op = MD->getOperand(i); 76 if (Op == 0) 77 Elts.push_back(0); 78 else { 79 Value *Mapped_Op = MapValue(Op, VM, Flags, TypeMapper); 80 // If Mapped_Op is null, we should use indentity map. 81 Elts.push_back(Mapped_Op ? Mapped_Op : Op); 82 } 83 } 84 MDNode *NewMD = MDNode::get(V->getContext(), Elts); 85 Dummy->replaceAllUsesWith(NewMD); 86 VM[V] = NewMD; 87 MDNode::deleteTemporary(Dummy); 88 return NewMD; 89 } 90 91 VM[V] = const_cast<Value*>(V); 92 MDNode::deleteTemporary(Dummy); 93 94 // No operands needed remapping. Use an identity mapping. 95 return const_cast<Value*>(V); 96 } 97 98 // Okay, this either must be a constant (which may or may not be mappable) or 99 // is something that is not in the mapping table. 100 Constant *C = const_cast<Constant*>(dyn_cast<Constant>(V)); 101 if (C == 0) 102 return 0; 103 104 if (BlockAddress *BA = dyn_cast<BlockAddress>(C)) { 105 Function *F = 106 cast<Function>(MapValue(BA->getFunction(), VM, Flags, TypeMapper)); 107 BasicBlock *BB = cast_or_null<BasicBlock>(MapValue(BA->getBasicBlock(), VM, 108 Flags, TypeMapper)); 109 return VM[V] = BlockAddress::get(F, BB ? BB : BA->getBasicBlock()); 110 } 111 112 // Otherwise, we have some other constant to remap. Start by checking to see 113 // if all operands have an identity remapping. 114 unsigned OpNo = 0, NumOperands = C->getNumOperands(); 115 Value *Mapped = 0; 116 for (; OpNo != NumOperands; ++OpNo) { 117 Value *Op = C->getOperand(OpNo); 118 Mapped = MapValue(Op, VM, Flags, TypeMapper); 119 if (Mapped != C) break; 120 } 121 122 // See if the type mapper wants to remap the type as well. 123 Type *NewTy = C->getType(); 124 if (TypeMapper) 125 NewTy = TypeMapper->remapType(NewTy); 126 127 // If the result type and all operands match up, then just insert an identity 128 // mapping. 129 if (OpNo == NumOperands && NewTy == C->getType()) 130 return VM[V] = C; 131 132 // Okay, we need to create a new constant. We've already processed some or 133 // all of the operands, set them all up now. 134 SmallVector<Constant*, 8> Ops; 135 Ops.reserve(NumOperands); 136 for (unsigned j = 0; j != OpNo; ++j) 137 Ops.push_back(cast<Constant>(C->getOperand(j))); 138 139 // If one of the operands mismatch, push it and the other mapped operands. 140 if (OpNo != NumOperands) { 141 Ops.push_back(cast<Constant>(Mapped)); 142 143 // Map the rest of the operands that aren't processed yet. 144 for (++OpNo; OpNo != NumOperands; ++OpNo) 145 Ops.push_back(MapValue(cast<Constant>(C->getOperand(OpNo)), VM, 146 Flags, TypeMapper)); 147 } 148 149 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) 150 return VM[V] = CE->getWithOperands(Ops, NewTy); 151 if (isa<ConstantArray>(C)) 152 return VM[V] = ConstantArray::get(cast<ArrayType>(NewTy), Ops); 153 if (isa<ConstantStruct>(C)) 154 return VM[V] = ConstantStruct::get(cast<StructType>(NewTy), Ops); 155 if (isa<ConstantVector>(C)) 156 return VM[V] = ConstantVector::get(Ops); 157 // If this is a no-operand constant, it must be because the type was remapped. 158 if (isa<UndefValue>(C)) 159 return VM[V] = UndefValue::get(NewTy); 160 if (isa<ConstantAggregateZero>(C)) 161 return VM[V] = ConstantAggregateZero::get(NewTy); 162 assert(isa<ConstantPointerNull>(C)); 163 return VM[V] = ConstantPointerNull::get(cast<PointerType>(NewTy)); 164} 165 166/// RemapInstruction - Convert the instruction operands from referencing the 167/// current values into those specified by VMap. 168/// 169void llvm::RemapInstruction(Instruction *I, ValueToValueMapTy &VMap, 170 RemapFlags Flags, ValueMapTypeRemapper *TypeMapper){ 171 // Remap operands. 172 for (User::op_iterator op = I->op_begin(), E = I->op_end(); op != E; ++op) { 173 Value *V = MapValue(*op, VMap, Flags, TypeMapper); 174 // If we aren't ignoring missing entries, assert that something happened. 175 if (V != 0) 176 *op = V; 177 else 178 assert((Flags & RF_IgnoreMissingEntries) && 179 "Referenced value not in value map!"); 180 } 181 182 // Remap phi nodes' incoming blocks. 183 if (PHINode *PN = dyn_cast<PHINode>(I)) { 184 for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) { 185 Value *V = MapValue(PN->getIncomingBlock(i), VMap, Flags); 186 // If we aren't ignoring missing entries, assert that something happened. 187 if (V != 0) 188 PN->setIncomingBlock(i, cast<BasicBlock>(V)); 189 else 190 assert((Flags & RF_IgnoreMissingEntries) && 191 "Referenced block not in value map!"); 192 } 193 } 194 195 // Remap attached metadata. 196 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs; 197 I->getAllMetadata(MDs); 198 for (SmallVectorImpl<std::pair<unsigned, MDNode *> >::iterator 199 MI = MDs.begin(), ME = MDs.end(); MI != ME; ++MI) { 200 MDNode *Old = MI->second; 201 MDNode *New = MapValue(Old, VMap, Flags, TypeMapper); 202 if (New != Old) 203 I->setMetadata(MI->first, New); 204 } 205 206 // If the instruction's type is being remapped, do so now. 207 if (TypeMapper) 208 I->mutateType(TypeMapper->remapType(I->getType())); 209} 210