]>
Commit | Line | Data |
---|---|---|
223e47cc LB |
1 | //===-- Constants.cpp - Implement Constant nodes --------------------------===// |
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 implements the Constant* classes. | |
11 | // | |
12 | //===----------------------------------------------------------------------===// | |
13 | ||
14 | #include "llvm/Constants.h" | |
15 | #include "LLVMContextImpl.h" | |
16 | #include "ConstantFold.h" | |
17 | #include "llvm/DerivedTypes.h" | |
18 | #include "llvm/GlobalValue.h" | |
19 | #include "llvm/Instructions.h" | |
20 | #include "llvm/Module.h" | |
21 | #include "llvm/Operator.h" | |
22 | #include "llvm/ADT/FoldingSet.h" | |
23 | #include "llvm/ADT/StringExtras.h" | |
24 | #include "llvm/ADT/StringMap.h" | |
25 | #include "llvm/Support/Compiler.h" | |
26 | #include "llvm/Support/Debug.h" | |
27 | #include "llvm/Support/ErrorHandling.h" | |
28 | #include "llvm/Support/ManagedStatic.h" | |
29 | #include "llvm/Support/MathExtras.h" | |
30 | #include "llvm/Support/raw_ostream.h" | |
31 | #include "llvm/Support/GetElementPtrTypeIterator.h" | |
32 | #include "llvm/ADT/DenseMap.h" | |
33 | #include "llvm/ADT/SmallVector.h" | |
34 | #include "llvm/ADT/STLExtras.h" | |
35 | #include <algorithm> | |
36 | #include <cstdarg> | |
37 | using namespace llvm; | |
38 | ||
39 | //===----------------------------------------------------------------------===// | |
40 | // Constant Class | |
41 | //===----------------------------------------------------------------------===// | |
42 | ||
43 | void Constant::anchor() { } | |
44 | ||
45 | bool Constant::isNegativeZeroValue() const { | |
46 | // Floating point values have an explicit -0.0 value. | |
47 | if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this)) | |
48 | return CFP->isZero() && CFP->isNegative(); | |
49 | ||
50 | // Otherwise, just use +0.0. | |
51 | return isNullValue(); | |
52 | } | |
53 | ||
54 | bool Constant::isNullValue() const { | |
55 | // 0 is null. | |
56 | if (const ConstantInt *CI = dyn_cast<ConstantInt>(this)) | |
57 | return CI->isZero(); | |
58 | ||
59 | // +0.0 is null. | |
60 | if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this)) | |
61 | return CFP->isZero() && !CFP->isNegative(); | |
62 | ||
63 | // constant zero is zero for aggregates and cpnull is null for pointers. | |
64 | return isa<ConstantAggregateZero>(this) || isa<ConstantPointerNull>(this); | |
65 | } | |
66 | ||
67 | bool Constant::isAllOnesValue() const { | |
68 | // Check for -1 integers | |
69 | if (const ConstantInt *CI = dyn_cast<ConstantInt>(this)) | |
70 | return CI->isMinusOne(); | |
71 | ||
72 | // Check for FP which are bitcasted from -1 integers | |
73 | if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this)) | |
74 | return CFP->getValueAPF().bitcastToAPInt().isAllOnesValue(); | |
75 | ||
76 | // Check for constant vectors which are splats of -1 values. | |
77 | if (const ConstantVector *CV = dyn_cast<ConstantVector>(this)) | |
78 | if (Constant *Splat = CV->getSplatValue()) | |
79 | return Splat->isAllOnesValue(); | |
80 | ||
81 | // Check for constant vectors which are splats of -1 values. | |
82 | if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this)) | |
83 | if (Constant *Splat = CV->getSplatValue()) | |
84 | return Splat->isAllOnesValue(); | |
85 | ||
86 | return false; | |
87 | } | |
88 | ||
89 | // Constructor to create a '0' constant of arbitrary type... | |
90 | Constant *Constant::getNullValue(Type *Ty) { | |
91 | switch (Ty->getTypeID()) { | |
92 | case Type::IntegerTyID: | |
93 | return ConstantInt::get(Ty, 0); | |
94 | case Type::HalfTyID: | |
95 | return ConstantFP::get(Ty->getContext(), | |
96 | APFloat::getZero(APFloat::IEEEhalf)); | |
97 | case Type::FloatTyID: | |
98 | return ConstantFP::get(Ty->getContext(), | |
99 | APFloat::getZero(APFloat::IEEEsingle)); | |
100 | case Type::DoubleTyID: | |
101 | return ConstantFP::get(Ty->getContext(), | |
102 | APFloat::getZero(APFloat::IEEEdouble)); | |
103 | case Type::X86_FP80TyID: | |
104 | return ConstantFP::get(Ty->getContext(), | |
105 | APFloat::getZero(APFloat::x87DoubleExtended)); | |
106 | case Type::FP128TyID: | |
107 | return ConstantFP::get(Ty->getContext(), | |
108 | APFloat::getZero(APFloat::IEEEquad)); | |
109 | case Type::PPC_FP128TyID: | |
110 | return ConstantFP::get(Ty->getContext(), | |
111 | APFloat(APInt::getNullValue(128))); | |
112 | case Type::PointerTyID: | |
113 | return ConstantPointerNull::get(cast<PointerType>(Ty)); | |
114 | case Type::StructTyID: | |
115 | case Type::ArrayTyID: | |
116 | case Type::VectorTyID: | |
117 | return ConstantAggregateZero::get(Ty); | |
118 | default: | |
119 | // Function, Label, or Opaque type? | |
120 | llvm_unreachable("Cannot create a null constant of that type!"); | |
121 | } | |
122 | } | |
123 | ||
124 | Constant *Constant::getIntegerValue(Type *Ty, const APInt &V) { | |
125 | Type *ScalarTy = Ty->getScalarType(); | |
126 | ||
127 | // Create the base integer constant. | |
128 | Constant *C = ConstantInt::get(Ty->getContext(), V); | |
129 | ||
130 | // Convert an integer to a pointer, if necessary. | |
131 | if (PointerType *PTy = dyn_cast<PointerType>(ScalarTy)) | |
132 | C = ConstantExpr::getIntToPtr(C, PTy); | |
133 | ||
134 | // Broadcast a scalar to a vector, if necessary. | |
135 | if (VectorType *VTy = dyn_cast<VectorType>(Ty)) | |
136 | C = ConstantVector::getSplat(VTy->getNumElements(), C); | |
137 | ||
138 | return C; | |
139 | } | |
140 | ||
141 | Constant *Constant::getAllOnesValue(Type *Ty) { | |
142 | if (IntegerType *ITy = dyn_cast<IntegerType>(Ty)) | |
143 | return ConstantInt::get(Ty->getContext(), | |
144 | APInt::getAllOnesValue(ITy->getBitWidth())); | |
145 | ||
146 | if (Ty->isFloatingPointTy()) { | |
147 | APFloat FL = APFloat::getAllOnesValue(Ty->getPrimitiveSizeInBits(), | |
148 | !Ty->isPPC_FP128Ty()); | |
149 | return ConstantFP::get(Ty->getContext(), FL); | |
150 | } | |
151 | ||
152 | VectorType *VTy = cast<VectorType>(Ty); | |
153 | return ConstantVector::getSplat(VTy->getNumElements(), | |
154 | getAllOnesValue(VTy->getElementType())); | |
155 | } | |
156 | ||
157 | /// getAggregateElement - For aggregates (struct/array/vector) return the | |
158 | /// constant that corresponds to the specified element if possible, or null if | |
159 | /// not. This can return null if the element index is a ConstantExpr, or if | |
160 | /// 'this' is a constant expr. | |
161 | Constant *Constant::getAggregateElement(unsigned Elt) const { | |
162 | if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(this)) | |
163 | return Elt < CS->getNumOperands() ? CS->getOperand(Elt) : 0; | |
164 | ||
165 | if (const ConstantArray *CA = dyn_cast<ConstantArray>(this)) | |
166 | return Elt < CA->getNumOperands() ? CA->getOperand(Elt) : 0; | |
167 | ||
168 | if (const ConstantVector *CV = dyn_cast<ConstantVector>(this)) | |
169 | return Elt < CV->getNumOperands() ? CV->getOperand(Elt) : 0; | |
170 | ||
171 | if (const ConstantAggregateZero *CAZ =dyn_cast<ConstantAggregateZero>(this)) | |
172 | return CAZ->getElementValue(Elt); | |
173 | ||
174 | if (const UndefValue *UV = dyn_cast<UndefValue>(this)) | |
175 | return UV->getElementValue(Elt); | |
176 | ||
177 | if (const ConstantDataSequential *CDS =dyn_cast<ConstantDataSequential>(this)) | |
178 | return Elt < CDS->getNumElements() ? CDS->getElementAsConstant(Elt) : 0; | |
179 | return 0; | |
180 | } | |
181 | ||
182 | Constant *Constant::getAggregateElement(Constant *Elt) const { | |
183 | assert(isa<IntegerType>(Elt->getType()) && "Index must be an integer"); | |
184 | if (ConstantInt *CI = dyn_cast<ConstantInt>(Elt)) | |
185 | return getAggregateElement(CI->getZExtValue()); | |
186 | return 0; | |
187 | } | |
188 | ||
189 | ||
190 | void Constant::destroyConstantImpl() { | |
191 | // When a Constant is destroyed, there may be lingering | |
192 | // references to the constant by other constants in the constant pool. These | |
193 | // constants are implicitly dependent on the module that is being deleted, | |
194 | // but they don't know that. Because we only find out when the CPV is | |
195 | // deleted, we must now notify all of our users (that should only be | |
196 | // Constants) that they are, in fact, invalid now and should be deleted. | |
197 | // | |
198 | while (!use_empty()) { | |
199 | Value *V = use_back(); | |
200 | #ifndef NDEBUG // Only in -g mode... | |
201 | if (!isa<Constant>(V)) { | |
202 | dbgs() << "While deleting: " << *this | |
203 | << "\n\nUse still stuck around after Def is destroyed: " | |
204 | << *V << "\n\n"; | |
205 | } | |
206 | #endif | |
207 | assert(isa<Constant>(V) && "References remain to Constant being destroyed"); | |
208 | cast<Constant>(V)->destroyConstant(); | |
209 | ||
210 | // The constant should remove itself from our use list... | |
211 | assert((use_empty() || use_back() != V) && "Constant not removed!"); | |
212 | } | |
213 | ||
214 | // Value has no outstanding references it is safe to delete it now... | |
215 | delete this; | |
216 | } | |
217 | ||
218 | /// canTrap - Return true if evaluation of this constant could trap. This is | |
219 | /// true for things like constant expressions that could divide by zero. | |
220 | bool Constant::canTrap() const { | |
221 | assert(getType()->isFirstClassType() && "Cannot evaluate aggregate vals!"); | |
222 | // The only thing that could possibly trap are constant exprs. | |
223 | const ConstantExpr *CE = dyn_cast<ConstantExpr>(this); | |
224 | if (!CE) return false; | |
225 | ||
226 | // ConstantExpr traps if any operands can trap. | |
227 | for (unsigned i = 0, e = getNumOperands(); i != e; ++i) | |
228 | if (CE->getOperand(i)->canTrap()) | |
229 | return true; | |
230 | ||
231 | // Otherwise, only specific operations can trap. | |
232 | switch (CE->getOpcode()) { | |
233 | default: | |
234 | return false; | |
235 | case Instruction::UDiv: | |
236 | case Instruction::SDiv: | |
237 | case Instruction::FDiv: | |
238 | case Instruction::URem: | |
239 | case Instruction::SRem: | |
240 | case Instruction::FRem: | |
241 | // Div and rem can trap if the RHS is not known to be non-zero. | |
242 | if (!isa<ConstantInt>(CE->getOperand(1)) ||CE->getOperand(1)->isNullValue()) | |
243 | return true; | |
244 | return false; | |
245 | } | |
246 | } | |
247 | ||
248 | /// isConstantUsed - Return true if the constant has users other than constant | |
249 | /// exprs and other dangling things. | |
250 | bool Constant::isConstantUsed() const { | |
251 | for (const_use_iterator UI = use_begin(), E = use_end(); UI != E; ++UI) { | |
252 | const Constant *UC = dyn_cast<Constant>(*UI); | |
253 | if (UC == 0 || isa<GlobalValue>(UC)) | |
254 | return true; | |
255 | ||
256 | if (UC->isConstantUsed()) | |
257 | return true; | |
258 | } | |
259 | return false; | |
260 | } | |
261 | ||
262 | ||
263 | ||
264 | /// getRelocationInfo - This method classifies the entry according to | |
265 | /// whether or not it may generate a relocation entry. This must be | |
266 | /// conservative, so if it might codegen to a relocatable entry, it should say | |
267 | /// so. The return values are: | |
268 | /// | |
269 | /// NoRelocation: This constant pool entry is guaranteed to never have a | |
270 | /// relocation applied to it (because it holds a simple constant like | |
271 | /// '4'). | |
272 | /// LocalRelocation: This entry has relocations, but the entries are | |
273 | /// guaranteed to be resolvable by the static linker, so the dynamic | |
274 | /// linker will never see them. | |
275 | /// GlobalRelocations: This entry may have arbitrary relocations. | |
276 | /// | |
277 | /// FIXME: This really should not be in VMCore. | |
278 | Constant::PossibleRelocationsTy Constant::getRelocationInfo() const { | |
279 | if (const GlobalValue *GV = dyn_cast<GlobalValue>(this)) { | |
280 | if (GV->hasLocalLinkage() || GV->hasHiddenVisibility()) | |
281 | return LocalRelocation; // Local to this file/library. | |
282 | return GlobalRelocations; // Global reference. | |
283 | } | |
284 | ||
285 | if (const BlockAddress *BA = dyn_cast<BlockAddress>(this)) | |
286 | return BA->getFunction()->getRelocationInfo(); | |
287 | ||
288 | // While raw uses of blockaddress need to be relocated, differences between | |
289 | // two of them don't when they are for labels in the same function. This is a | |
290 | // common idiom when creating a table for the indirect goto extension, so we | |
291 | // handle it efficiently here. | |
292 | if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(this)) | |
293 | if (CE->getOpcode() == Instruction::Sub) { | |
294 | ConstantExpr *LHS = dyn_cast<ConstantExpr>(CE->getOperand(0)); | |
295 | ConstantExpr *RHS = dyn_cast<ConstantExpr>(CE->getOperand(1)); | |
296 | if (LHS && RHS && | |
297 | LHS->getOpcode() == Instruction::PtrToInt && | |
298 | RHS->getOpcode() == Instruction::PtrToInt && | |
299 | isa<BlockAddress>(LHS->getOperand(0)) && | |
300 | isa<BlockAddress>(RHS->getOperand(0)) && | |
301 | cast<BlockAddress>(LHS->getOperand(0))->getFunction() == | |
302 | cast<BlockAddress>(RHS->getOperand(0))->getFunction()) | |
303 | return NoRelocation; | |
304 | } | |
305 | ||
306 | PossibleRelocationsTy Result = NoRelocation; | |
307 | for (unsigned i = 0, e = getNumOperands(); i != e; ++i) | |
308 | Result = std::max(Result, | |
309 | cast<Constant>(getOperand(i))->getRelocationInfo()); | |
310 | ||
311 | return Result; | |
312 | } | |
313 | ||
314 | /// removeDeadUsersOfConstant - If the specified constantexpr is dead, remove | |
315 | /// it. This involves recursively eliminating any dead users of the | |
316 | /// constantexpr. | |
317 | static bool removeDeadUsersOfConstant(const Constant *C) { | |
318 | if (isa<GlobalValue>(C)) return false; // Cannot remove this | |
319 | ||
320 | while (!C->use_empty()) { | |
321 | const Constant *User = dyn_cast<Constant>(C->use_back()); | |
322 | if (!User) return false; // Non-constant usage; | |
323 | if (!removeDeadUsersOfConstant(User)) | |
324 | return false; // Constant wasn't dead | |
325 | } | |
326 | ||
327 | const_cast<Constant*>(C)->destroyConstant(); | |
328 | return true; | |
329 | } | |
330 | ||
331 | ||
332 | /// removeDeadConstantUsers - If there are any dead constant users dangling | |
333 | /// off of this constant, remove them. This method is useful for clients | |
334 | /// that want to check to see if a global is unused, but don't want to deal | |
335 | /// with potentially dead constants hanging off of the globals. | |
336 | void Constant::removeDeadConstantUsers() const { | |
337 | Value::const_use_iterator I = use_begin(), E = use_end(); | |
338 | Value::const_use_iterator LastNonDeadUser = E; | |
339 | while (I != E) { | |
340 | const Constant *User = dyn_cast<Constant>(*I); | |
341 | if (User == 0) { | |
342 | LastNonDeadUser = I; | |
343 | ++I; | |
344 | continue; | |
345 | } | |
346 | ||
347 | if (!removeDeadUsersOfConstant(User)) { | |
348 | // If the constant wasn't dead, remember that this was the last live use | |
349 | // and move on to the next constant. | |
350 | LastNonDeadUser = I; | |
351 | ++I; | |
352 | continue; | |
353 | } | |
354 | ||
355 | // If the constant was dead, then the iterator is invalidated. | |
356 | if (LastNonDeadUser == E) { | |
357 | I = use_begin(); | |
358 | if (I == E) break; | |
359 | } else { | |
360 | I = LastNonDeadUser; | |
361 | ++I; | |
362 | } | |
363 | } | |
364 | } | |
365 | ||
366 | ||
367 | ||
368 | //===----------------------------------------------------------------------===// | |
369 | // ConstantInt | |
370 | //===----------------------------------------------------------------------===// | |
371 | ||
372 | void ConstantInt::anchor() { } | |
373 | ||
374 | ConstantInt::ConstantInt(IntegerType *Ty, const APInt& V) | |
375 | : Constant(Ty, ConstantIntVal, 0, 0), Val(V) { | |
376 | assert(V.getBitWidth() == Ty->getBitWidth() && "Invalid constant for type"); | |
377 | } | |
378 | ||
379 | ConstantInt *ConstantInt::getTrue(LLVMContext &Context) { | |
380 | LLVMContextImpl *pImpl = Context.pImpl; | |
381 | if (!pImpl->TheTrueVal) | |
382 | pImpl->TheTrueVal = ConstantInt::get(Type::getInt1Ty(Context), 1); | |
383 | return pImpl->TheTrueVal; | |
384 | } | |
385 | ||
386 | ConstantInt *ConstantInt::getFalse(LLVMContext &Context) { | |
387 | LLVMContextImpl *pImpl = Context.pImpl; | |
388 | if (!pImpl->TheFalseVal) | |
389 | pImpl->TheFalseVal = ConstantInt::get(Type::getInt1Ty(Context), 0); | |
390 | return pImpl->TheFalseVal; | |
391 | } | |
392 | ||
393 | Constant *ConstantInt::getTrue(Type *Ty) { | |
394 | VectorType *VTy = dyn_cast<VectorType>(Ty); | |
395 | if (!VTy) { | |
396 | assert(Ty->isIntegerTy(1) && "True must be i1 or vector of i1."); | |
397 | return ConstantInt::getTrue(Ty->getContext()); | |
398 | } | |
399 | assert(VTy->getElementType()->isIntegerTy(1) && | |
400 | "True must be vector of i1 or i1."); | |
401 | return ConstantVector::getSplat(VTy->getNumElements(), | |
402 | ConstantInt::getTrue(Ty->getContext())); | |
403 | } | |
404 | ||
405 | Constant *ConstantInt::getFalse(Type *Ty) { | |
406 | VectorType *VTy = dyn_cast<VectorType>(Ty); | |
407 | if (!VTy) { | |
408 | assert(Ty->isIntegerTy(1) && "False must be i1 or vector of i1."); | |
409 | return ConstantInt::getFalse(Ty->getContext()); | |
410 | } | |
411 | assert(VTy->getElementType()->isIntegerTy(1) && | |
412 | "False must be vector of i1 or i1."); | |
413 | return ConstantVector::getSplat(VTy->getNumElements(), | |
414 | ConstantInt::getFalse(Ty->getContext())); | |
415 | } | |
416 | ||
417 | ||
418 | // Get a ConstantInt from an APInt. Note that the value stored in the DenseMap | |
419 | // as the key, is a DenseMapAPIntKeyInfo::KeyTy which has provided the | |
420 | // operator== and operator!= to ensure that the DenseMap doesn't attempt to | |
421 | // compare APInt's of different widths, which would violate an APInt class | |
422 | // invariant which generates an assertion. | |
423 | ConstantInt *ConstantInt::get(LLVMContext &Context, const APInt &V) { | |
424 | // Get the corresponding integer type for the bit width of the value. | |
425 | IntegerType *ITy = IntegerType::get(Context, V.getBitWidth()); | |
426 | // get an existing value or the insertion position | |
427 | DenseMapAPIntKeyInfo::KeyTy Key(V, ITy); | |
428 | ConstantInt *&Slot = Context.pImpl->IntConstants[Key]; | |
429 | if (!Slot) Slot = new ConstantInt(ITy, V); | |
430 | return Slot; | |
431 | } | |
432 | ||
433 | Constant *ConstantInt::get(Type *Ty, uint64_t V, bool isSigned) { | |
434 | Constant *C = get(cast<IntegerType>(Ty->getScalarType()), V, isSigned); | |
435 | ||
436 | // For vectors, broadcast the value. | |
437 | if (VectorType *VTy = dyn_cast<VectorType>(Ty)) | |
438 | return ConstantVector::getSplat(VTy->getNumElements(), C); | |
439 | ||
440 | return C; | |
441 | } | |
442 | ||
443 | ConstantInt *ConstantInt::get(IntegerType *Ty, uint64_t V, | |
444 | bool isSigned) { | |
445 | return get(Ty->getContext(), APInt(Ty->getBitWidth(), V, isSigned)); | |
446 | } | |
447 | ||
448 | ConstantInt *ConstantInt::getSigned(IntegerType *Ty, int64_t V) { | |
449 | return get(Ty, V, true); | |
450 | } | |
451 | ||
452 | Constant *ConstantInt::getSigned(Type *Ty, int64_t V) { | |
453 | return get(Ty, V, true); | |
454 | } | |
455 | ||
456 | Constant *ConstantInt::get(Type *Ty, const APInt& V) { | |
457 | ConstantInt *C = get(Ty->getContext(), V); | |
458 | assert(C->getType() == Ty->getScalarType() && | |
459 | "ConstantInt type doesn't match the type implied by its value!"); | |
460 | ||
461 | // For vectors, broadcast the value. | |
462 | if (VectorType *VTy = dyn_cast<VectorType>(Ty)) | |
463 | return ConstantVector::getSplat(VTy->getNumElements(), C); | |
464 | ||
465 | return C; | |
466 | } | |
467 | ||
468 | ConstantInt *ConstantInt::get(IntegerType* Ty, StringRef Str, | |
469 | uint8_t radix) { | |
470 | return get(Ty->getContext(), APInt(Ty->getBitWidth(), Str, radix)); | |
471 | } | |
472 | ||
473 | //===----------------------------------------------------------------------===// | |
474 | // ConstantFP | |
475 | //===----------------------------------------------------------------------===// | |
476 | ||
477 | static const fltSemantics *TypeToFloatSemantics(Type *Ty) { | |
478 | if (Ty->isHalfTy()) | |
479 | return &APFloat::IEEEhalf; | |
480 | if (Ty->isFloatTy()) | |
481 | return &APFloat::IEEEsingle; | |
482 | if (Ty->isDoubleTy()) | |
483 | return &APFloat::IEEEdouble; | |
484 | if (Ty->isX86_FP80Ty()) | |
485 | return &APFloat::x87DoubleExtended; | |
486 | else if (Ty->isFP128Ty()) | |
487 | return &APFloat::IEEEquad; | |
488 | ||
489 | assert(Ty->isPPC_FP128Ty() && "Unknown FP format"); | |
490 | return &APFloat::PPCDoubleDouble; | |
491 | } | |
492 | ||
493 | void ConstantFP::anchor() { } | |
494 | ||
495 | /// get() - This returns a constant fp for the specified value in the | |
496 | /// specified type. This should only be used for simple constant values like | |
497 | /// 2.0/1.0 etc, that are known-valid both as double and as the target format. | |
498 | Constant *ConstantFP::get(Type *Ty, double V) { | |
499 | LLVMContext &Context = Ty->getContext(); | |
500 | ||
501 | APFloat FV(V); | |
502 | bool ignored; | |
503 | FV.convert(*TypeToFloatSemantics(Ty->getScalarType()), | |
504 | APFloat::rmNearestTiesToEven, &ignored); | |
505 | Constant *C = get(Context, FV); | |
506 | ||
507 | // For vectors, broadcast the value. | |
508 | if (VectorType *VTy = dyn_cast<VectorType>(Ty)) | |
509 | return ConstantVector::getSplat(VTy->getNumElements(), C); | |
510 | ||
511 | return C; | |
512 | } | |
513 | ||
514 | ||
515 | Constant *ConstantFP::get(Type *Ty, StringRef Str) { | |
516 | LLVMContext &Context = Ty->getContext(); | |
517 | ||
518 | APFloat FV(*TypeToFloatSemantics(Ty->getScalarType()), Str); | |
519 | Constant *C = get(Context, FV); | |
520 | ||
521 | // For vectors, broadcast the value. | |
522 | if (VectorType *VTy = dyn_cast<VectorType>(Ty)) | |
523 | return ConstantVector::getSplat(VTy->getNumElements(), C); | |
524 | ||
525 | return C; | |
526 | } | |
527 | ||
528 | ||
529 | ConstantFP *ConstantFP::getNegativeZero(Type *Ty) { | |
530 | LLVMContext &Context = Ty->getContext(); | |
531 | APFloat apf = cast<ConstantFP>(Constant::getNullValue(Ty))->getValueAPF(); | |
532 | apf.changeSign(); | |
533 | return get(Context, apf); | |
534 | } | |
535 | ||
536 | ||
537 | Constant *ConstantFP::getZeroValueForNegation(Type *Ty) { | |
538 | Type *ScalarTy = Ty->getScalarType(); | |
539 | if (ScalarTy->isFloatingPointTy()) { | |
540 | Constant *C = getNegativeZero(ScalarTy); | |
541 | if (VectorType *VTy = dyn_cast<VectorType>(Ty)) | |
542 | return ConstantVector::getSplat(VTy->getNumElements(), C); | |
543 | return C; | |
544 | } | |
545 | ||
546 | return Constant::getNullValue(Ty); | |
547 | } | |
548 | ||
549 | ||
550 | // ConstantFP accessors. | |
551 | ConstantFP* ConstantFP::get(LLVMContext &Context, const APFloat& V) { | |
552 | DenseMapAPFloatKeyInfo::KeyTy Key(V); | |
553 | ||
554 | LLVMContextImpl* pImpl = Context.pImpl; | |
555 | ||
556 | ConstantFP *&Slot = pImpl->FPConstants[Key]; | |
557 | ||
558 | if (!Slot) { | |
559 | Type *Ty; | |
560 | if (&V.getSemantics() == &APFloat::IEEEhalf) | |
561 | Ty = Type::getHalfTy(Context); | |
562 | else if (&V.getSemantics() == &APFloat::IEEEsingle) | |
563 | Ty = Type::getFloatTy(Context); | |
564 | else if (&V.getSemantics() == &APFloat::IEEEdouble) | |
565 | Ty = Type::getDoubleTy(Context); | |
566 | else if (&V.getSemantics() == &APFloat::x87DoubleExtended) | |
567 | Ty = Type::getX86_FP80Ty(Context); | |
568 | else if (&V.getSemantics() == &APFloat::IEEEquad) | |
569 | Ty = Type::getFP128Ty(Context); | |
570 | else { | |
571 | assert(&V.getSemantics() == &APFloat::PPCDoubleDouble && | |
572 | "Unknown FP format"); | |
573 | Ty = Type::getPPC_FP128Ty(Context); | |
574 | } | |
575 | Slot = new ConstantFP(Ty, V); | |
576 | } | |
577 | ||
578 | return Slot; | |
579 | } | |
580 | ||
581 | ConstantFP *ConstantFP::getInfinity(Type *Ty, bool Negative) { | |
582 | const fltSemantics &Semantics = *TypeToFloatSemantics(Ty); | |
583 | return ConstantFP::get(Ty->getContext(), | |
584 | APFloat::getInf(Semantics, Negative)); | |
585 | } | |
586 | ||
587 | ConstantFP::ConstantFP(Type *Ty, const APFloat& V) | |
588 | : Constant(Ty, ConstantFPVal, 0, 0), Val(V) { | |
589 | assert(&V.getSemantics() == TypeToFloatSemantics(Ty) && | |
590 | "FP type Mismatch"); | |
591 | } | |
592 | ||
593 | bool ConstantFP::isExactlyValue(const APFloat &V) const { | |
594 | return Val.bitwiseIsEqual(V); | |
595 | } | |
596 | ||
597 | //===----------------------------------------------------------------------===// | |
598 | // ConstantAggregateZero Implementation | |
599 | //===----------------------------------------------------------------------===// | |
600 | ||
601 | /// getSequentialElement - If this CAZ has array or vector type, return a zero | |
602 | /// with the right element type. | |
603 | Constant *ConstantAggregateZero::getSequentialElement() const { | |
604 | return Constant::getNullValue(getType()->getSequentialElementType()); | |
605 | } | |
606 | ||
607 | /// getStructElement - If this CAZ has struct type, return a zero with the | |
608 | /// right element type for the specified element. | |
609 | Constant *ConstantAggregateZero::getStructElement(unsigned Elt) const { | |
610 | return Constant::getNullValue(getType()->getStructElementType(Elt)); | |
611 | } | |
612 | ||
613 | /// getElementValue - Return a zero of the right value for the specified GEP | |
614 | /// index if we can, otherwise return null (e.g. if C is a ConstantExpr). | |
615 | Constant *ConstantAggregateZero::getElementValue(Constant *C) const { | |
616 | if (isa<SequentialType>(getType())) | |
617 | return getSequentialElement(); | |
618 | return getStructElement(cast<ConstantInt>(C)->getZExtValue()); | |
619 | } | |
620 | ||
621 | /// getElementValue - Return a zero of the right value for the specified GEP | |
622 | /// index. | |
623 | Constant *ConstantAggregateZero::getElementValue(unsigned Idx) const { | |
624 | if (isa<SequentialType>(getType())) | |
625 | return getSequentialElement(); | |
626 | return getStructElement(Idx); | |
627 | } | |
628 | ||
629 | ||
630 | //===----------------------------------------------------------------------===// | |
631 | // UndefValue Implementation | |
632 | //===----------------------------------------------------------------------===// | |
633 | ||
634 | /// getSequentialElement - If this undef has array or vector type, return an | |
635 | /// undef with the right element type. | |
636 | UndefValue *UndefValue::getSequentialElement() const { | |
637 | return UndefValue::get(getType()->getSequentialElementType()); | |
638 | } | |
639 | ||
640 | /// getStructElement - If this undef has struct type, return a zero with the | |
641 | /// right element type for the specified element. | |
642 | UndefValue *UndefValue::getStructElement(unsigned Elt) const { | |
643 | return UndefValue::get(getType()->getStructElementType(Elt)); | |
644 | } | |
645 | ||
646 | /// getElementValue - Return an undef of the right value for the specified GEP | |
647 | /// index if we can, otherwise return null (e.g. if C is a ConstantExpr). | |
648 | UndefValue *UndefValue::getElementValue(Constant *C) const { | |
649 | if (isa<SequentialType>(getType())) | |
650 | return getSequentialElement(); | |
651 | return getStructElement(cast<ConstantInt>(C)->getZExtValue()); | |
652 | } | |
653 | ||
654 | /// getElementValue - Return an undef of the right value for the specified GEP | |
655 | /// index. | |
656 | UndefValue *UndefValue::getElementValue(unsigned Idx) const { | |
657 | if (isa<SequentialType>(getType())) | |
658 | return getSequentialElement(); | |
659 | return getStructElement(Idx); | |
660 | } | |
661 | ||
662 | ||
663 | ||
664 | //===----------------------------------------------------------------------===// | |
665 | // ConstantXXX Classes | |
666 | //===----------------------------------------------------------------------===// | |
667 | ||
668 | template <typename ItTy, typename EltTy> | |
669 | static bool rangeOnlyContains(ItTy Start, ItTy End, EltTy Elt) { | |
670 | for (; Start != End; ++Start) | |
671 | if (*Start != Elt) | |
672 | return false; | |
673 | return true; | |
674 | } | |
675 | ||
676 | ConstantArray::ConstantArray(ArrayType *T, ArrayRef<Constant *> V) | |
677 | : Constant(T, ConstantArrayVal, | |
678 | OperandTraits<ConstantArray>::op_end(this) - V.size(), | |
679 | V.size()) { | |
680 | assert(V.size() == T->getNumElements() && | |
681 | "Invalid initializer vector for constant array"); | |
682 | for (unsigned i = 0, e = V.size(); i != e; ++i) | |
683 | assert(V[i]->getType() == T->getElementType() && | |
684 | "Initializer for array element doesn't match array element type!"); | |
685 | std::copy(V.begin(), V.end(), op_begin()); | |
686 | } | |
687 | ||
688 | Constant *ConstantArray::get(ArrayType *Ty, ArrayRef<Constant*> V) { | |
689 | // Empty arrays are canonicalized to ConstantAggregateZero. | |
690 | if (V.empty()) | |
691 | return ConstantAggregateZero::get(Ty); | |
692 | ||
693 | for (unsigned i = 0, e = V.size(); i != e; ++i) { | |
694 | assert(V[i]->getType() == Ty->getElementType() && | |
695 | "Wrong type in array element initializer"); | |
696 | } | |
697 | LLVMContextImpl *pImpl = Ty->getContext().pImpl; | |
698 | ||
699 | // If this is an all-zero array, return a ConstantAggregateZero object. If | |
700 | // all undef, return an UndefValue, if "all simple", then return a | |
701 | // ConstantDataArray. | |
702 | Constant *C = V[0]; | |
703 | if (isa<UndefValue>(C) && rangeOnlyContains(V.begin(), V.end(), C)) | |
704 | return UndefValue::get(Ty); | |
705 | ||
706 | if (C->isNullValue() && rangeOnlyContains(V.begin(), V.end(), C)) | |
707 | return ConstantAggregateZero::get(Ty); | |
708 | ||
709 | // Check to see if all of the elements are ConstantFP or ConstantInt and if | |
710 | // the element type is compatible with ConstantDataVector. If so, use it. | |
711 | if (ConstantDataSequential::isElementTypeCompatible(C->getType())) { | |
712 | // We speculatively build the elements here even if it turns out that there | |
713 | // is a constantexpr or something else weird in the array, since it is so | |
714 | // uncommon for that to happen. | |
715 | if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) { | |
716 | if (CI->getType()->isIntegerTy(8)) { | |
717 | SmallVector<uint8_t, 16> Elts; | |
718 | for (unsigned i = 0, e = V.size(); i != e; ++i) | |
719 | if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i])) | |
720 | Elts.push_back(CI->getZExtValue()); | |
721 | else | |
722 | break; | |
723 | if (Elts.size() == V.size()) | |
724 | return ConstantDataArray::get(C->getContext(), Elts); | |
725 | } else if (CI->getType()->isIntegerTy(16)) { | |
726 | SmallVector<uint16_t, 16> Elts; | |
727 | for (unsigned i = 0, e = V.size(); i != e; ++i) | |
728 | if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i])) | |
729 | Elts.push_back(CI->getZExtValue()); | |
730 | else | |
731 | break; | |
732 | if (Elts.size() == V.size()) | |
733 | return ConstantDataArray::get(C->getContext(), Elts); | |
734 | } else if (CI->getType()->isIntegerTy(32)) { | |
735 | SmallVector<uint32_t, 16> Elts; | |
736 | for (unsigned i = 0, e = V.size(); i != e; ++i) | |
737 | if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i])) | |
738 | Elts.push_back(CI->getZExtValue()); | |
739 | else | |
740 | break; | |
741 | if (Elts.size() == V.size()) | |
742 | return ConstantDataArray::get(C->getContext(), Elts); | |
743 | } else if (CI->getType()->isIntegerTy(64)) { | |
744 | SmallVector<uint64_t, 16> Elts; | |
745 | for (unsigned i = 0, e = V.size(); i != e; ++i) | |
746 | if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i])) | |
747 | Elts.push_back(CI->getZExtValue()); | |
748 | else | |
749 | break; | |
750 | if (Elts.size() == V.size()) | |
751 | return ConstantDataArray::get(C->getContext(), Elts); | |
752 | } | |
753 | } | |
754 | ||
755 | if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) { | |
756 | if (CFP->getType()->isFloatTy()) { | |
757 | SmallVector<float, 16> Elts; | |
758 | for (unsigned i = 0, e = V.size(); i != e; ++i) | |
759 | if (ConstantFP *CFP = dyn_cast<ConstantFP>(V[i])) | |
760 | Elts.push_back(CFP->getValueAPF().convertToFloat()); | |
761 | else | |
762 | break; | |
763 | if (Elts.size() == V.size()) | |
764 | return ConstantDataArray::get(C->getContext(), Elts); | |
765 | } else if (CFP->getType()->isDoubleTy()) { | |
766 | SmallVector<double, 16> Elts; | |
767 | for (unsigned i = 0, e = V.size(); i != e; ++i) | |
768 | if (ConstantFP *CFP = dyn_cast<ConstantFP>(V[i])) | |
769 | Elts.push_back(CFP->getValueAPF().convertToDouble()); | |
770 | else | |
771 | break; | |
772 | if (Elts.size() == V.size()) | |
773 | return ConstantDataArray::get(C->getContext(), Elts); | |
774 | } | |
775 | } | |
776 | } | |
777 | ||
778 | // Otherwise, we really do want to create a ConstantArray. | |
779 | return pImpl->ArrayConstants.getOrCreate(Ty, V); | |
780 | } | |
781 | ||
782 | /// getTypeForElements - Return an anonymous struct type to use for a constant | |
783 | /// with the specified set of elements. The list must not be empty. | |
784 | StructType *ConstantStruct::getTypeForElements(LLVMContext &Context, | |
785 | ArrayRef<Constant*> V, | |
786 | bool Packed) { | |
787 | unsigned VecSize = V.size(); | |
788 | SmallVector<Type*, 16> EltTypes(VecSize); | |
789 | for (unsigned i = 0; i != VecSize; ++i) | |
790 | EltTypes[i] = V[i]->getType(); | |
791 | ||
792 | return StructType::get(Context, EltTypes, Packed); | |
793 | } | |
794 | ||
795 | ||
796 | StructType *ConstantStruct::getTypeForElements(ArrayRef<Constant*> V, | |
797 | bool Packed) { | |
798 | assert(!V.empty() && | |
799 | "ConstantStruct::getTypeForElements cannot be called on empty list"); | |
800 | return getTypeForElements(V[0]->getContext(), V, Packed); | |
801 | } | |
802 | ||
803 | ||
804 | ConstantStruct::ConstantStruct(StructType *T, ArrayRef<Constant *> V) | |
805 | : Constant(T, ConstantStructVal, | |
806 | OperandTraits<ConstantStruct>::op_end(this) - V.size(), | |
807 | V.size()) { | |
808 | assert(V.size() == T->getNumElements() && | |
809 | "Invalid initializer vector for constant structure"); | |
810 | for (unsigned i = 0, e = V.size(); i != e; ++i) | |
811 | assert((T->isOpaque() || V[i]->getType() == T->getElementType(i)) && | |
812 | "Initializer for struct element doesn't match struct element type!"); | |
813 | std::copy(V.begin(), V.end(), op_begin()); | |
814 | } | |
815 | ||
816 | // ConstantStruct accessors. | |
817 | Constant *ConstantStruct::get(StructType *ST, ArrayRef<Constant*> V) { | |
818 | assert((ST->isOpaque() || ST->getNumElements() == V.size()) && | |
819 | "Incorrect # elements specified to ConstantStruct::get"); | |
820 | ||
821 | // Create a ConstantAggregateZero value if all elements are zeros. | |
822 | bool isZero = true; | |
823 | bool isUndef = false; | |
824 | ||
825 | if (!V.empty()) { | |
826 | isUndef = isa<UndefValue>(V[0]); | |
827 | isZero = V[0]->isNullValue(); | |
828 | if (isUndef || isZero) { | |
829 | for (unsigned i = 0, e = V.size(); i != e; ++i) { | |
830 | if (!V[i]->isNullValue()) | |
831 | isZero = false; | |
832 | if (!isa<UndefValue>(V[i])) | |
833 | isUndef = false; | |
834 | } | |
835 | } | |
836 | } | |
837 | if (isZero) | |
838 | return ConstantAggregateZero::get(ST); | |
839 | if (isUndef) | |
840 | return UndefValue::get(ST); | |
841 | ||
842 | return ST->getContext().pImpl->StructConstants.getOrCreate(ST, V); | |
843 | } | |
844 | ||
845 | Constant *ConstantStruct::get(StructType *T, ...) { | |
846 | va_list ap; | |
847 | SmallVector<Constant*, 8> Values; | |
848 | va_start(ap, T); | |
849 | while (Constant *Val = va_arg(ap, llvm::Constant*)) | |
850 | Values.push_back(Val); | |
851 | va_end(ap); | |
852 | return get(T, Values); | |
853 | } | |
854 | ||
855 | ConstantVector::ConstantVector(VectorType *T, ArrayRef<Constant *> V) | |
856 | : Constant(T, ConstantVectorVal, | |
857 | OperandTraits<ConstantVector>::op_end(this) - V.size(), | |
858 | V.size()) { | |
859 | for (size_t i = 0, e = V.size(); i != e; i++) | |
860 | assert(V[i]->getType() == T->getElementType() && | |
861 | "Initializer for vector element doesn't match vector element type!"); | |
862 | std::copy(V.begin(), V.end(), op_begin()); | |
863 | } | |
864 | ||
865 | // ConstantVector accessors. | |
866 | Constant *ConstantVector::get(ArrayRef<Constant*> V) { | |
867 | assert(!V.empty() && "Vectors can't be empty"); | |
868 | VectorType *T = VectorType::get(V.front()->getType(), V.size()); | |
869 | LLVMContextImpl *pImpl = T->getContext().pImpl; | |
870 | ||
871 | // If this is an all-undef or all-zero vector, return a | |
872 | // ConstantAggregateZero or UndefValue. | |
873 | Constant *C = V[0]; | |
874 | bool isZero = C->isNullValue(); | |
875 | bool isUndef = isa<UndefValue>(C); | |
876 | ||
877 | if (isZero || isUndef) { | |
878 | for (unsigned i = 1, e = V.size(); i != e; ++i) | |
879 | if (V[i] != C) { | |
880 | isZero = isUndef = false; | |
881 | break; | |
882 | } | |
883 | } | |
884 | ||
885 | if (isZero) | |
886 | return ConstantAggregateZero::get(T); | |
887 | if (isUndef) | |
888 | return UndefValue::get(T); | |
889 | ||
890 | // Check to see if all of the elements are ConstantFP or ConstantInt and if | |
891 | // the element type is compatible with ConstantDataVector. If so, use it. | |
892 | if (ConstantDataSequential::isElementTypeCompatible(C->getType())) { | |
893 | // We speculatively build the elements here even if it turns out that there | |
894 | // is a constantexpr or something else weird in the array, since it is so | |
895 | // uncommon for that to happen. | |
896 | if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) { | |
897 | if (CI->getType()->isIntegerTy(8)) { | |
898 | SmallVector<uint8_t, 16> Elts; | |
899 | for (unsigned i = 0, e = V.size(); i != e; ++i) | |
900 | if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i])) | |
901 | Elts.push_back(CI->getZExtValue()); | |
902 | else | |
903 | break; | |
904 | if (Elts.size() == V.size()) | |
905 | return ConstantDataVector::get(C->getContext(), Elts); | |
906 | } else if (CI->getType()->isIntegerTy(16)) { | |
907 | SmallVector<uint16_t, 16> Elts; | |
908 | for (unsigned i = 0, e = V.size(); i != e; ++i) | |
909 | if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i])) | |
910 | Elts.push_back(CI->getZExtValue()); | |
911 | else | |
912 | break; | |
913 | if (Elts.size() == V.size()) | |
914 | return ConstantDataVector::get(C->getContext(), Elts); | |
915 | } else if (CI->getType()->isIntegerTy(32)) { | |
916 | SmallVector<uint32_t, 16> Elts; | |
917 | for (unsigned i = 0, e = V.size(); i != e; ++i) | |
918 | if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i])) | |
919 | Elts.push_back(CI->getZExtValue()); | |
920 | else | |
921 | break; | |
922 | if (Elts.size() == V.size()) | |
923 | return ConstantDataVector::get(C->getContext(), Elts); | |
924 | } else if (CI->getType()->isIntegerTy(64)) { | |
925 | SmallVector<uint64_t, 16> Elts; | |
926 | for (unsigned i = 0, e = V.size(); i != e; ++i) | |
927 | if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i])) | |
928 | Elts.push_back(CI->getZExtValue()); | |
929 | else | |
930 | break; | |
931 | if (Elts.size() == V.size()) | |
932 | return ConstantDataVector::get(C->getContext(), Elts); | |
933 | } | |
934 | } | |
935 | ||
936 | if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) { | |
937 | if (CFP->getType()->isFloatTy()) { | |
938 | SmallVector<float, 16> Elts; | |
939 | for (unsigned i = 0, e = V.size(); i != e; ++i) | |
940 | if (ConstantFP *CFP = dyn_cast<ConstantFP>(V[i])) | |
941 | Elts.push_back(CFP->getValueAPF().convertToFloat()); | |
942 | else | |
943 | break; | |
944 | if (Elts.size() == V.size()) | |
945 | return ConstantDataVector::get(C->getContext(), Elts); | |
946 | } else if (CFP->getType()->isDoubleTy()) { | |
947 | SmallVector<double, 16> Elts; | |
948 | for (unsigned i = 0, e = V.size(); i != e; ++i) | |
949 | if (ConstantFP *CFP = dyn_cast<ConstantFP>(V[i])) | |
950 | Elts.push_back(CFP->getValueAPF().convertToDouble()); | |
951 | else | |
952 | break; | |
953 | if (Elts.size() == V.size()) | |
954 | return ConstantDataVector::get(C->getContext(), Elts); | |
955 | } | |
956 | } | |
957 | } | |
958 | ||
959 | // Otherwise, the element type isn't compatible with ConstantDataVector, or | |
960 | // the operand list constants a ConstantExpr or something else strange. | |
961 | return pImpl->VectorConstants.getOrCreate(T, V); | |
962 | } | |
963 | ||
964 | Constant *ConstantVector::getSplat(unsigned NumElts, Constant *V) { | |
965 | // If this splat is compatible with ConstantDataVector, use it instead of | |
966 | // ConstantVector. | |
967 | if ((isa<ConstantFP>(V) || isa<ConstantInt>(V)) && | |
968 | ConstantDataSequential::isElementTypeCompatible(V->getType())) | |
969 | return ConstantDataVector::getSplat(NumElts, V); | |
970 | ||
971 | SmallVector<Constant*, 32> Elts(NumElts, V); | |
972 | return get(Elts); | |
973 | } | |
974 | ||
975 | ||
976 | // Utility function for determining if a ConstantExpr is a CastOp or not. This | |
977 | // can't be inline because we don't want to #include Instruction.h into | |
978 | // Constant.h | |
979 | bool ConstantExpr::isCast() const { | |
980 | return Instruction::isCast(getOpcode()); | |
981 | } | |
982 | ||
983 | bool ConstantExpr::isCompare() const { | |
984 | return getOpcode() == Instruction::ICmp || getOpcode() == Instruction::FCmp; | |
985 | } | |
986 | ||
987 | bool ConstantExpr::isGEPWithNoNotionalOverIndexing() const { | |
988 | if (getOpcode() != Instruction::GetElementPtr) return false; | |
989 | ||
990 | gep_type_iterator GEPI = gep_type_begin(this), E = gep_type_end(this); | |
991 | User::const_op_iterator OI = llvm::next(this->op_begin()); | |
992 | ||
993 | // Skip the first index, as it has no static limit. | |
994 | ++GEPI; | |
995 | ++OI; | |
996 | ||
997 | // The remaining indices must be compile-time known integers within the | |
998 | // bounds of the corresponding notional static array types. | |
999 | for (; GEPI != E; ++GEPI, ++OI) { | |
1000 | ConstantInt *CI = dyn_cast<ConstantInt>(*OI); | |
1001 | if (!CI) return false; | |
1002 | if (ArrayType *ATy = dyn_cast<ArrayType>(*GEPI)) | |
1003 | if (CI->getValue().getActiveBits() > 64 || | |
1004 | CI->getZExtValue() >= ATy->getNumElements()) | |
1005 | return false; | |
1006 | } | |
1007 | ||
1008 | // All the indices checked out. | |
1009 | return true; | |
1010 | } | |
1011 | ||
1012 | bool ConstantExpr::hasIndices() const { | |
1013 | return getOpcode() == Instruction::ExtractValue || | |
1014 | getOpcode() == Instruction::InsertValue; | |
1015 | } | |
1016 | ||
1017 | ArrayRef<unsigned> ConstantExpr::getIndices() const { | |
1018 | if (const ExtractValueConstantExpr *EVCE = | |
1019 | dyn_cast<ExtractValueConstantExpr>(this)) | |
1020 | return EVCE->Indices; | |
1021 | ||
1022 | return cast<InsertValueConstantExpr>(this)->Indices; | |
1023 | } | |
1024 | ||
1025 | unsigned ConstantExpr::getPredicate() const { | |
1026 | assert(isCompare()); | |
1027 | return ((const CompareConstantExpr*)this)->predicate; | |
1028 | } | |
1029 | ||
1030 | /// getWithOperandReplaced - Return a constant expression identical to this | |
1031 | /// one, but with the specified operand set to the specified value. | |
1032 | Constant * | |
1033 | ConstantExpr::getWithOperandReplaced(unsigned OpNo, Constant *Op) const { | |
1034 | assert(Op->getType() == getOperand(OpNo)->getType() && | |
1035 | "Replacing operand with value of different type!"); | |
1036 | if (getOperand(OpNo) == Op) | |
1037 | return const_cast<ConstantExpr*>(this); | |
1038 | ||
1039 | SmallVector<Constant*, 8> NewOps; | |
1040 | for (unsigned i = 0, e = getNumOperands(); i != e; ++i) | |
1041 | NewOps.push_back(i == OpNo ? Op : getOperand(i)); | |
1042 | ||
1043 | return getWithOperands(NewOps); | |
1044 | } | |
1045 | ||
1046 | /// getWithOperands - This returns the current constant expression with the | |
1047 | /// operands replaced with the specified values. The specified array must | |
1048 | /// have the same number of operands as our current one. | |
1049 | Constant *ConstantExpr:: | |
1050 | getWithOperands(ArrayRef<Constant*> Ops, Type *Ty) const { | |
1051 | assert(Ops.size() == getNumOperands() && "Operand count mismatch!"); | |
1052 | bool AnyChange = Ty != getType(); | |
1053 | for (unsigned i = 0; i != Ops.size(); ++i) | |
1054 | AnyChange |= Ops[i] != getOperand(i); | |
1055 | ||
1056 | if (!AnyChange) // No operands changed, return self. | |
1057 | return const_cast<ConstantExpr*>(this); | |
1058 | ||
1059 | switch (getOpcode()) { | |
1060 | case Instruction::Trunc: | |
1061 | case Instruction::ZExt: | |
1062 | case Instruction::SExt: | |
1063 | case Instruction::FPTrunc: | |
1064 | case Instruction::FPExt: | |
1065 | case Instruction::UIToFP: | |
1066 | case Instruction::SIToFP: | |
1067 | case Instruction::FPToUI: | |
1068 | case Instruction::FPToSI: | |
1069 | case Instruction::PtrToInt: | |
1070 | case Instruction::IntToPtr: | |
1071 | case Instruction::BitCast: | |
1072 | return ConstantExpr::getCast(getOpcode(), Ops[0], Ty); | |
1073 | case Instruction::Select: | |
1074 | return ConstantExpr::getSelect(Ops[0], Ops[1], Ops[2]); | |
1075 | case Instruction::InsertElement: | |
1076 | return ConstantExpr::getInsertElement(Ops[0], Ops[1], Ops[2]); | |
1077 | case Instruction::ExtractElement: | |
1078 | return ConstantExpr::getExtractElement(Ops[0], Ops[1]); | |
1079 | case Instruction::InsertValue: | |
1080 | return ConstantExpr::getInsertValue(Ops[0], Ops[1], getIndices()); | |
1081 | case Instruction::ExtractValue: | |
1082 | return ConstantExpr::getExtractValue(Ops[0], getIndices()); | |
1083 | case Instruction::ShuffleVector: | |
1084 | return ConstantExpr::getShuffleVector(Ops[0], Ops[1], Ops[2]); | |
1085 | case Instruction::GetElementPtr: | |
1086 | return ConstantExpr::getGetElementPtr(Ops[0], Ops.slice(1), | |
1087 | cast<GEPOperator>(this)->isInBounds()); | |
1088 | case Instruction::ICmp: | |
1089 | case Instruction::FCmp: | |
1090 | return ConstantExpr::getCompare(getPredicate(), Ops[0], Ops[1]); | |
1091 | default: | |
1092 | assert(getNumOperands() == 2 && "Must be binary operator?"); | |
1093 | return ConstantExpr::get(getOpcode(), Ops[0], Ops[1], SubclassOptionalData); | |
1094 | } | |
1095 | } | |
1096 | ||
1097 | ||
1098 | //===----------------------------------------------------------------------===// | |
1099 | // isValueValidForType implementations | |
1100 | ||
1101 | bool ConstantInt::isValueValidForType(Type *Ty, uint64_t Val) { | |
1102 | unsigned NumBits = Ty->getIntegerBitWidth(); // assert okay | |
1103 | if (Ty->isIntegerTy(1)) | |
1104 | return Val == 0 || Val == 1; | |
1105 | if (NumBits >= 64) | |
1106 | return true; // always true, has to fit in largest type | |
1107 | uint64_t Max = (1ll << NumBits) - 1; | |
1108 | return Val <= Max; | |
1109 | } | |
1110 | ||
1111 | bool ConstantInt::isValueValidForType(Type *Ty, int64_t Val) { | |
1112 | unsigned NumBits = Ty->getIntegerBitWidth(); | |
1113 | if (Ty->isIntegerTy(1)) | |
1114 | return Val == 0 || Val == 1 || Val == -1; | |
1115 | if (NumBits >= 64) | |
1116 | return true; // always true, has to fit in largest type | |
1117 | int64_t Min = -(1ll << (NumBits-1)); | |
1118 | int64_t Max = (1ll << (NumBits-1)) - 1; | |
1119 | return (Val >= Min && Val <= Max); | |
1120 | } | |
1121 | ||
1122 | bool ConstantFP::isValueValidForType(Type *Ty, const APFloat& Val) { | |
1123 | // convert modifies in place, so make a copy. | |
1124 | APFloat Val2 = APFloat(Val); | |
1125 | bool losesInfo; | |
1126 | switch (Ty->getTypeID()) { | |
1127 | default: | |
1128 | return false; // These can't be represented as floating point! | |
1129 | ||
1130 | // FIXME rounding mode needs to be more flexible | |
1131 | case Type::HalfTyID: { | |
1132 | if (&Val2.getSemantics() == &APFloat::IEEEhalf) | |
1133 | return true; | |
1134 | Val2.convert(APFloat::IEEEhalf, APFloat::rmNearestTiesToEven, &losesInfo); | |
1135 | return !losesInfo; | |
1136 | } | |
1137 | case Type::FloatTyID: { | |
1138 | if (&Val2.getSemantics() == &APFloat::IEEEsingle) | |
1139 | return true; | |
1140 | Val2.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven, &losesInfo); | |
1141 | return !losesInfo; | |
1142 | } | |
1143 | case Type::DoubleTyID: { | |
1144 | if (&Val2.getSemantics() == &APFloat::IEEEhalf || | |
1145 | &Val2.getSemantics() == &APFloat::IEEEsingle || | |
1146 | &Val2.getSemantics() == &APFloat::IEEEdouble) | |
1147 | return true; | |
1148 | Val2.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo); | |
1149 | return !losesInfo; | |
1150 | } | |
1151 | case Type::X86_FP80TyID: | |
1152 | return &Val2.getSemantics() == &APFloat::IEEEhalf || | |
1153 | &Val2.getSemantics() == &APFloat::IEEEsingle || | |
1154 | &Val2.getSemantics() == &APFloat::IEEEdouble || | |
1155 | &Val2.getSemantics() == &APFloat::x87DoubleExtended; | |
1156 | case Type::FP128TyID: | |
1157 | return &Val2.getSemantics() == &APFloat::IEEEhalf || | |
1158 | &Val2.getSemantics() == &APFloat::IEEEsingle || | |
1159 | &Val2.getSemantics() == &APFloat::IEEEdouble || | |
1160 | &Val2.getSemantics() == &APFloat::IEEEquad; | |
1161 | case Type::PPC_FP128TyID: | |
1162 | return &Val2.getSemantics() == &APFloat::IEEEhalf || | |
1163 | &Val2.getSemantics() == &APFloat::IEEEsingle || | |
1164 | &Val2.getSemantics() == &APFloat::IEEEdouble || | |
1165 | &Val2.getSemantics() == &APFloat::PPCDoubleDouble; | |
1166 | } | |
1167 | } | |
1168 | ||
1169 | ||
1170 | //===----------------------------------------------------------------------===// | |
1171 | // Factory Function Implementation | |
1172 | ||
1173 | ConstantAggregateZero *ConstantAggregateZero::get(Type *Ty) { | |
1174 | assert((Ty->isStructTy() || Ty->isArrayTy() || Ty->isVectorTy()) && | |
1175 | "Cannot create an aggregate zero of non-aggregate type!"); | |
1176 | ||
1177 | ConstantAggregateZero *&Entry = Ty->getContext().pImpl->CAZConstants[Ty]; | |
1178 | if (Entry == 0) | |
1179 | Entry = new ConstantAggregateZero(Ty); | |
1180 | ||
1181 | return Entry; | |
1182 | } | |
1183 | ||
1184 | /// destroyConstant - Remove the constant from the constant table. | |
1185 | /// | |
1186 | void ConstantAggregateZero::destroyConstant() { | |
1187 | getContext().pImpl->CAZConstants.erase(getType()); | |
1188 | destroyConstantImpl(); | |
1189 | } | |
1190 | ||
1191 | /// destroyConstant - Remove the constant from the constant table... | |
1192 | /// | |
1193 | void ConstantArray::destroyConstant() { | |
1194 | getType()->getContext().pImpl->ArrayConstants.remove(this); | |
1195 | destroyConstantImpl(); | |
1196 | } | |
1197 | ||
1198 | ||
1199 | //---- ConstantStruct::get() implementation... | |
1200 | // | |
1201 | ||
1202 | // destroyConstant - Remove the constant from the constant table... | |
1203 | // | |
1204 | void ConstantStruct::destroyConstant() { | |
1205 | getType()->getContext().pImpl->StructConstants.remove(this); | |
1206 | destroyConstantImpl(); | |
1207 | } | |
1208 | ||
1209 | // destroyConstant - Remove the constant from the constant table... | |
1210 | // | |
1211 | void ConstantVector::destroyConstant() { | |
1212 | getType()->getContext().pImpl->VectorConstants.remove(this); | |
1213 | destroyConstantImpl(); | |
1214 | } | |
1215 | ||
1216 | /// getSplatValue - If this is a splat constant, where all of the | |
1217 | /// elements have the same value, return that value. Otherwise return null. | |
1218 | Constant *ConstantVector::getSplatValue() const { | |
1219 | // Check out first element. | |
1220 | Constant *Elt = getOperand(0); | |
1221 | // Then make sure all remaining elements point to the same value. | |
1222 | for (unsigned I = 1, E = getNumOperands(); I < E; ++I) | |
1223 | if (getOperand(I) != Elt) | |
1224 | return 0; | |
1225 | return Elt; | |
1226 | } | |
1227 | ||
1228 | //---- ConstantPointerNull::get() implementation. | |
1229 | // | |
1230 | ||
1231 | ConstantPointerNull *ConstantPointerNull::get(PointerType *Ty) { | |
1232 | ConstantPointerNull *&Entry = Ty->getContext().pImpl->CPNConstants[Ty]; | |
1233 | if (Entry == 0) | |
1234 | Entry = new ConstantPointerNull(Ty); | |
1235 | ||
1236 | return Entry; | |
1237 | } | |
1238 | ||
1239 | // destroyConstant - Remove the constant from the constant table... | |
1240 | // | |
1241 | void ConstantPointerNull::destroyConstant() { | |
1242 | getContext().pImpl->CPNConstants.erase(getType()); | |
1243 | // Free the constant and any dangling references to it. | |
1244 | destroyConstantImpl(); | |
1245 | } | |
1246 | ||
1247 | ||
1248 | //---- UndefValue::get() implementation. | |
1249 | // | |
1250 | ||
1251 | UndefValue *UndefValue::get(Type *Ty) { | |
1252 | UndefValue *&Entry = Ty->getContext().pImpl->UVConstants[Ty]; | |
1253 | if (Entry == 0) | |
1254 | Entry = new UndefValue(Ty); | |
1255 | ||
1256 | return Entry; | |
1257 | } | |
1258 | ||
1259 | // destroyConstant - Remove the constant from the constant table. | |
1260 | // | |
1261 | void UndefValue::destroyConstant() { | |
1262 | // Free the constant and any dangling references to it. | |
1263 | getContext().pImpl->UVConstants.erase(getType()); | |
1264 | destroyConstantImpl(); | |
1265 | } | |
1266 | ||
1267 | //---- BlockAddress::get() implementation. | |
1268 | // | |
1269 | ||
1270 | BlockAddress *BlockAddress::get(BasicBlock *BB) { | |
1271 | assert(BB->getParent() != 0 && "Block must have a parent"); | |
1272 | return get(BB->getParent(), BB); | |
1273 | } | |
1274 | ||
1275 | BlockAddress *BlockAddress::get(Function *F, BasicBlock *BB) { | |
1276 | BlockAddress *&BA = | |
1277 | F->getContext().pImpl->BlockAddresses[std::make_pair(F, BB)]; | |
1278 | if (BA == 0) | |
1279 | BA = new BlockAddress(F, BB); | |
1280 | ||
1281 | assert(BA->getFunction() == F && "Basic block moved between functions"); | |
1282 | return BA; | |
1283 | } | |
1284 | ||
1285 | BlockAddress::BlockAddress(Function *F, BasicBlock *BB) | |
1286 | : Constant(Type::getInt8PtrTy(F->getContext()), Value::BlockAddressVal, | |
1287 | &Op<0>(), 2) { | |
1288 | setOperand(0, F); | |
1289 | setOperand(1, BB); | |
1290 | BB->AdjustBlockAddressRefCount(1); | |
1291 | } | |
1292 | ||
1293 | ||
1294 | // destroyConstant - Remove the constant from the constant table. | |
1295 | // | |
1296 | void BlockAddress::destroyConstant() { | |
1297 | getFunction()->getType()->getContext().pImpl | |
1298 | ->BlockAddresses.erase(std::make_pair(getFunction(), getBasicBlock())); | |
1299 | getBasicBlock()->AdjustBlockAddressRefCount(-1); | |
1300 | destroyConstantImpl(); | |
1301 | } | |
1302 | ||
1303 | void BlockAddress::replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U) { | |
1304 | // This could be replacing either the Basic Block or the Function. In either | |
1305 | // case, we have to remove the map entry. | |
1306 | Function *NewF = getFunction(); | |
1307 | BasicBlock *NewBB = getBasicBlock(); | |
1308 | ||
1309 | if (U == &Op<0>()) | |
1310 | NewF = cast<Function>(To); | |
1311 | else | |
1312 | NewBB = cast<BasicBlock>(To); | |
1313 | ||
1314 | // See if the 'new' entry already exists, if not, just update this in place | |
1315 | // and return early. | |
1316 | BlockAddress *&NewBA = | |
1317 | getContext().pImpl->BlockAddresses[std::make_pair(NewF, NewBB)]; | |
1318 | if (NewBA == 0) { | |
1319 | getBasicBlock()->AdjustBlockAddressRefCount(-1); | |
1320 | ||
1321 | // Remove the old entry, this can't cause the map to rehash (just a | |
1322 | // tombstone will get added). | |
1323 | getContext().pImpl->BlockAddresses.erase(std::make_pair(getFunction(), | |
1324 | getBasicBlock())); | |
1325 | NewBA = this; | |
1326 | setOperand(0, NewF); | |
1327 | setOperand(1, NewBB); | |
1328 | getBasicBlock()->AdjustBlockAddressRefCount(1); | |
1329 | return; | |
1330 | } | |
1331 | ||
1332 | // Otherwise, I do need to replace this with an existing value. | |
1333 | assert(NewBA != this && "I didn't contain From!"); | |
1334 | ||
1335 | // Everyone using this now uses the replacement. | |
1336 | replaceAllUsesWith(NewBA); | |
1337 | ||
1338 | destroyConstant(); | |
1339 | } | |
1340 | ||
1341 | //---- ConstantExpr::get() implementations. | |
1342 | // | |
1343 | ||
1344 | /// This is a utility function to handle folding of casts and lookup of the | |
1345 | /// cast in the ExprConstants map. It is used by the various get* methods below. | |
1346 | static inline Constant *getFoldedCast( | |
1347 | Instruction::CastOps opc, Constant *C, Type *Ty) { | |
1348 | assert(Ty->isFirstClassType() && "Cannot cast to an aggregate type!"); | |
1349 | // Fold a few common cases | |
1350 | if (Constant *FC = ConstantFoldCastInstruction(opc, C, Ty)) | |
1351 | return FC; | |
1352 | ||
1353 | LLVMContextImpl *pImpl = Ty->getContext().pImpl; | |
1354 | ||
1355 | // Look up the constant in the table first to ensure uniqueness | |
1356 | std::vector<Constant*> argVec(1, C); | |
1357 | ExprMapKeyType Key(opc, argVec); | |
1358 | ||
1359 | return pImpl->ExprConstants.getOrCreate(Ty, Key); | |
1360 | } | |
1361 | ||
1362 | Constant *ConstantExpr::getCast(unsigned oc, Constant *C, Type *Ty) { | |
1363 | Instruction::CastOps opc = Instruction::CastOps(oc); | |
1364 | assert(Instruction::isCast(opc) && "opcode out of range"); | |
1365 | assert(C && Ty && "Null arguments to getCast"); | |
1366 | assert(CastInst::castIsValid(opc, C, Ty) && "Invalid constantexpr cast!"); | |
1367 | ||
1368 | switch (opc) { | |
1369 | default: | |
1370 | llvm_unreachable("Invalid cast opcode"); | |
1371 | case Instruction::Trunc: return getTrunc(C, Ty); | |
1372 | case Instruction::ZExt: return getZExt(C, Ty); | |
1373 | case Instruction::SExt: return getSExt(C, Ty); | |
1374 | case Instruction::FPTrunc: return getFPTrunc(C, Ty); | |
1375 | case Instruction::FPExt: return getFPExtend(C, Ty); | |
1376 | case Instruction::UIToFP: return getUIToFP(C, Ty); | |
1377 | case Instruction::SIToFP: return getSIToFP(C, Ty); | |
1378 | case Instruction::FPToUI: return getFPToUI(C, Ty); | |
1379 | case Instruction::FPToSI: return getFPToSI(C, Ty); | |
1380 | case Instruction::PtrToInt: return getPtrToInt(C, Ty); | |
1381 | case Instruction::IntToPtr: return getIntToPtr(C, Ty); | |
1382 | case Instruction::BitCast: return getBitCast(C, Ty); | |
1383 | } | |
1384 | } | |
1385 | ||
1386 | Constant *ConstantExpr::getZExtOrBitCast(Constant *C, Type *Ty) { | |
1387 | if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) | |
1388 | return getBitCast(C, Ty); | |
1389 | return getZExt(C, Ty); | |
1390 | } | |
1391 | ||
1392 | Constant *ConstantExpr::getSExtOrBitCast(Constant *C, Type *Ty) { | |
1393 | if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) | |
1394 | return getBitCast(C, Ty); | |
1395 | return getSExt(C, Ty); | |
1396 | } | |
1397 | ||
1398 | Constant *ConstantExpr::getTruncOrBitCast(Constant *C, Type *Ty) { | |
1399 | if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) | |
1400 | return getBitCast(C, Ty); | |
1401 | return getTrunc(C, Ty); | |
1402 | } | |
1403 | ||
1404 | Constant *ConstantExpr::getPointerCast(Constant *S, Type *Ty) { | |
1405 | assert(S->getType()->isPointerTy() && "Invalid cast"); | |
1406 | assert((Ty->isIntegerTy() || Ty->isPointerTy()) && "Invalid cast"); | |
1407 | ||
1408 | if (Ty->isIntegerTy()) | |
1409 | return getPtrToInt(S, Ty); | |
1410 | return getBitCast(S, Ty); | |
1411 | } | |
1412 | ||
1413 | Constant *ConstantExpr::getIntegerCast(Constant *C, Type *Ty, | |
1414 | bool isSigned) { | |
1415 | assert(C->getType()->isIntOrIntVectorTy() && | |
1416 | Ty->isIntOrIntVectorTy() && "Invalid cast"); | |
1417 | unsigned SrcBits = C->getType()->getScalarSizeInBits(); | |
1418 | unsigned DstBits = Ty->getScalarSizeInBits(); | |
1419 | Instruction::CastOps opcode = | |
1420 | (SrcBits == DstBits ? Instruction::BitCast : | |
1421 | (SrcBits > DstBits ? Instruction::Trunc : | |
1422 | (isSigned ? Instruction::SExt : Instruction::ZExt))); | |
1423 | return getCast(opcode, C, Ty); | |
1424 | } | |
1425 | ||
1426 | Constant *ConstantExpr::getFPCast(Constant *C, Type *Ty) { | |
1427 | assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() && | |
1428 | "Invalid cast"); | |
1429 | unsigned SrcBits = C->getType()->getScalarSizeInBits(); | |
1430 | unsigned DstBits = Ty->getScalarSizeInBits(); | |
1431 | if (SrcBits == DstBits) | |
1432 | return C; // Avoid a useless cast | |
1433 | Instruction::CastOps opcode = | |
1434 | (SrcBits > DstBits ? Instruction::FPTrunc : Instruction::FPExt); | |
1435 | return getCast(opcode, C, Ty); | |
1436 | } | |
1437 | ||
1438 | Constant *ConstantExpr::getTrunc(Constant *C, Type *Ty) { | |
1439 | #ifndef NDEBUG | |
1440 | bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; | |
1441 | bool toVec = Ty->getTypeID() == Type::VectorTyID; | |
1442 | #endif | |
1443 | assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); | |
1444 | assert(C->getType()->isIntOrIntVectorTy() && "Trunc operand must be integer"); | |
1445 | assert(Ty->isIntOrIntVectorTy() && "Trunc produces only integral"); | |
1446 | assert(C->getType()->getScalarSizeInBits() > Ty->getScalarSizeInBits()&& | |
1447 | "SrcTy must be larger than DestTy for Trunc!"); | |
1448 | ||
1449 | return getFoldedCast(Instruction::Trunc, C, Ty); | |
1450 | } | |
1451 | ||
1452 | Constant *ConstantExpr::getSExt(Constant *C, Type *Ty) { | |
1453 | #ifndef NDEBUG | |
1454 | bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; | |
1455 | bool toVec = Ty->getTypeID() == Type::VectorTyID; | |
1456 | #endif | |
1457 | assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); | |
1458 | assert(C->getType()->isIntOrIntVectorTy() && "SExt operand must be integral"); | |
1459 | assert(Ty->isIntOrIntVectorTy() && "SExt produces only integer"); | |
1460 | assert(C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&& | |
1461 | "SrcTy must be smaller than DestTy for SExt!"); | |
1462 | ||
1463 | return getFoldedCast(Instruction::SExt, C, Ty); | |
1464 | } | |
1465 | ||
1466 | Constant *ConstantExpr::getZExt(Constant *C, Type *Ty) { | |
1467 | #ifndef NDEBUG | |
1468 | bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; | |
1469 | bool toVec = Ty->getTypeID() == Type::VectorTyID; | |
1470 | #endif | |
1471 | assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); | |
1472 | assert(C->getType()->isIntOrIntVectorTy() && "ZEXt operand must be integral"); | |
1473 | assert(Ty->isIntOrIntVectorTy() && "ZExt produces only integer"); | |
1474 | assert(C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&& | |
1475 | "SrcTy must be smaller than DestTy for ZExt!"); | |
1476 | ||
1477 | return getFoldedCast(Instruction::ZExt, C, Ty); | |
1478 | } | |
1479 | ||
1480 | Constant *ConstantExpr::getFPTrunc(Constant *C, Type *Ty) { | |
1481 | #ifndef NDEBUG | |
1482 | bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; | |
1483 | bool toVec = Ty->getTypeID() == Type::VectorTyID; | |
1484 | #endif | |
1485 | assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); | |
1486 | assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() && | |
1487 | C->getType()->getScalarSizeInBits() > Ty->getScalarSizeInBits()&& | |
1488 | "This is an illegal floating point truncation!"); | |
1489 | return getFoldedCast(Instruction::FPTrunc, C, Ty); | |
1490 | } | |
1491 | ||
1492 | Constant *ConstantExpr::getFPExtend(Constant *C, Type *Ty) { | |
1493 | #ifndef NDEBUG | |
1494 | bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; | |
1495 | bool toVec = Ty->getTypeID() == Type::VectorTyID; | |
1496 | #endif | |
1497 | assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); | |
1498 | assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() && | |
1499 | C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&& | |
1500 | "This is an illegal floating point extension!"); | |
1501 | return getFoldedCast(Instruction::FPExt, C, Ty); | |
1502 | } | |
1503 | ||
1504 | Constant *ConstantExpr::getUIToFP(Constant *C, Type *Ty) { | |
1505 | #ifndef NDEBUG | |
1506 | bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; | |
1507 | bool toVec = Ty->getTypeID() == Type::VectorTyID; | |
1508 | #endif | |
1509 | assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); | |
1510 | assert(C->getType()->isIntOrIntVectorTy() && Ty->isFPOrFPVectorTy() && | |
1511 | "This is an illegal uint to floating point cast!"); | |
1512 | return getFoldedCast(Instruction::UIToFP, C, Ty); | |
1513 | } | |
1514 | ||
1515 | Constant *ConstantExpr::getSIToFP(Constant *C, Type *Ty) { | |
1516 | #ifndef NDEBUG | |
1517 | bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; | |
1518 | bool toVec = Ty->getTypeID() == Type::VectorTyID; | |
1519 | #endif | |
1520 | assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); | |
1521 | assert(C->getType()->isIntOrIntVectorTy() && Ty->isFPOrFPVectorTy() && | |
1522 | "This is an illegal sint to floating point cast!"); | |
1523 | return getFoldedCast(Instruction::SIToFP, C, Ty); | |
1524 | } | |
1525 | ||
1526 | Constant *ConstantExpr::getFPToUI(Constant *C, Type *Ty) { | |
1527 | #ifndef NDEBUG | |
1528 | bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; | |
1529 | bool toVec = Ty->getTypeID() == Type::VectorTyID; | |
1530 | #endif | |
1531 | assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); | |
1532 | assert(C->getType()->isFPOrFPVectorTy() && Ty->isIntOrIntVectorTy() && | |
1533 | "This is an illegal floating point to uint cast!"); | |
1534 | return getFoldedCast(Instruction::FPToUI, C, Ty); | |
1535 | } | |
1536 | ||
1537 | Constant *ConstantExpr::getFPToSI(Constant *C, Type *Ty) { | |
1538 | #ifndef NDEBUG | |
1539 | bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; | |
1540 | bool toVec = Ty->getTypeID() == Type::VectorTyID; | |
1541 | #endif | |
1542 | assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); | |
1543 | assert(C->getType()->isFPOrFPVectorTy() && Ty->isIntOrIntVectorTy() && | |
1544 | "This is an illegal floating point to sint cast!"); | |
1545 | return getFoldedCast(Instruction::FPToSI, C, Ty); | |
1546 | } | |
1547 | ||
1548 | Constant *ConstantExpr::getPtrToInt(Constant *C, Type *DstTy) { | |
1549 | assert(C->getType()->getScalarType()->isPointerTy() && | |
1550 | "PtrToInt source must be pointer or pointer vector"); | |
1551 | assert(DstTy->getScalarType()->isIntegerTy() && | |
1552 | "PtrToInt destination must be integer or integer vector"); | |
1553 | assert(isa<VectorType>(C->getType()) == isa<VectorType>(DstTy)); | |
1554 | if (isa<VectorType>(C->getType())) | |
1555 | assert(C->getType()->getVectorNumElements()==DstTy->getVectorNumElements()&& | |
1556 | "Invalid cast between a different number of vector elements"); | |
1557 | return getFoldedCast(Instruction::PtrToInt, C, DstTy); | |
1558 | } | |
1559 | ||
1560 | Constant *ConstantExpr::getIntToPtr(Constant *C, Type *DstTy) { | |
1561 | assert(C->getType()->getScalarType()->isIntegerTy() && | |
1562 | "IntToPtr source must be integer or integer vector"); | |
1563 | assert(DstTy->getScalarType()->isPointerTy() && | |
1564 | "IntToPtr destination must be a pointer or pointer vector"); | |
1565 | assert(isa<VectorType>(C->getType()) == isa<VectorType>(DstTy)); | |
1566 | if (isa<VectorType>(C->getType())) | |
1567 | assert(C->getType()->getVectorNumElements()==DstTy->getVectorNumElements()&& | |
1568 | "Invalid cast between a different number of vector elements"); | |
1569 | return getFoldedCast(Instruction::IntToPtr, C, DstTy); | |
1570 | } | |
1571 | ||
1572 | Constant *ConstantExpr::getBitCast(Constant *C, Type *DstTy) { | |
1573 | assert(CastInst::castIsValid(Instruction::BitCast, C, DstTy) && | |
1574 | "Invalid constantexpr bitcast!"); | |
1575 | ||
1576 | // It is common to ask for a bitcast of a value to its own type, handle this | |
1577 | // speedily. | |
1578 | if (C->getType() == DstTy) return C; | |
1579 | ||
1580 | return getFoldedCast(Instruction::BitCast, C, DstTy); | |
1581 | } | |
1582 | ||
1583 | Constant *ConstantExpr::get(unsigned Opcode, Constant *C1, Constant *C2, | |
1584 | unsigned Flags) { | |
1585 | // Check the operands for consistency first. | |
1586 | assert(Opcode >= Instruction::BinaryOpsBegin && | |
1587 | Opcode < Instruction::BinaryOpsEnd && | |
1588 | "Invalid opcode in binary constant expression"); | |
1589 | assert(C1->getType() == C2->getType() && | |
1590 | "Operand types in binary constant expression should match"); | |
1591 | ||
1592 | #ifndef NDEBUG | |
1593 | switch (Opcode) { | |
1594 | case Instruction::Add: | |
1595 | case Instruction::Sub: | |
1596 | case Instruction::Mul: | |
1597 | assert(C1->getType() == C2->getType() && "Op types should be identical!"); | |
1598 | assert(C1->getType()->isIntOrIntVectorTy() && | |
1599 | "Tried to create an integer operation on a non-integer type!"); | |
1600 | break; | |
1601 | case Instruction::FAdd: | |
1602 | case Instruction::FSub: | |
1603 | case Instruction::FMul: | |
1604 | assert(C1->getType() == C2->getType() && "Op types should be identical!"); | |
1605 | assert(C1->getType()->isFPOrFPVectorTy() && | |
1606 | "Tried to create a floating-point operation on a " | |
1607 | "non-floating-point type!"); | |
1608 | break; | |
1609 | case Instruction::UDiv: | |
1610 | case Instruction::SDiv: | |
1611 | assert(C1->getType() == C2->getType() && "Op types should be identical!"); | |
1612 | assert(C1->getType()->isIntOrIntVectorTy() && | |
1613 | "Tried to create an arithmetic operation on a non-arithmetic type!"); | |
1614 | break; | |
1615 | case Instruction::FDiv: | |
1616 | assert(C1->getType() == C2->getType() && "Op types should be identical!"); | |
1617 | assert(C1->getType()->isFPOrFPVectorTy() && | |
1618 | "Tried to create an arithmetic operation on a non-arithmetic type!"); | |
1619 | break; | |
1620 | case Instruction::URem: | |
1621 | case Instruction::SRem: | |
1622 | assert(C1->getType() == C2->getType() && "Op types should be identical!"); | |
1623 | assert(C1->getType()->isIntOrIntVectorTy() && | |
1624 | "Tried to create an arithmetic operation on a non-arithmetic type!"); | |
1625 | break; | |
1626 | case Instruction::FRem: | |
1627 | assert(C1->getType() == C2->getType() && "Op types should be identical!"); | |
1628 | assert(C1->getType()->isFPOrFPVectorTy() && | |
1629 | "Tried to create an arithmetic operation on a non-arithmetic type!"); | |
1630 | break; | |
1631 | case Instruction::And: | |
1632 | case Instruction::Or: | |
1633 | case Instruction::Xor: | |
1634 | assert(C1->getType() == C2->getType() && "Op types should be identical!"); | |
1635 | assert(C1->getType()->isIntOrIntVectorTy() && | |
1636 | "Tried to create a logical operation on a non-integral type!"); | |
1637 | break; | |
1638 | case Instruction::Shl: | |
1639 | case Instruction::LShr: | |
1640 | case Instruction::AShr: | |
1641 | assert(C1->getType() == C2->getType() && "Op types should be identical!"); | |
1642 | assert(C1->getType()->isIntOrIntVectorTy() && | |
1643 | "Tried to create a shift operation on a non-integer type!"); | |
1644 | break; | |
1645 | default: | |
1646 | break; | |
1647 | } | |
1648 | #endif | |
1649 | ||
1650 | if (Constant *FC = ConstantFoldBinaryInstruction(Opcode, C1, C2)) | |
1651 | return FC; // Fold a few common cases. | |
1652 | ||
1653 | std::vector<Constant*> argVec(1, C1); | |
1654 | argVec.push_back(C2); | |
1655 | ExprMapKeyType Key(Opcode, argVec, 0, Flags); | |
1656 | ||
1657 | LLVMContextImpl *pImpl = C1->getContext().pImpl; | |
1658 | return pImpl->ExprConstants.getOrCreate(C1->getType(), Key); | |
1659 | } | |
1660 | ||
1661 | Constant *ConstantExpr::getSizeOf(Type* Ty) { | |
1662 | // sizeof is implemented as: (i64) gep (Ty*)null, 1 | |
1663 | // Note that a non-inbounds gep is used, as null isn't within any object. | |
1664 | Constant *GEPIdx = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1); | |
1665 | Constant *GEP = getGetElementPtr( | |
1666 | Constant::getNullValue(PointerType::getUnqual(Ty)), GEPIdx); | |
1667 | return getPtrToInt(GEP, | |
1668 | Type::getInt64Ty(Ty->getContext())); | |
1669 | } | |
1670 | ||
1671 | Constant *ConstantExpr::getAlignOf(Type* Ty) { | |
1672 | // alignof is implemented as: (i64) gep ({i1,Ty}*)null, 0, 1 | |
1673 | // Note that a non-inbounds gep is used, as null isn't within any object. | |
1674 | Type *AligningTy = | |
1675 | StructType::get(Type::getInt1Ty(Ty->getContext()), Ty, NULL); | |
1676 | Constant *NullPtr = Constant::getNullValue(AligningTy->getPointerTo()); | |
1677 | Constant *Zero = ConstantInt::get(Type::getInt64Ty(Ty->getContext()), 0); | |
1678 | Constant *One = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1); | |
1679 | Constant *Indices[2] = { Zero, One }; | |
1680 | Constant *GEP = getGetElementPtr(NullPtr, Indices); | |
1681 | return getPtrToInt(GEP, | |
1682 | Type::getInt64Ty(Ty->getContext())); | |
1683 | } | |
1684 | ||
1685 | Constant *ConstantExpr::getOffsetOf(StructType* STy, unsigned FieldNo) { | |
1686 | return getOffsetOf(STy, ConstantInt::get(Type::getInt32Ty(STy->getContext()), | |
1687 | FieldNo)); | |
1688 | } | |
1689 | ||
1690 | Constant *ConstantExpr::getOffsetOf(Type* Ty, Constant *FieldNo) { | |
1691 | // offsetof is implemented as: (i64) gep (Ty*)null, 0, FieldNo | |
1692 | // Note that a non-inbounds gep is used, as null isn't within any object. | |
1693 | Constant *GEPIdx[] = { | |
1694 | ConstantInt::get(Type::getInt64Ty(Ty->getContext()), 0), | |
1695 | FieldNo | |
1696 | }; | |
1697 | Constant *GEP = getGetElementPtr( | |
1698 | Constant::getNullValue(PointerType::getUnqual(Ty)), GEPIdx); | |
1699 | return getPtrToInt(GEP, | |
1700 | Type::getInt64Ty(Ty->getContext())); | |
1701 | } | |
1702 | ||
1703 | Constant *ConstantExpr::getCompare(unsigned short Predicate, | |
1704 | Constant *C1, Constant *C2) { | |
1705 | assert(C1->getType() == C2->getType() && "Op types should be identical!"); | |
1706 | ||
1707 | switch (Predicate) { | |
1708 | default: llvm_unreachable("Invalid CmpInst predicate"); | |
1709 | case CmpInst::FCMP_FALSE: case CmpInst::FCMP_OEQ: case CmpInst::FCMP_OGT: | |
1710 | case CmpInst::FCMP_OGE: case CmpInst::FCMP_OLT: case CmpInst::FCMP_OLE: | |
1711 | case CmpInst::FCMP_ONE: case CmpInst::FCMP_ORD: case CmpInst::FCMP_UNO: | |
1712 | case CmpInst::FCMP_UEQ: case CmpInst::FCMP_UGT: case CmpInst::FCMP_UGE: | |
1713 | case CmpInst::FCMP_ULT: case CmpInst::FCMP_ULE: case CmpInst::FCMP_UNE: | |
1714 | case CmpInst::FCMP_TRUE: | |
1715 | return getFCmp(Predicate, C1, C2); | |
1716 | ||
1717 | case CmpInst::ICMP_EQ: case CmpInst::ICMP_NE: case CmpInst::ICMP_UGT: | |
1718 | case CmpInst::ICMP_UGE: case CmpInst::ICMP_ULT: case CmpInst::ICMP_ULE: | |
1719 | case CmpInst::ICMP_SGT: case CmpInst::ICMP_SGE: case CmpInst::ICMP_SLT: | |
1720 | case CmpInst::ICMP_SLE: | |
1721 | return getICmp(Predicate, C1, C2); | |
1722 | } | |
1723 | } | |
1724 | ||
1725 | Constant *ConstantExpr::getSelect(Constant *C, Constant *V1, Constant *V2) { | |
1726 | assert(!SelectInst::areInvalidOperands(C, V1, V2)&&"Invalid select operands"); | |
1727 | ||
1728 | if (Constant *SC = ConstantFoldSelectInstruction(C, V1, V2)) | |
1729 | return SC; // Fold common cases | |
1730 | ||
1731 | std::vector<Constant*> argVec(3, C); | |
1732 | argVec[1] = V1; | |
1733 | argVec[2] = V2; | |
1734 | ExprMapKeyType Key(Instruction::Select, argVec); | |
1735 | ||
1736 | LLVMContextImpl *pImpl = C->getContext().pImpl; | |
1737 | return pImpl->ExprConstants.getOrCreate(V1->getType(), Key); | |
1738 | } | |
1739 | ||
1740 | Constant *ConstantExpr::getGetElementPtr(Constant *C, ArrayRef<Value *> Idxs, | |
1741 | bool InBounds) { | |
1742 | if (Constant *FC = ConstantFoldGetElementPtr(C, InBounds, Idxs)) | |
1743 | return FC; // Fold a few common cases. | |
1744 | ||
1745 | // Get the result type of the getelementptr! | |
1746 | Type *Ty = GetElementPtrInst::getIndexedType(C->getType(), Idxs); | |
1747 | assert(Ty && "GEP indices invalid!"); | |
1748 | unsigned AS = C->getType()->getPointerAddressSpace(); | |
1749 | Type *ReqTy = Ty->getPointerTo(AS); | |
1750 | ||
1751 | assert(C->getType()->isPointerTy() && | |
1752 | "Non-pointer type for constant GetElementPtr expression"); | |
1753 | // Look up the constant in the table first to ensure uniqueness | |
1754 | std::vector<Constant*> ArgVec; | |
1755 | ArgVec.reserve(1 + Idxs.size()); | |
1756 | ArgVec.push_back(C); | |
1757 | for (unsigned i = 0, e = Idxs.size(); i != e; ++i) | |
1758 | ArgVec.push_back(cast<Constant>(Idxs[i])); | |
1759 | const ExprMapKeyType Key(Instruction::GetElementPtr, ArgVec, 0, | |
1760 | InBounds ? GEPOperator::IsInBounds : 0); | |
1761 | ||
1762 | LLVMContextImpl *pImpl = C->getContext().pImpl; | |
1763 | return pImpl->ExprConstants.getOrCreate(ReqTy, Key); | |
1764 | } | |
1765 | ||
1766 | Constant * | |
1767 | ConstantExpr::getICmp(unsigned short pred, Constant *LHS, Constant *RHS) { | |
1768 | assert(LHS->getType() == RHS->getType()); | |
1769 | assert(pred >= ICmpInst::FIRST_ICMP_PREDICATE && | |
1770 | pred <= ICmpInst::LAST_ICMP_PREDICATE && "Invalid ICmp Predicate"); | |
1771 | ||
1772 | if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS)) | |
1773 | return FC; // Fold a few common cases... | |
1774 | ||
1775 | // Look up the constant in the table first to ensure uniqueness | |
1776 | std::vector<Constant*> ArgVec; | |
1777 | ArgVec.push_back(LHS); | |
1778 | ArgVec.push_back(RHS); | |
1779 | // Get the key type with both the opcode and predicate | |
1780 | const ExprMapKeyType Key(Instruction::ICmp, ArgVec, pred); | |
1781 | ||
1782 | Type *ResultTy = Type::getInt1Ty(LHS->getContext()); | |
1783 | if (VectorType *VT = dyn_cast<VectorType>(LHS->getType())) | |
1784 | ResultTy = VectorType::get(ResultTy, VT->getNumElements()); | |
1785 | ||
1786 | LLVMContextImpl *pImpl = LHS->getType()->getContext().pImpl; | |
1787 | return pImpl->ExprConstants.getOrCreate(ResultTy, Key); | |
1788 | } | |
1789 | ||
1790 | Constant * | |
1791 | ConstantExpr::getFCmp(unsigned short pred, Constant *LHS, Constant *RHS) { | |
1792 | assert(LHS->getType() == RHS->getType()); | |
1793 | assert(pred <= FCmpInst::LAST_FCMP_PREDICATE && "Invalid FCmp Predicate"); | |
1794 | ||
1795 | if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS)) | |
1796 | return FC; // Fold a few common cases... | |
1797 | ||
1798 | // Look up the constant in the table first to ensure uniqueness | |
1799 | std::vector<Constant*> ArgVec; | |
1800 | ArgVec.push_back(LHS); | |
1801 | ArgVec.push_back(RHS); | |
1802 | // Get the key type with both the opcode and predicate | |
1803 | const ExprMapKeyType Key(Instruction::FCmp, ArgVec, pred); | |
1804 | ||
1805 | Type *ResultTy = Type::getInt1Ty(LHS->getContext()); | |
1806 | if (VectorType *VT = dyn_cast<VectorType>(LHS->getType())) | |
1807 | ResultTy = VectorType::get(ResultTy, VT->getNumElements()); | |
1808 | ||
1809 | LLVMContextImpl *pImpl = LHS->getType()->getContext().pImpl; | |
1810 | return pImpl->ExprConstants.getOrCreate(ResultTy, Key); | |
1811 | } | |
1812 | ||
1813 | Constant *ConstantExpr::getExtractElement(Constant *Val, Constant *Idx) { | |
1814 | assert(Val->getType()->isVectorTy() && | |
1815 | "Tried to create extractelement operation on non-vector type!"); | |
1816 | assert(Idx->getType()->isIntegerTy(32) && | |
1817 | "Extractelement index must be i32 type!"); | |
1818 | ||
1819 | if (Constant *FC = ConstantFoldExtractElementInstruction(Val, Idx)) | |
1820 | return FC; // Fold a few common cases. | |
1821 | ||
1822 | // Look up the constant in the table first to ensure uniqueness | |
1823 | std::vector<Constant*> ArgVec(1, Val); | |
1824 | ArgVec.push_back(Idx); | |
1825 | const ExprMapKeyType Key(Instruction::ExtractElement,ArgVec); | |
1826 | ||
1827 | LLVMContextImpl *pImpl = Val->getContext().pImpl; | |
1828 | Type *ReqTy = Val->getType()->getVectorElementType(); | |
1829 | return pImpl->ExprConstants.getOrCreate(ReqTy, Key); | |
1830 | } | |
1831 | ||
1832 | Constant *ConstantExpr::getInsertElement(Constant *Val, Constant *Elt, | |
1833 | Constant *Idx) { | |
1834 | assert(Val->getType()->isVectorTy() && | |
1835 | "Tried to create insertelement operation on non-vector type!"); | |
1836 | assert(Elt->getType() == Val->getType()->getVectorElementType() && | |
1837 | "Insertelement types must match!"); | |
1838 | assert(Idx->getType()->isIntegerTy(32) && | |
1839 | "Insertelement index must be i32 type!"); | |
1840 | ||
1841 | if (Constant *FC = ConstantFoldInsertElementInstruction(Val, Elt, Idx)) | |
1842 | return FC; // Fold a few common cases. | |
1843 | // Look up the constant in the table first to ensure uniqueness | |
1844 | std::vector<Constant*> ArgVec(1, Val); | |
1845 | ArgVec.push_back(Elt); | |
1846 | ArgVec.push_back(Idx); | |
1847 | const ExprMapKeyType Key(Instruction::InsertElement,ArgVec); | |
1848 | ||
1849 | LLVMContextImpl *pImpl = Val->getContext().pImpl; | |
1850 | return pImpl->ExprConstants.getOrCreate(Val->getType(), Key); | |
1851 | } | |
1852 | ||
1853 | Constant *ConstantExpr::getShuffleVector(Constant *V1, Constant *V2, | |
1854 | Constant *Mask) { | |
1855 | assert(ShuffleVectorInst::isValidOperands(V1, V2, Mask) && | |
1856 | "Invalid shuffle vector constant expr operands!"); | |
1857 | ||
1858 | if (Constant *FC = ConstantFoldShuffleVectorInstruction(V1, V2, Mask)) | |
1859 | return FC; // Fold a few common cases. | |
1860 | ||
1861 | unsigned NElts = Mask->getType()->getVectorNumElements(); | |
1862 | Type *EltTy = V1->getType()->getVectorElementType(); | |
1863 | Type *ShufTy = VectorType::get(EltTy, NElts); | |
1864 | ||
1865 | // Look up the constant in the table first to ensure uniqueness | |
1866 | std::vector<Constant*> ArgVec(1, V1); | |
1867 | ArgVec.push_back(V2); | |
1868 | ArgVec.push_back(Mask); | |
1869 | const ExprMapKeyType Key(Instruction::ShuffleVector,ArgVec); | |
1870 | ||
1871 | LLVMContextImpl *pImpl = ShufTy->getContext().pImpl; | |
1872 | return pImpl->ExprConstants.getOrCreate(ShufTy, Key); | |
1873 | } | |
1874 | ||
1875 | Constant *ConstantExpr::getInsertValue(Constant *Agg, Constant *Val, | |
1876 | ArrayRef<unsigned> Idxs) { | |
1877 | assert(ExtractValueInst::getIndexedType(Agg->getType(), | |
1878 | Idxs) == Val->getType() && | |
1879 | "insertvalue indices invalid!"); | |
1880 | assert(Agg->getType()->isFirstClassType() && | |
1881 | "Non-first-class type for constant insertvalue expression"); | |
1882 | Constant *FC = ConstantFoldInsertValueInstruction(Agg, Val, Idxs); | |
1883 | assert(FC && "insertvalue constant expr couldn't be folded!"); | |
1884 | return FC; | |
1885 | } | |
1886 | ||
1887 | Constant *ConstantExpr::getExtractValue(Constant *Agg, | |
1888 | ArrayRef<unsigned> Idxs) { | |
1889 | assert(Agg->getType()->isFirstClassType() && | |
1890 | "Tried to create extractelement operation on non-first-class type!"); | |
1891 | ||
1892 | Type *ReqTy = ExtractValueInst::getIndexedType(Agg->getType(), Idxs); | |
1893 | (void)ReqTy; | |
1894 | assert(ReqTy && "extractvalue indices invalid!"); | |
1895 | ||
1896 | assert(Agg->getType()->isFirstClassType() && | |
1897 | "Non-first-class type for constant extractvalue expression"); | |
1898 | Constant *FC = ConstantFoldExtractValueInstruction(Agg, Idxs); | |
1899 | assert(FC && "ExtractValue constant expr couldn't be folded!"); | |
1900 | return FC; | |
1901 | } | |
1902 | ||
1903 | Constant *ConstantExpr::getNeg(Constant *C, bool HasNUW, bool HasNSW) { | |
1904 | assert(C->getType()->isIntOrIntVectorTy() && | |
1905 | "Cannot NEG a nonintegral value!"); | |
1906 | return getSub(ConstantFP::getZeroValueForNegation(C->getType()), | |
1907 | C, HasNUW, HasNSW); | |
1908 | } | |
1909 | ||
1910 | Constant *ConstantExpr::getFNeg(Constant *C) { | |
1911 | assert(C->getType()->isFPOrFPVectorTy() && | |
1912 | "Cannot FNEG a non-floating-point value!"); | |
1913 | return getFSub(ConstantFP::getZeroValueForNegation(C->getType()), C); | |
1914 | } | |
1915 | ||
1916 | Constant *ConstantExpr::getNot(Constant *C) { | |
1917 | assert(C->getType()->isIntOrIntVectorTy() && | |
1918 | "Cannot NOT a nonintegral value!"); | |
1919 | return get(Instruction::Xor, C, Constant::getAllOnesValue(C->getType())); | |
1920 | } | |
1921 | ||
1922 | Constant *ConstantExpr::getAdd(Constant *C1, Constant *C2, | |
1923 | bool HasNUW, bool HasNSW) { | |
1924 | unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) | | |
1925 | (HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0); | |
1926 | return get(Instruction::Add, C1, C2, Flags); | |
1927 | } | |
1928 | ||
1929 | Constant *ConstantExpr::getFAdd(Constant *C1, Constant *C2) { | |
1930 | return get(Instruction::FAdd, C1, C2); | |
1931 | } | |
1932 | ||
1933 | Constant *ConstantExpr::getSub(Constant *C1, Constant *C2, | |
1934 | bool HasNUW, bool HasNSW) { | |
1935 | unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) | | |
1936 | (HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0); | |
1937 | return get(Instruction::Sub, C1, C2, Flags); | |
1938 | } | |
1939 | ||
1940 | Constant *ConstantExpr::getFSub(Constant *C1, Constant *C2) { | |
1941 | return get(Instruction::FSub, C1, C2); | |
1942 | } | |
1943 | ||
1944 | Constant *ConstantExpr::getMul(Constant *C1, Constant *C2, | |
1945 | bool HasNUW, bool HasNSW) { | |
1946 | unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) | | |
1947 | (HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0); | |
1948 | return get(Instruction::Mul, C1, C2, Flags); | |
1949 | } | |
1950 | ||
1951 | Constant *ConstantExpr::getFMul(Constant *C1, Constant *C2) { | |
1952 | return get(Instruction::FMul, C1, C2); | |
1953 | } | |
1954 | ||
1955 | Constant *ConstantExpr::getUDiv(Constant *C1, Constant *C2, bool isExact) { | |
1956 | return get(Instruction::UDiv, C1, C2, | |
1957 | isExact ? PossiblyExactOperator::IsExact : 0); | |
1958 | } | |
1959 | ||
1960 | Constant *ConstantExpr::getSDiv(Constant *C1, Constant *C2, bool isExact) { | |
1961 | return get(Instruction::SDiv, C1, C2, | |
1962 | isExact ? PossiblyExactOperator::IsExact : 0); | |
1963 | } | |
1964 | ||
1965 | Constant *ConstantExpr::getFDiv(Constant *C1, Constant *C2) { | |
1966 | return get(Instruction::FDiv, C1, C2); | |
1967 | } | |
1968 | ||
1969 | Constant *ConstantExpr::getURem(Constant *C1, Constant *C2) { | |
1970 | return get(Instruction::URem, C1, C2); | |
1971 | } | |
1972 | ||
1973 | Constant *ConstantExpr::getSRem(Constant *C1, Constant *C2) { | |
1974 | return get(Instruction::SRem, C1, C2); | |
1975 | } | |
1976 | ||
1977 | Constant *ConstantExpr::getFRem(Constant *C1, Constant *C2) { | |
1978 | return get(Instruction::FRem, C1, C2); | |
1979 | } | |
1980 | ||
1981 | Constant *ConstantExpr::getAnd(Constant *C1, Constant *C2) { | |
1982 | return get(Instruction::And, C1, C2); | |
1983 | } | |
1984 | ||
1985 | Constant *ConstantExpr::getOr(Constant *C1, Constant *C2) { | |
1986 | return get(Instruction::Or, C1, C2); | |
1987 | } | |
1988 | ||
1989 | Constant *ConstantExpr::getXor(Constant *C1, Constant *C2) { | |
1990 | return get(Instruction::Xor, C1, C2); | |
1991 | } | |
1992 | ||
1993 | Constant *ConstantExpr::getShl(Constant *C1, Constant *C2, | |
1994 | bool HasNUW, bool HasNSW) { | |
1995 | unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) | | |
1996 | (HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0); | |
1997 | return get(Instruction::Shl, C1, C2, Flags); | |
1998 | } | |
1999 | ||
2000 | Constant *ConstantExpr::getLShr(Constant *C1, Constant *C2, bool isExact) { | |
2001 | return get(Instruction::LShr, C1, C2, | |
2002 | isExact ? PossiblyExactOperator::IsExact : 0); | |
2003 | } | |
2004 | ||
2005 | Constant *ConstantExpr::getAShr(Constant *C1, Constant *C2, bool isExact) { | |
2006 | return get(Instruction::AShr, C1, C2, | |
2007 | isExact ? PossiblyExactOperator::IsExact : 0); | |
2008 | } | |
2009 | ||
2010 | /// getBinOpIdentity - Return the identity for the given binary operation, | |
2011 | /// i.e. a constant C such that X op C = X and C op X = X for every X. It | |
2012 | /// returns null if the operator doesn't have an identity. | |
2013 | Constant *ConstantExpr::getBinOpIdentity(unsigned Opcode, Type *Ty) { | |
2014 | switch (Opcode) { | |
2015 | default: | |
2016 | // Doesn't have an identity. | |
2017 | return 0; | |
2018 | ||
2019 | case Instruction::Add: | |
2020 | case Instruction::Or: | |
2021 | case Instruction::Xor: | |
2022 | return Constant::getNullValue(Ty); | |
2023 | ||
2024 | case Instruction::Mul: | |
2025 | return ConstantInt::get(Ty, 1); | |
2026 | ||
2027 | case Instruction::And: | |
2028 | return Constant::getAllOnesValue(Ty); | |
2029 | } | |
2030 | } | |
2031 | ||
2032 | /// getBinOpAbsorber - Return the absorbing element for the given binary | |
2033 | /// operation, i.e. a constant C such that X op C = C and C op X = C for | |
2034 | /// every X. For example, this returns zero for integer multiplication. | |
2035 | /// It returns null if the operator doesn't have an absorbing element. | |
2036 | Constant *ConstantExpr::getBinOpAbsorber(unsigned Opcode, Type *Ty) { | |
2037 | switch (Opcode) { | |
2038 | default: | |
2039 | // Doesn't have an absorber. | |
2040 | return 0; | |
2041 | ||
2042 | case Instruction::Or: | |
2043 | return Constant::getAllOnesValue(Ty); | |
2044 | ||
2045 | case Instruction::And: | |
2046 | case Instruction::Mul: | |
2047 | return Constant::getNullValue(Ty); | |
2048 | } | |
2049 | } | |
2050 | ||
2051 | // destroyConstant - Remove the constant from the constant table... | |
2052 | // | |
2053 | void ConstantExpr::destroyConstant() { | |
2054 | getType()->getContext().pImpl->ExprConstants.remove(this); | |
2055 | destroyConstantImpl(); | |
2056 | } | |
2057 | ||
2058 | const char *ConstantExpr::getOpcodeName() const { | |
2059 | return Instruction::getOpcodeName(getOpcode()); | |
2060 | } | |
2061 | ||
2062 | ||
2063 | ||
2064 | GetElementPtrConstantExpr:: | |
2065 | GetElementPtrConstantExpr(Constant *C, ArrayRef<Constant*> IdxList, | |
2066 | Type *DestTy) | |
2067 | : ConstantExpr(DestTy, Instruction::GetElementPtr, | |
2068 | OperandTraits<GetElementPtrConstantExpr>::op_end(this) | |
2069 | - (IdxList.size()+1), IdxList.size()+1) { | |
2070 | OperandList[0] = C; | |
2071 | for (unsigned i = 0, E = IdxList.size(); i != E; ++i) | |
2072 | OperandList[i+1] = IdxList[i]; | |
2073 | } | |
2074 | ||
2075 | //===----------------------------------------------------------------------===// | |
2076 | // ConstantData* implementations | |
2077 | ||
2078 | void ConstantDataArray::anchor() {} | |
2079 | void ConstantDataVector::anchor() {} | |
2080 | ||
2081 | /// getElementType - Return the element type of the array/vector. | |
2082 | Type *ConstantDataSequential::getElementType() const { | |
2083 | return getType()->getElementType(); | |
2084 | } | |
2085 | ||
2086 | StringRef ConstantDataSequential::getRawDataValues() const { | |
2087 | return StringRef(DataElements, getNumElements()*getElementByteSize()); | |
2088 | } | |
2089 | ||
2090 | /// isElementTypeCompatible - Return true if a ConstantDataSequential can be | |
2091 | /// formed with a vector or array of the specified element type. | |
2092 | /// ConstantDataArray only works with normal float and int types that are | |
2093 | /// stored densely in memory, not with things like i42 or x86_f80. | |
2094 | bool ConstantDataSequential::isElementTypeCompatible(const Type *Ty) { | |
2095 | if (Ty->isFloatTy() || Ty->isDoubleTy()) return true; | |
2096 | if (const IntegerType *IT = dyn_cast<IntegerType>(Ty)) { | |
2097 | switch (IT->getBitWidth()) { | |
2098 | case 8: | |
2099 | case 16: | |
2100 | case 32: | |
2101 | case 64: | |
2102 | return true; | |
2103 | default: break; | |
2104 | } | |
2105 | } | |
2106 | return false; | |
2107 | } | |
2108 | ||
2109 | /// getNumElements - Return the number of elements in the array or vector. | |
2110 | unsigned ConstantDataSequential::getNumElements() const { | |
2111 | if (ArrayType *AT = dyn_cast<ArrayType>(getType())) | |
2112 | return AT->getNumElements(); | |
2113 | return getType()->getVectorNumElements(); | |
2114 | } | |
2115 | ||
2116 | ||
2117 | /// getElementByteSize - Return the size in bytes of the elements in the data. | |
2118 | uint64_t ConstantDataSequential::getElementByteSize() const { | |
2119 | return getElementType()->getPrimitiveSizeInBits()/8; | |
2120 | } | |
2121 | ||
2122 | /// getElementPointer - Return the start of the specified element. | |
2123 | const char *ConstantDataSequential::getElementPointer(unsigned Elt) const { | |
2124 | assert(Elt < getNumElements() && "Invalid Elt"); | |
2125 | return DataElements+Elt*getElementByteSize(); | |
2126 | } | |
2127 | ||
2128 | ||
2129 | /// isAllZeros - return true if the array is empty or all zeros. | |
2130 | static bool isAllZeros(StringRef Arr) { | |
2131 | for (StringRef::iterator I = Arr.begin(), E = Arr.end(); I != E; ++I) | |
2132 | if (*I != 0) | |
2133 | return false; | |
2134 | return true; | |
2135 | } | |
2136 | ||
2137 | /// getImpl - This is the underlying implementation of all of the | |
2138 | /// ConstantDataSequential::get methods. They all thunk down to here, providing | |
2139 | /// the correct element type. We take the bytes in as a StringRef because | |
2140 | /// we *want* an underlying "char*" to avoid TBAA type punning violations. | |
2141 | Constant *ConstantDataSequential::getImpl(StringRef Elements, Type *Ty) { | |
2142 | assert(isElementTypeCompatible(Ty->getSequentialElementType())); | |
2143 | // If the elements are all zero or there are no elements, return a CAZ, which | |
2144 | // is more dense and canonical. | |
2145 | if (isAllZeros(Elements)) | |
2146 | return ConstantAggregateZero::get(Ty); | |
2147 | ||
2148 | // Do a lookup to see if we have already formed one of these. | |
2149 | StringMap<ConstantDataSequential*>::MapEntryTy &Slot = | |
2150 | Ty->getContext().pImpl->CDSConstants.GetOrCreateValue(Elements); | |
2151 | ||
2152 | // The bucket can point to a linked list of different CDS's that have the same | |
2153 | // body but different types. For example, 0,0,0,1 could be a 4 element array | |
2154 | // of i8, or a 1-element array of i32. They'll both end up in the same | |
2155 | /// StringMap bucket, linked up by their Next pointers. Walk the list. | |
2156 | ConstantDataSequential **Entry = &Slot.getValue(); | |
2157 | for (ConstantDataSequential *Node = *Entry; Node != 0; | |
2158 | Entry = &Node->Next, Node = *Entry) | |
2159 | if (Node->getType() == Ty) | |
2160 | return Node; | |
2161 | ||
2162 | // Okay, we didn't get a hit. Create a node of the right class, link it in, | |
2163 | // and return it. | |
2164 | if (isa<ArrayType>(Ty)) | |
2165 | return *Entry = new ConstantDataArray(Ty, Slot.getKeyData()); | |
2166 | ||
2167 | assert(isa<VectorType>(Ty)); | |
2168 | return *Entry = new ConstantDataVector(Ty, Slot.getKeyData()); | |
2169 | } | |
2170 | ||
2171 | void ConstantDataSequential::destroyConstant() { | |
2172 | // Remove the constant from the StringMap. | |
2173 | StringMap<ConstantDataSequential*> &CDSConstants = | |
2174 | getType()->getContext().pImpl->CDSConstants; | |
2175 | ||
2176 | StringMap<ConstantDataSequential*>::iterator Slot = | |
2177 | CDSConstants.find(getRawDataValues()); | |
2178 | ||
2179 | assert(Slot != CDSConstants.end() && "CDS not found in uniquing table"); | |
2180 | ||
2181 | ConstantDataSequential **Entry = &Slot->getValue(); | |
2182 | ||
2183 | // Remove the entry from the hash table. | |
2184 | if ((*Entry)->Next == 0) { | |
2185 | // If there is only one value in the bucket (common case) it must be this | |
2186 | // entry, and removing the entry should remove the bucket completely. | |
2187 | assert((*Entry) == this && "Hash mismatch in ConstantDataSequential"); | |
2188 | getContext().pImpl->CDSConstants.erase(Slot); | |
2189 | } else { | |
2190 | // Otherwise, there are multiple entries linked off the bucket, unlink the | |
2191 | // node we care about but keep the bucket around. | |
2192 | for (ConstantDataSequential *Node = *Entry; ; | |
2193 | Entry = &Node->Next, Node = *Entry) { | |
2194 | assert(Node && "Didn't find entry in its uniquing hash table!"); | |
2195 | // If we found our entry, unlink it from the list and we're done. | |
2196 | if (Node == this) { | |
2197 | *Entry = Node->Next; | |
2198 | break; | |
2199 | } | |
2200 | } | |
2201 | } | |
2202 | ||
2203 | // If we were part of a list, make sure that we don't delete the list that is | |
2204 | // still owned by the uniquing map. | |
2205 | Next = 0; | |
2206 | ||
2207 | // Finally, actually delete it. | |
2208 | destroyConstantImpl(); | |
2209 | } | |
2210 | ||
2211 | /// get() constructors - Return a constant with array type with an element | |
2212 | /// count and element type matching the ArrayRef passed in. Note that this | |
2213 | /// can return a ConstantAggregateZero object. | |
2214 | Constant *ConstantDataArray::get(LLVMContext &Context, ArrayRef<uint8_t> Elts) { | |
2215 | Type *Ty = ArrayType::get(Type::getInt8Ty(Context), Elts.size()); | |
2216 | const char *Data = reinterpret_cast<const char *>(Elts.data()); | |
2217 | return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*1), Ty); | |
2218 | } | |
2219 | Constant *ConstantDataArray::get(LLVMContext &Context, ArrayRef<uint16_t> Elts){ | |
2220 | Type *Ty = ArrayType::get(Type::getInt16Ty(Context), Elts.size()); | |
2221 | const char *Data = reinterpret_cast<const char *>(Elts.data()); | |
2222 | return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*2), Ty); | |
2223 | } | |
2224 | Constant *ConstantDataArray::get(LLVMContext &Context, ArrayRef<uint32_t> Elts){ | |
2225 | Type *Ty = ArrayType::get(Type::getInt32Ty(Context), Elts.size()); | |
2226 | const char *Data = reinterpret_cast<const char *>(Elts.data()); | |
2227 | return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*4), Ty); | |
2228 | } | |
2229 | Constant *ConstantDataArray::get(LLVMContext &Context, ArrayRef<uint64_t> Elts){ | |
2230 | Type *Ty = ArrayType::get(Type::getInt64Ty(Context), Elts.size()); | |
2231 | const char *Data = reinterpret_cast<const char *>(Elts.data()); | |
2232 | return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*8), Ty); | |
2233 | } | |
2234 | Constant *ConstantDataArray::get(LLVMContext &Context, ArrayRef<float> Elts) { | |
2235 | Type *Ty = ArrayType::get(Type::getFloatTy(Context), Elts.size()); | |
2236 | const char *Data = reinterpret_cast<const char *>(Elts.data()); | |
2237 | return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*4), Ty); | |
2238 | } | |
2239 | Constant *ConstantDataArray::get(LLVMContext &Context, ArrayRef<double> Elts) { | |
2240 | Type *Ty = ArrayType::get(Type::getDoubleTy(Context), Elts.size()); | |
2241 | const char *Data = reinterpret_cast<const char *>(Elts.data()); | |
2242 | return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*8), Ty); | |
2243 | } | |
2244 | ||
2245 | /// getString - This method constructs a CDS and initializes it with a text | |
2246 | /// string. The default behavior (AddNull==true) causes a null terminator to | |
2247 | /// be placed at the end of the array (increasing the length of the string by | |
2248 | /// one more than the StringRef would normally indicate. Pass AddNull=false | |
2249 | /// to disable this behavior. | |
2250 | Constant *ConstantDataArray::getString(LLVMContext &Context, | |
2251 | StringRef Str, bool AddNull) { | |
2252 | if (!AddNull) { | |
2253 | const uint8_t *Data = reinterpret_cast<const uint8_t *>(Str.data()); | |
2254 | return get(Context, ArrayRef<uint8_t>(const_cast<uint8_t *>(Data), | |
2255 | Str.size())); | |
2256 | } | |
2257 | ||
2258 | SmallVector<uint8_t, 64> ElementVals; | |
2259 | ElementVals.append(Str.begin(), Str.end()); | |
2260 | ElementVals.push_back(0); | |
2261 | return get(Context, ElementVals); | |
2262 | } | |
2263 | ||
2264 | /// get() constructors - Return a constant with vector type with an element | |
2265 | /// count and element type matching the ArrayRef passed in. Note that this | |
2266 | /// can return a ConstantAggregateZero object. | |
2267 | Constant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<uint8_t> Elts){ | |
2268 | Type *Ty = VectorType::get(Type::getInt8Ty(Context), Elts.size()); | |
2269 | const char *Data = reinterpret_cast<const char *>(Elts.data()); | |
2270 | return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*1), Ty); | |
2271 | } | |
2272 | Constant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<uint16_t> Elts){ | |
2273 | Type *Ty = VectorType::get(Type::getInt16Ty(Context), Elts.size()); | |
2274 | const char *Data = reinterpret_cast<const char *>(Elts.data()); | |
2275 | return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*2), Ty); | |
2276 | } | |
2277 | Constant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<uint32_t> Elts){ | |
2278 | Type *Ty = VectorType::get(Type::getInt32Ty(Context), Elts.size()); | |
2279 | const char *Data = reinterpret_cast<const char *>(Elts.data()); | |
2280 | return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*4), Ty); | |
2281 | } | |
2282 | Constant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<uint64_t> Elts){ | |
2283 | Type *Ty = VectorType::get(Type::getInt64Ty(Context), Elts.size()); | |
2284 | const char *Data = reinterpret_cast<const char *>(Elts.data()); | |
2285 | return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*8), Ty); | |
2286 | } | |
2287 | Constant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<float> Elts) { | |
2288 | Type *Ty = VectorType::get(Type::getFloatTy(Context), Elts.size()); | |
2289 | const char *Data = reinterpret_cast<const char *>(Elts.data()); | |
2290 | return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*4), Ty); | |
2291 | } | |
2292 | Constant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<double> Elts) { | |
2293 | Type *Ty = VectorType::get(Type::getDoubleTy(Context), Elts.size()); | |
2294 | const char *Data = reinterpret_cast<const char *>(Elts.data()); | |
2295 | return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*8), Ty); | |
2296 | } | |
2297 | ||
2298 | Constant *ConstantDataVector::getSplat(unsigned NumElts, Constant *V) { | |
2299 | assert(isElementTypeCompatible(V->getType()) && | |
2300 | "Element type not compatible with ConstantData"); | |
2301 | if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) { | |
2302 | if (CI->getType()->isIntegerTy(8)) { | |
2303 | SmallVector<uint8_t, 16> Elts(NumElts, CI->getZExtValue()); | |
2304 | return get(V->getContext(), Elts); | |
2305 | } | |
2306 | if (CI->getType()->isIntegerTy(16)) { | |
2307 | SmallVector<uint16_t, 16> Elts(NumElts, CI->getZExtValue()); | |
2308 | return get(V->getContext(), Elts); | |
2309 | } | |
2310 | if (CI->getType()->isIntegerTy(32)) { | |
2311 | SmallVector<uint32_t, 16> Elts(NumElts, CI->getZExtValue()); | |
2312 | return get(V->getContext(), Elts); | |
2313 | } | |
2314 | assert(CI->getType()->isIntegerTy(64) && "Unsupported ConstantData type"); | |
2315 | SmallVector<uint64_t, 16> Elts(NumElts, CI->getZExtValue()); | |
2316 | return get(V->getContext(), Elts); | |
2317 | } | |
2318 | ||
2319 | if (ConstantFP *CFP = dyn_cast<ConstantFP>(V)) { | |
2320 | if (CFP->getType()->isFloatTy()) { | |
2321 | SmallVector<float, 16> Elts(NumElts, CFP->getValueAPF().convertToFloat()); | |
2322 | return get(V->getContext(), Elts); | |
2323 | } | |
2324 | if (CFP->getType()->isDoubleTy()) { | |
2325 | SmallVector<double, 16> Elts(NumElts, | |
2326 | CFP->getValueAPF().convertToDouble()); | |
2327 | return get(V->getContext(), Elts); | |
2328 | } | |
2329 | } | |
2330 | return ConstantVector::getSplat(NumElts, V); | |
2331 | } | |
2332 | ||
2333 | ||
2334 | /// getElementAsInteger - If this is a sequential container of integers (of | |
2335 | /// any size), return the specified element in the low bits of a uint64_t. | |
2336 | uint64_t ConstantDataSequential::getElementAsInteger(unsigned Elt) const { | |
2337 | assert(isa<IntegerType>(getElementType()) && | |
2338 | "Accessor can only be used when element is an integer"); | |
2339 | const char *EltPtr = getElementPointer(Elt); | |
2340 | ||
2341 | // The data is stored in host byte order, make sure to cast back to the right | |
2342 | // type to load with the right endianness. | |
2343 | switch (getElementType()->getIntegerBitWidth()) { | |
2344 | default: llvm_unreachable("Invalid bitwidth for CDS"); | |
2345 | case 8: | |
2346 | return *const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(EltPtr)); | |
2347 | case 16: | |
2348 | return *const_cast<uint16_t *>(reinterpret_cast<const uint16_t *>(EltPtr)); | |
2349 | case 32: | |
2350 | return *const_cast<uint32_t *>(reinterpret_cast<const uint32_t *>(EltPtr)); | |
2351 | case 64: | |
2352 | return *const_cast<uint64_t *>(reinterpret_cast<const uint64_t *>(EltPtr)); | |
2353 | } | |
2354 | } | |
2355 | ||
2356 | /// getElementAsAPFloat - If this is a sequential container of floating point | |
2357 | /// type, return the specified element as an APFloat. | |
2358 | APFloat ConstantDataSequential::getElementAsAPFloat(unsigned Elt) const { | |
2359 | const char *EltPtr = getElementPointer(Elt); | |
2360 | ||
2361 | switch (getElementType()->getTypeID()) { | |
2362 | default: | |
2363 | llvm_unreachable("Accessor can only be used when element is float/double!"); | |
2364 | case Type::FloatTyID: { | |
2365 | const float *FloatPrt = reinterpret_cast<const float *>(EltPtr); | |
2366 | return APFloat(*const_cast<float *>(FloatPrt)); | |
2367 | } | |
2368 | case Type::DoubleTyID: { | |
2369 | const double *DoublePtr = reinterpret_cast<const double *>(EltPtr); | |
2370 | return APFloat(*const_cast<double *>(DoublePtr)); | |
2371 | } | |
2372 | } | |
2373 | } | |
2374 | ||
2375 | /// getElementAsFloat - If this is an sequential container of floats, return | |
2376 | /// the specified element as a float. | |
2377 | float ConstantDataSequential::getElementAsFloat(unsigned Elt) const { | |
2378 | assert(getElementType()->isFloatTy() && | |
2379 | "Accessor can only be used when element is a 'float'"); | |
2380 | const float *EltPtr = reinterpret_cast<const float *>(getElementPointer(Elt)); | |
2381 | return *const_cast<float *>(EltPtr); | |
2382 | } | |
2383 | ||
2384 | /// getElementAsDouble - If this is an sequential container of doubles, return | |
2385 | /// the specified element as a float. | |
2386 | double ConstantDataSequential::getElementAsDouble(unsigned Elt) const { | |
2387 | assert(getElementType()->isDoubleTy() && | |
2388 | "Accessor can only be used when element is a 'float'"); | |
2389 | const double *EltPtr = | |
2390 | reinterpret_cast<const double *>(getElementPointer(Elt)); | |
2391 | return *const_cast<double *>(EltPtr); | |
2392 | } | |
2393 | ||
2394 | /// getElementAsConstant - Return a Constant for a specified index's element. | |
2395 | /// Note that this has to compute a new constant to return, so it isn't as | |
2396 | /// efficient as getElementAsInteger/Float/Double. | |
2397 | Constant *ConstantDataSequential::getElementAsConstant(unsigned Elt) const { | |
2398 | if (getElementType()->isFloatTy() || getElementType()->isDoubleTy()) | |
2399 | return ConstantFP::get(getContext(), getElementAsAPFloat(Elt)); | |
2400 | ||
2401 | return ConstantInt::get(getElementType(), getElementAsInteger(Elt)); | |
2402 | } | |
2403 | ||
2404 | /// isString - This method returns true if this is an array of i8. | |
2405 | bool ConstantDataSequential::isString() const { | |
2406 | return isa<ArrayType>(getType()) && getElementType()->isIntegerTy(8); | |
2407 | } | |
2408 | ||
2409 | /// isCString - This method returns true if the array "isString", ends with a | |
2410 | /// nul byte, and does not contains any other nul bytes. | |
2411 | bool ConstantDataSequential::isCString() const { | |
2412 | if (!isString()) | |
2413 | return false; | |
2414 | ||
2415 | StringRef Str = getAsString(); | |
2416 | ||
2417 | // The last value must be nul. | |
2418 | if (Str.back() != 0) return false; | |
2419 | ||
2420 | // Other elements must be non-nul. | |
2421 | return Str.drop_back().find(0) == StringRef::npos; | |
2422 | } | |
2423 | ||
2424 | /// getSplatValue - If this is a splat constant, meaning that all of the | |
2425 | /// elements have the same value, return that value. Otherwise return NULL. | |
2426 | Constant *ConstantDataVector::getSplatValue() const { | |
2427 | const char *Base = getRawDataValues().data(); | |
2428 | ||
2429 | // Compare elements 1+ to the 0'th element. | |
2430 | unsigned EltSize = getElementByteSize(); | |
2431 | for (unsigned i = 1, e = getNumElements(); i != e; ++i) | |
2432 | if (memcmp(Base, Base+i*EltSize, EltSize)) | |
2433 | return 0; | |
2434 | ||
2435 | // If they're all the same, return the 0th one as a representative. | |
2436 | return getElementAsConstant(0); | |
2437 | } | |
2438 | ||
2439 | //===----------------------------------------------------------------------===// | |
2440 | // replaceUsesOfWithOnConstant implementations | |
2441 | ||
2442 | /// replaceUsesOfWithOnConstant - Update this constant array to change uses of | |
2443 | /// 'From' to be uses of 'To'. This must update the uniquing data structures | |
2444 | /// etc. | |
2445 | /// | |
2446 | /// Note that we intentionally replace all uses of From with To here. Consider | |
2447 | /// a large array that uses 'From' 1000 times. By handling this case all here, | |
2448 | /// ConstantArray::replaceUsesOfWithOnConstant is only invoked once, and that | |
2449 | /// single invocation handles all 1000 uses. Handling them one at a time would | |
2450 | /// work, but would be really slow because it would have to unique each updated | |
2451 | /// array instance. | |
2452 | /// | |
2453 | void ConstantArray::replaceUsesOfWithOnConstant(Value *From, Value *To, | |
2454 | Use *U) { | |
2455 | assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!"); | |
2456 | Constant *ToC = cast<Constant>(To); | |
2457 | ||
2458 | LLVMContextImpl *pImpl = getType()->getContext().pImpl; | |
2459 | ||
2460 | SmallVector<Constant*, 8> Values; | |
2461 | LLVMContextImpl::ArrayConstantsTy::LookupKey Lookup; | |
2462 | Lookup.first = cast<ArrayType>(getType()); | |
2463 | Values.reserve(getNumOperands()); // Build replacement array. | |
2464 | ||
2465 | // Fill values with the modified operands of the constant array. Also, | |
2466 | // compute whether this turns into an all-zeros array. | |
2467 | unsigned NumUpdated = 0; | |
2468 | ||
2469 | // Keep track of whether all the values in the array are "ToC". | |
2470 | bool AllSame = true; | |
2471 | for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) { | |
2472 | Constant *Val = cast<Constant>(O->get()); | |
2473 | if (Val == From) { | |
2474 | Val = ToC; | |
2475 | ++NumUpdated; | |
2476 | } | |
2477 | Values.push_back(Val); | |
2478 | AllSame &= Val == ToC; | |
2479 | } | |
2480 | ||
2481 | Constant *Replacement = 0; | |
2482 | if (AllSame && ToC->isNullValue()) { | |
2483 | Replacement = ConstantAggregateZero::get(getType()); | |
2484 | } else if (AllSame && isa<UndefValue>(ToC)) { | |
2485 | Replacement = UndefValue::get(getType()); | |
2486 | } else { | |
2487 | // Check to see if we have this array type already. | |
2488 | Lookup.second = makeArrayRef(Values); | |
2489 | LLVMContextImpl::ArrayConstantsTy::MapTy::iterator I = | |
2490 | pImpl->ArrayConstants.find(Lookup); | |
2491 | ||
2492 | if (I != pImpl->ArrayConstants.map_end()) { | |
2493 | Replacement = I->first; | |
2494 | } else { | |
2495 | // Okay, the new shape doesn't exist in the system yet. Instead of | |
2496 | // creating a new constant array, inserting it, replaceallusesof'ing the | |
2497 | // old with the new, then deleting the old... just update the current one | |
2498 | // in place! | |
2499 | pImpl->ArrayConstants.remove(this); | |
2500 | ||
2501 | // Update to the new value. Optimize for the case when we have a single | |
2502 | // operand that we're changing, but handle bulk updates efficiently. | |
2503 | if (NumUpdated == 1) { | |
2504 | unsigned OperandToUpdate = U - OperandList; | |
2505 | assert(getOperand(OperandToUpdate) == From && | |
2506 | "ReplaceAllUsesWith broken!"); | |
2507 | setOperand(OperandToUpdate, ToC); | |
2508 | } else { | |
2509 | for (unsigned i = 0, e = getNumOperands(); i != e; ++i) | |
2510 | if (getOperand(i) == From) | |
2511 | setOperand(i, ToC); | |
2512 | } | |
2513 | pImpl->ArrayConstants.insert(this); | |
2514 | return; | |
2515 | } | |
2516 | } | |
2517 | ||
2518 | // Otherwise, I do need to replace this with an existing value. | |
2519 | assert(Replacement != this && "I didn't contain From!"); | |
2520 | ||
2521 | // Everyone using this now uses the replacement. | |
2522 | replaceAllUsesWith(Replacement); | |
2523 | ||
2524 | // Delete the old constant! | |
2525 | destroyConstant(); | |
2526 | } | |
2527 | ||
2528 | void ConstantStruct::replaceUsesOfWithOnConstant(Value *From, Value *To, | |
2529 | Use *U) { | |
2530 | assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!"); | |
2531 | Constant *ToC = cast<Constant>(To); | |
2532 | ||
2533 | unsigned OperandToUpdate = U-OperandList; | |
2534 | assert(getOperand(OperandToUpdate) == From && "ReplaceAllUsesWith broken!"); | |
2535 | ||
2536 | SmallVector<Constant*, 8> Values; | |
2537 | LLVMContextImpl::StructConstantsTy::LookupKey Lookup; | |
2538 | Lookup.first = cast<StructType>(getType()); | |
2539 | Values.reserve(getNumOperands()); // Build replacement struct. | |
2540 | ||
2541 | // Fill values with the modified operands of the constant struct. Also, | |
2542 | // compute whether this turns into an all-zeros struct. | |
2543 | bool isAllZeros = false; | |
2544 | bool isAllUndef = false; | |
2545 | if (ToC->isNullValue()) { | |
2546 | isAllZeros = true; | |
2547 | for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) { | |
2548 | Constant *Val = cast<Constant>(O->get()); | |
2549 | Values.push_back(Val); | |
2550 | if (isAllZeros) isAllZeros = Val->isNullValue(); | |
2551 | } | |
2552 | } else if (isa<UndefValue>(ToC)) { | |
2553 | isAllUndef = true; | |
2554 | for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) { | |
2555 | Constant *Val = cast<Constant>(O->get()); | |
2556 | Values.push_back(Val); | |
2557 | if (isAllUndef) isAllUndef = isa<UndefValue>(Val); | |
2558 | } | |
2559 | } else { | |
2560 | for (Use *O = OperandList, *E = OperandList + getNumOperands(); O != E; ++O) | |
2561 | Values.push_back(cast<Constant>(O->get())); | |
2562 | } | |
2563 | Values[OperandToUpdate] = ToC; | |
2564 | ||
2565 | LLVMContextImpl *pImpl = getContext().pImpl; | |
2566 | ||
2567 | Constant *Replacement = 0; | |
2568 | if (isAllZeros) { | |
2569 | Replacement = ConstantAggregateZero::get(getType()); | |
2570 | } else if (isAllUndef) { | |
2571 | Replacement = UndefValue::get(getType()); | |
2572 | } else { | |
2573 | // Check to see if we have this struct type already. | |
2574 | Lookup.second = makeArrayRef(Values); | |
2575 | LLVMContextImpl::StructConstantsTy::MapTy::iterator I = | |
2576 | pImpl->StructConstants.find(Lookup); | |
2577 | ||
2578 | if (I != pImpl->StructConstants.map_end()) { | |
2579 | Replacement = I->first; | |
2580 | } else { | |
2581 | // Okay, the new shape doesn't exist in the system yet. Instead of | |
2582 | // creating a new constant struct, inserting it, replaceallusesof'ing the | |
2583 | // old with the new, then deleting the old... just update the current one | |
2584 | // in place! | |
2585 | pImpl->StructConstants.remove(this); | |
2586 | ||
2587 | // Update to the new value. | |
2588 | setOperand(OperandToUpdate, ToC); | |
2589 | pImpl->StructConstants.insert(this); | |
2590 | return; | |
2591 | } | |
2592 | } | |
2593 | ||
2594 | assert(Replacement != this && "I didn't contain From!"); | |
2595 | ||
2596 | // Everyone using this now uses the replacement. | |
2597 | replaceAllUsesWith(Replacement); | |
2598 | ||
2599 | // Delete the old constant! | |
2600 | destroyConstant(); | |
2601 | } | |
2602 | ||
2603 | void ConstantVector::replaceUsesOfWithOnConstant(Value *From, Value *To, | |
2604 | Use *U) { | |
2605 | assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!"); | |
2606 | ||
2607 | SmallVector<Constant*, 8> Values; | |
2608 | Values.reserve(getNumOperands()); // Build replacement array... | |
2609 | for (unsigned i = 0, e = getNumOperands(); i != e; ++i) { | |
2610 | Constant *Val = getOperand(i); | |
2611 | if (Val == From) Val = cast<Constant>(To); | |
2612 | Values.push_back(Val); | |
2613 | } | |
2614 | ||
2615 | Constant *Replacement = get(Values); | |
2616 | assert(Replacement != this && "I didn't contain From!"); | |
2617 | ||
2618 | // Everyone using this now uses the replacement. | |
2619 | replaceAllUsesWith(Replacement); | |
2620 | ||
2621 | // Delete the old constant! | |
2622 | destroyConstant(); | |
2623 | } | |
2624 | ||
2625 | void ConstantExpr::replaceUsesOfWithOnConstant(Value *From, Value *ToV, | |
2626 | Use *U) { | |
2627 | assert(isa<Constant>(ToV) && "Cannot make Constant refer to non-constant!"); | |
2628 | Constant *To = cast<Constant>(ToV); | |
2629 | ||
2630 | SmallVector<Constant*, 8> NewOps; | |
2631 | for (unsigned i = 0, e = getNumOperands(); i != e; ++i) { | |
2632 | Constant *Op = getOperand(i); | |
2633 | NewOps.push_back(Op == From ? To : Op); | |
2634 | } | |
2635 | ||
2636 | Constant *Replacement = getWithOperands(NewOps); | |
2637 | assert(Replacement != this && "I didn't contain From!"); | |
2638 | ||
2639 | // Everyone using this now uses the replacement. | |
2640 | replaceAllUsesWith(Replacement); | |
2641 | ||
2642 | // Delete the old constant! | |
2643 | destroyConstant(); | |
2644 | } |