ValueMapper.cpp revision 0a205a459884ec745df1c529396dd921f029dafd 
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/BasicBlock.h"
17#include "llvm/Constants.h"
18#include "llvm/GlobalValue.h"
19#include "llvm/Instruction.h"
20#include "llvm/LLVMContext.h"
21#include "llvm/MDNode.h"
22#include "llvm/ADT/SmallVector.h"
23using namespace llvm;
24
25Value *llvm::MapValue(const Value *V, ValueMapTy &VM, LLVMContext* Context) {
26  Value *&VMSlot = VM[V];
27  if (VMSlot) return VMSlot;      // Does it exist in the map yet?
28
29  // NOTE: VMSlot can be invalidated by any reference to VM, which can grow the
30  // DenseMap.  This includes any recursive calls to MapValue.
31
32  // Global values do not need to be seeded into the ValueMap if they are using
33  // the identity mapping.
34  if (isa<GlobalValue>(V) || isa<InlineAsm>(V))
35    return VMSlot = const_cast<Value*>(V);
36
37  if (Constant *C = const_cast<Constant*>(dyn_cast<Constant>(V))) {
38    if (isa<ConstantInt>(C) || isa<ConstantFP>(C) ||
39        isa<ConstantPointerNull>(C) || isa<ConstantAggregateZero>(C) ||
40        isa<UndefValue>(C) || isa<MDString>(C))
41      return VMSlot = C;           // Primitive constants map directly
42    else if (ConstantArray *CA = dyn_cast<ConstantArray>(C)) {
43      for (User::op_iterator b = CA->op_begin(), i = b, e = CA->op_end();
44           i != e; ++i) {
45        Value *MV = MapValue(*i, VM, Context);
46        if (MV != *i) {
47          // This array must contain a reference to a global, make a new array
48          // and return it.
49          //
50          std::vector<Constant*> Values;
51          Values.reserve(CA->getNumOperands());
52          for (User::op_iterator j = b; j != i; ++j)
53            Values.push_back(cast<Constant>(*j));
54          Values.push_back(cast<Constant>(MV));
55          for (++i; i != e; ++i)
56            Values.push_back(cast<Constant>(MapValue(*i, VM, Context)));
57          return VM[V] = Context->getConstantArray(CA->getType(), Values);
58        }
59      }
60      return VM[V] = C;
61
62    } else if (ConstantStruct *CS = dyn_cast<ConstantStruct>(C)) {
63      for (User::op_iterator b = CS->op_begin(), i = b, e = CS->op_end();
64           i != e; ++i) {
65        Value *MV = MapValue(*i, VM, Context);
66        if (MV != *i) {
67          // This struct must contain a reference to a global, make a new struct
68          // and return it.
69          //
70          std::vector<Constant*> Values;
71          Values.reserve(CS->getNumOperands());
72          for (User::op_iterator j = b; j != i; ++j)
73            Values.push_back(cast<Constant>(*j));
74          Values.push_back(cast<Constant>(MV));
75          for (++i; i != e; ++i)
76            Values.push_back(cast<Constant>(MapValue(*i, VM, Context)));
77          return VM[V] = Context->getConstantStruct(CS->getType(), Values);
78        }
79      }
80      return VM[V] = C;
81
82    } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
83      std::vector<Constant*> Ops;
84      for (User::op_iterator i = CE->op_begin(), e = CE->op_end(); i != e; ++i)
85        Ops.push_back(cast<Constant>(MapValue(*i, VM, Context)));
86      return VM[V] = CE->getWithOperands(Ops);
87    } else if (ConstantVector *CP = dyn_cast<ConstantVector>(C)) {
88      for (User::op_iterator b = CP->op_begin(), i = b, e = CP->op_end();
89           i != e; ++i) {
90        Value *MV = MapValue(*i, VM, Context);
91        if (MV != *i) {
92          // This vector value must contain a reference to a global, make a new
93          // vector constant and return it.
94          //
95          std::vector<Constant*> Values;
96          Values.reserve(CP->getNumOperands());
97          for (User::op_iterator j = b; j != i; ++j)
98            Values.push_back(cast<Constant>(*j));
99          Values.push_back(cast<Constant>(MV));
100          for (++i; i != e; ++i)
101            Values.push_back(cast<Constant>(MapValue(*i, VM, Context)));
102          return VM[V] = Context->getConstantVector(Values);
103        }
104      }
105      return VM[V] = C;
106
107    } else if (MDNode *N = dyn_cast<MDNode>(C)) {
108      for (MDNode::const_elem_iterator b = N->elem_begin(), i = b,
109             e = N->elem_end(); i != e; ++i) {
110        if (!*i) continue;
111
112        Value *MV = MapValue(*i, VM, Context);
113        if (MV != *i) {
114          // This MDNode must contain a reference to a global, make a new MDNode
115          // and return it.
116	  SmallVector<Value*, 8> Values;
117          Values.reserve(N->getNumElements());
118          for (MDNode::const_elem_iterator j = b; j != i; ++j)
119            Values.push_back(*j);
120          Values.push_back(MV);
121          for (++i; i != e; ++i)
122            Values.push_back(MapValue(*i, VM, Context));
123          return VM[V] = Context->getMDNode(Values.data(), Values.size());
124        }
125      }
126      return VM[V] = C;
127
128    } else {
129      assert(0 && "Unknown type of constant!");
130    }
131  }
132
133  return 0;
134}
135
136/// RemapInstruction - Convert the instruction operands from referencing the
137/// current values into those specified by ValueMap.
138///
139void llvm::RemapInstruction(Instruction *I, ValueMapTy &ValueMap) {
140  for (User::op_iterator op = I->op_begin(), E = I->op_end(); op != E; ++op) {
141    Value *V = MapValue(*op, ValueMap, I->getParent()->getContext());
142    assert(V && "Referenced value not in value map!");
143    *op = V;
144  }
145}
146