1 //===-- Constants.cpp - Implement Constant nodes --------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the Constant* classes.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "llvm/IR/Constants.h"
14 #include "ConstantFold.h"
15 #include "LLVMContextImpl.h"
16 #include "llvm/ADT/STLExtras.h"
17 #include "llvm/ADT/SmallVector.h"
18 #include "llvm/ADT/StringMap.h"
19 #include "llvm/IR/DerivedTypes.h"
20 #include "llvm/IR/GetElementPtrTypeIterator.h"
21 #include "llvm/IR/GlobalValue.h"
22 #include "llvm/IR/Instructions.h"
23 #include "llvm/IR/Module.h"
24 #include "llvm/IR/Operator.h"
25 #include "llvm/IR/PatternMatch.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 <algorithm>
32
33 using namespace llvm;
34 using namespace PatternMatch;
35
36 //===----------------------------------------------------------------------===//
37 // Constant Class
38 //===----------------------------------------------------------------------===//
39
isNegativeZeroValue() const40 bool Constant::isNegativeZeroValue() const {
41 // Floating point values have an explicit -0.0 value.
42 if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
43 return CFP->isZero() && CFP->isNegative();
44
45 // Equivalent for a vector of -0.0's.
46 if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this))
47 if (CV->getElementType()->isFloatingPointTy() && CV->isSplat())
48 if (CV->getElementAsAPFloat(0).isNegZero())
49 return true;
50
51 if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
52 if (ConstantFP *SplatCFP = dyn_cast_or_null<ConstantFP>(CV->getSplatValue()))
53 if (SplatCFP && SplatCFP->isZero() && SplatCFP->isNegative())
54 return true;
55
56 // We've already handled true FP case; any other FP vectors can't represent -0.0.
57 if (getType()->isFPOrFPVectorTy())
58 return false;
59
60 // Otherwise, just use +0.0.
61 return isNullValue();
62 }
63
64 // Return true iff this constant is positive zero (floating point), negative
65 // zero (floating point), or a null value.
isZeroValue() const66 bool Constant::isZeroValue() const {
67 // Floating point values have an explicit -0.0 value.
68 if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
69 return CFP->isZero();
70
71 // Equivalent for a vector of -0.0's.
72 if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this))
73 if (CV->getElementType()->isFloatingPointTy() && CV->isSplat())
74 if (CV->getElementAsAPFloat(0).isZero())
75 return true;
76
77 if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
78 if (ConstantFP *SplatCFP = dyn_cast_or_null<ConstantFP>(CV->getSplatValue()))
79 if (SplatCFP && SplatCFP->isZero())
80 return true;
81
82 // Otherwise, just use +0.0.
83 return isNullValue();
84 }
85
isNullValue() const86 bool Constant::isNullValue() const {
87 // 0 is null.
88 if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
89 return CI->isZero();
90
91 // +0.0 is null.
92 if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
93 return CFP->isZero() && !CFP->isNegative();
94
95 // constant zero is zero for aggregates, cpnull is null for pointers, none for
96 // tokens.
97 return isa<ConstantAggregateZero>(this) || isa<ConstantPointerNull>(this) ||
98 isa<ConstantTokenNone>(this);
99 }
100
isAllOnesValue() const101 bool Constant::isAllOnesValue() const {
102 // Check for -1 integers
103 if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
104 return CI->isMinusOne();
105
106 // Check for FP which are bitcasted from -1 integers
107 if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
108 return CFP->getValueAPF().bitcastToAPInt().isAllOnesValue();
109
110 // Check for constant vectors which are splats of -1 values.
111 if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
112 if (Constant *Splat = CV->getSplatValue())
113 return Splat->isAllOnesValue();
114
115 // Check for constant vectors which are splats of -1 values.
116 if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this)) {
117 if (CV->isSplat()) {
118 if (CV->getElementType()->isFloatingPointTy())
119 return CV->getElementAsAPFloat(0).bitcastToAPInt().isAllOnesValue();
120 return CV->getElementAsAPInt(0).isAllOnesValue();
121 }
122 }
123
124 return false;
125 }
126
isOneValue() const127 bool Constant::isOneValue() const {
128 // Check for 1 integers
129 if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
130 return CI->isOne();
131
132 // Check for FP which are bitcasted from 1 integers
133 if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
134 return CFP->getValueAPF().bitcastToAPInt().isOneValue();
135
136 // Check for constant vectors which are splats of 1 values.
137 if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
138 if (Constant *Splat = CV->getSplatValue())
139 return Splat->isOneValue();
140
141 // Check for constant vectors which are splats of 1 values.
142 if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this)) {
143 if (CV->isSplat()) {
144 if (CV->getElementType()->isFloatingPointTy())
145 return CV->getElementAsAPFloat(0).bitcastToAPInt().isOneValue();
146 return CV->getElementAsAPInt(0).isOneValue();
147 }
148 }
149
150 return false;
151 }
152
isNotOneValue() const153 bool Constant::isNotOneValue() const {
154 // Check for 1 integers
155 if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
156 return !CI->isOneValue();
157
158 // Check for FP which are bitcasted from 1 integers
159 if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
160 return !CFP->getValueAPF().bitcastToAPInt().isOneValue();
161
162 // Check that vectors don't contain 1
163 if (auto *VTy = dyn_cast<VectorType>(this->getType())) {
164 unsigned NumElts = cast<FixedVectorType>(VTy)->getNumElements();
165 for (unsigned i = 0; i != NumElts; ++i) {
166 Constant *Elt = this->getAggregateElement(i);
167 if (!Elt || !Elt->isNotOneValue())
168 return false;
169 }
170 return true;
171 }
172
173 // It *may* contain 1, we can't tell.
174 return false;
175 }
176
isMinSignedValue() const177 bool Constant::isMinSignedValue() const {
178 // Check for INT_MIN integers
179 if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
180 return CI->isMinValue(/*isSigned=*/true);
181
182 // Check for FP which are bitcasted from INT_MIN integers
183 if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
184 return CFP->getValueAPF().bitcastToAPInt().isMinSignedValue();
185
186 // Check for constant vectors which are splats of INT_MIN values.
187 if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
188 if (Constant *Splat = CV->getSplatValue())
189 return Splat->isMinSignedValue();
190
191 // Check for constant vectors which are splats of INT_MIN values.
192 if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this)) {
193 if (CV->isSplat()) {
194 if (CV->getElementType()->isFloatingPointTy())
195 return CV->getElementAsAPFloat(0).bitcastToAPInt().isMinSignedValue();
196 return CV->getElementAsAPInt(0).isMinSignedValue();
197 }
198 }
199
200 return false;
201 }
202
isNotMinSignedValue() const203 bool Constant::isNotMinSignedValue() const {
204 // Check for INT_MIN integers
205 if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
206 return !CI->isMinValue(/*isSigned=*/true);
207
208 // Check for FP which are bitcasted from INT_MIN integers
209 if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
210 return !CFP->getValueAPF().bitcastToAPInt().isMinSignedValue();
211
212 // Check that vectors don't contain INT_MIN
213 if (auto *VTy = dyn_cast<VectorType>(this->getType())) {
214 unsigned NumElts = cast<FixedVectorType>(VTy)->getNumElements();
215 for (unsigned i = 0; i != NumElts; ++i) {
216 Constant *Elt = this->getAggregateElement(i);
217 if (!Elt || !Elt->isNotMinSignedValue())
218 return false;
219 }
220 return true;
221 }
222
223 // It *may* contain INT_MIN, we can't tell.
224 return false;
225 }
226
isFiniteNonZeroFP() const227 bool Constant::isFiniteNonZeroFP() const {
228 if (auto *CFP = dyn_cast<ConstantFP>(this))
229 return CFP->getValueAPF().isFiniteNonZero();
230 auto *VTy = dyn_cast<FixedVectorType>(getType());
231 if (!VTy)
232 return false;
233 for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
234 auto *CFP = dyn_cast_or_null<ConstantFP>(this->getAggregateElement(i));
235 if (!CFP || !CFP->getValueAPF().isFiniteNonZero())
236 return false;
237 }
238 return true;
239 }
240
isNormalFP() const241 bool Constant::isNormalFP() const {
242 if (auto *CFP = dyn_cast<ConstantFP>(this))
243 return CFP->getValueAPF().isNormal();
244 auto *VTy = dyn_cast<FixedVectorType>(getType());
245 if (!VTy)
246 return false;
247 for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
248 auto *CFP = dyn_cast_or_null<ConstantFP>(this->getAggregateElement(i));
249 if (!CFP || !CFP->getValueAPF().isNormal())
250 return false;
251 }
252 return true;
253 }
254
hasExactInverseFP() const255 bool Constant::hasExactInverseFP() const {
256 if (auto *CFP = dyn_cast<ConstantFP>(this))
257 return CFP->getValueAPF().getExactInverse(nullptr);
258 auto *VTy = dyn_cast<FixedVectorType>(getType());
259 if (!VTy)
260 return false;
261 for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
262 auto *CFP = dyn_cast_or_null<ConstantFP>(this->getAggregateElement(i));
263 if (!CFP || !CFP->getValueAPF().getExactInverse(nullptr))
264 return false;
265 }
266 return true;
267 }
268
isNaN() const269 bool Constant::isNaN() const {
270 if (auto *CFP = dyn_cast<ConstantFP>(this))
271 return CFP->isNaN();
272 auto *VTy = dyn_cast<FixedVectorType>(getType());
273 if (!VTy)
274 return false;
275 for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
276 auto *CFP = dyn_cast_or_null<ConstantFP>(this->getAggregateElement(i));
277 if (!CFP || !CFP->isNaN())
278 return false;
279 }
280 return true;
281 }
282
isElementWiseEqual(Value * Y) const283 bool Constant::isElementWiseEqual(Value *Y) const {
284 // Are they fully identical?
285 if (this == Y)
286 return true;
287
288 // The input value must be a vector constant with the same type.
289 auto *VTy = dyn_cast<VectorType>(getType());
290 if (!isa<Constant>(Y) || !VTy || VTy != Y->getType())
291 return false;
292
293 // TODO: Compare pointer constants?
294 if (!(VTy->getElementType()->isIntegerTy() ||
295 VTy->getElementType()->isFloatingPointTy()))
296 return false;
297
298 // They may still be identical element-wise (if they have `undef`s).
299 // Bitcast to integer to allow exact bitwise comparison for all types.
300 Type *IntTy = VectorType::getInteger(VTy);
301 Constant *C0 = ConstantExpr::getBitCast(const_cast<Constant *>(this), IntTy);
302 Constant *C1 = ConstantExpr::getBitCast(cast<Constant>(Y), IntTy);
303 Constant *CmpEq = ConstantExpr::getICmp(ICmpInst::ICMP_EQ, C0, C1);
304 return isa<UndefValue>(CmpEq) || match(CmpEq, m_One());
305 }
306
307 static bool
containsUndefinedElement(const Constant * C,function_ref<bool (const Constant *)> HasFn)308 containsUndefinedElement(const Constant *C,
309 function_ref<bool(const Constant *)> HasFn) {
310 if (auto *VTy = dyn_cast<VectorType>(C->getType())) {
311 if (HasFn(C))
312 return true;
313 if (isa<ConstantAggregateZero>(C))
314 return false;
315 if (isa<ScalableVectorType>(C->getType()))
316 return false;
317
318 for (unsigned i = 0, e = cast<FixedVectorType>(VTy)->getNumElements();
319 i != e; ++i)
320 if (HasFn(C->getAggregateElement(i)))
321 return true;
322 }
323
324 return false;
325 }
326
containsUndefOrPoisonElement() const327 bool Constant::containsUndefOrPoisonElement() const {
328 return containsUndefinedElement(
329 this, [&](const auto *C) { return isa<UndefValue>(C); });
330 }
331
containsPoisonElement() const332 bool Constant::containsPoisonElement() const {
333 return containsUndefinedElement(
334 this, [&](const auto *C) { return isa<PoisonValue>(C); });
335 }
336
containsConstantExpression() const337 bool Constant::containsConstantExpression() const {
338 if (auto *VTy = dyn_cast<FixedVectorType>(getType())) {
339 for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i)
340 if (isa<ConstantExpr>(getAggregateElement(i)))
341 return true;
342 }
343 return false;
344 }
345
346 /// Constructor to create a '0' constant of arbitrary type.
getNullValue(Type * Ty)347 Constant *Constant::getNullValue(Type *Ty) {
348 switch (Ty->getTypeID()) {
349 case Type::IntegerTyID:
350 return ConstantInt::get(Ty, 0);
351 case Type::HalfTyID:
352 return ConstantFP::get(Ty->getContext(),
353 APFloat::getZero(APFloat::IEEEhalf()));
354 case Type::BFloatTyID:
355 return ConstantFP::get(Ty->getContext(),
356 APFloat::getZero(APFloat::BFloat()));
357 case Type::FloatTyID:
358 return ConstantFP::get(Ty->getContext(),
359 APFloat::getZero(APFloat::IEEEsingle()));
360 case Type::DoubleTyID:
361 return ConstantFP::get(Ty->getContext(),
362 APFloat::getZero(APFloat::IEEEdouble()));
363 case Type::X86_FP80TyID:
364 return ConstantFP::get(Ty->getContext(),
365 APFloat::getZero(APFloat::x87DoubleExtended()));
366 case Type::FP128TyID:
367 return ConstantFP::get(Ty->getContext(),
368 APFloat::getZero(APFloat::IEEEquad()));
369 case Type::PPC_FP128TyID:
370 return ConstantFP::get(Ty->getContext(),
371 APFloat(APFloat::PPCDoubleDouble(),
372 APInt::getNullValue(128)));
373 case Type::PointerTyID:
374 return ConstantPointerNull::get(cast<PointerType>(Ty));
375 case Type::StructTyID:
376 case Type::ArrayTyID:
377 case Type::FixedVectorTyID:
378 case Type::ScalableVectorTyID:
379 return ConstantAggregateZero::get(Ty);
380 case Type::TokenTyID:
381 return ConstantTokenNone::get(Ty->getContext());
382 default:
383 // Function, Label, or Opaque type?
384 llvm_unreachable("Cannot create a null constant of that type!");
385 }
386 }
387
getIntegerValue(Type * Ty,const APInt & V)388 Constant *Constant::getIntegerValue(Type *Ty, const APInt &V) {
389 Type *ScalarTy = Ty->getScalarType();
390
391 // Create the base integer constant.
392 Constant *C = ConstantInt::get(Ty->getContext(), V);
393
394 // Convert an integer to a pointer, if necessary.
395 if (PointerType *PTy = dyn_cast<PointerType>(ScalarTy))
396 C = ConstantExpr::getIntToPtr(C, PTy);
397
398 // Broadcast a scalar to a vector, if necessary.
399 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
400 C = ConstantVector::getSplat(VTy->getElementCount(), C);
401
402 return C;
403 }
404
getAllOnesValue(Type * Ty)405 Constant *Constant::getAllOnesValue(Type *Ty) {
406 if (IntegerType *ITy = dyn_cast<IntegerType>(Ty))
407 return ConstantInt::get(Ty->getContext(),
408 APInt::getAllOnesValue(ITy->getBitWidth()));
409
410 if (Ty->isFloatingPointTy()) {
411 APFloat FL = APFloat::getAllOnesValue(Ty->getFltSemantics(),
412 Ty->getPrimitiveSizeInBits());
413 return ConstantFP::get(Ty->getContext(), FL);
414 }
415
416 VectorType *VTy = cast<VectorType>(Ty);
417 return ConstantVector::getSplat(VTy->getElementCount(),
418 getAllOnesValue(VTy->getElementType()));
419 }
420
getAggregateElement(unsigned Elt) const421 Constant *Constant::getAggregateElement(unsigned Elt) const {
422 assert((getType()->isAggregateType() || getType()->isVectorTy()) &&
423 "Must be an aggregate/vector constant");
424
425 if (const auto *CC = dyn_cast<ConstantAggregate>(this))
426 return Elt < CC->getNumOperands() ? CC->getOperand(Elt) : nullptr;
427
428 if (const auto *CAZ = dyn_cast<ConstantAggregateZero>(this))
429 return Elt < CAZ->getElementCount().getKnownMinValue()
430 ? CAZ->getElementValue(Elt)
431 : nullptr;
432
433 // FIXME: getNumElements() will fail for non-fixed vector types.
434 if (isa<ScalableVectorType>(getType()))
435 return nullptr;
436
437 if (const auto *PV = dyn_cast<PoisonValue>(this))
438 return Elt < PV->getNumElements() ? PV->getElementValue(Elt) : nullptr;
439
440 if (const auto *UV = dyn_cast<UndefValue>(this))
441 return Elt < UV->getNumElements() ? UV->getElementValue(Elt) : nullptr;
442
443 if (const auto *CDS = dyn_cast<ConstantDataSequential>(this))
444 return Elt < CDS->getNumElements() ? CDS->getElementAsConstant(Elt)
445 : nullptr;
446 return nullptr;
447 }
448
getAggregateElement(Constant * Elt) const449 Constant *Constant::getAggregateElement(Constant *Elt) const {
450 assert(isa<IntegerType>(Elt->getType()) && "Index must be an integer");
451 if (ConstantInt *CI = dyn_cast<ConstantInt>(Elt)) {
452 // Check if the constant fits into an uint64_t.
453 if (CI->getValue().getActiveBits() > 64)
454 return nullptr;
455 return getAggregateElement(CI->getZExtValue());
456 }
457 return nullptr;
458 }
459
destroyConstant()460 void Constant::destroyConstant() {
461 /// First call destroyConstantImpl on the subclass. This gives the subclass
462 /// a chance to remove the constant from any maps/pools it's contained in.
463 switch (getValueID()) {
464 default:
465 llvm_unreachable("Not a constant!");
466 #define HANDLE_CONSTANT(Name) \
467 case Value::Name##Val: \
468 cast<Name>(this)->destroyConstantImpl(); \
469 break;
470 #include "llvm/IR/Value.def"
471 }
472
473 // When a Constant is destroyed, there may be lingering
474 // references to the constant by other constants in the constant pool. These
475 // constants are implicitly dependent on the module that is being deleted,
476 // but they don't know that. Because we only find out when the CPV is
477 // deleted, we must now notify all of our users (that should only be
478 // Constants) that they are, in fact, invalid now and should be deleted.
479 //
480 while (!use_empty()) {
481 Value *V = user_back();
482 #ifndef NDEBUG // Only in -g mode...
483 if (!isa<Constant>(V)) {
484 dbgs() << "While deleting: " << *this
485 << "\n\nUse still stuck around after Def is destroyed: " << *V
486 << "\n\n";
487 }
488 #endif
489 assert(isa<Constant>(V) && "References remain to Constant being destroyed");
490 cast<Constant>(V)->destroyConstant();
491
492 // The constant should remove itself from our use list...
493 assert((use_empty() || user_back() != V) && "Constant not removed!");
494 }
495
496 // Value has no outstanding references it is safe to delete it now...
497 deleteConstant(this);
498 }
499
deleteConstant(Constant * C)500 void llvm::deleteConstant(Constant *C) {
501 switch (C->getValueID()) {
502 case Constant::ConstantIntVal:
503 delete static_cast<ConstantInt *>(C);
504 break;
505 case Constant::ConstantFPVal:
506 delete static_cast<ConstantFP *>(C);
507 break;
508 case Constant::ConstantAggregateZeroVal:
509 delete static_cast<ConstantAggregateZero *>(C);
510 break;
511 case Constant::ConstantArrayVal:
512 delete static_cast<ConstantArray *>(C);
513 break;
514 case Constant::ConstantStructVal:
515 delete static_cast<ConstantStruct *>(C);
516 break;
517 case Constant::ConstantVectorVal:
518 delete static_cast<ConstantVector *>(C);
519 break;
520 case Constant::ConstantPointerNullVal:
521 delete static_cast<ConstantPointerNull *>(C);
522 break;
523 case Constant::ConstantDataArrayVal:
524 delete static_cast<ConstantDataArray *>(C);
525 break;
526 case Constant::ConstantDataVectorVal:
527 delete static_cast<ConstantDataVector *>(C);
528 break;
529 case Constant::ConstantTokenNoneVal:
530 delete static_cast<ConstantTokenNone *>(C);
531 break;
532 case Constant::BlockAddressVal:
533 delete static_cast<BlockAddress *>(C);
534 break;
535 case Constant::DSOLocalEquivalentVal:
536 delete static_cast<DSOLocalEquivalent *>(C);
537 break;
538 case Constant::UndefValueVal:
539 delete static_cast<UndefValue *>(C);
540 break;
541 case Constant::PoisonValueVal:
542 delete static_cast<PoisonValue *>(C);
543 break;
544 case Constant::ConstantExprVal:
545 if (isa<UnaryConstantExpr>(C))
546 delete static_cast<UnaryConstantExpr *>(C);
547 else if (isa<BinaryConstantExpr>(C))
548 delete static_cast<BinaryConstantExpr *>(C);
549 else if (isa<SelectConstantExpr>(C))
550 delete static_cast<SelectConstantExpr *>(C);
551 else if (isa<ExtractElementConstantExpr>(C))
552 delete static_cast<ExtractElementConstantExpr *>(C);
553 else if (isa<InsertElementConstantExpr>(C))
554 delete static_cast<InsertElementConstantExpr *>(C);
555 else if (isa<ShuffleVectorConstantExpr>(C))
556 delete static_cast<ShuffleVectorConstantExpr *>(C);
557 else if (isa<ExtractValueConstantExpr>(C))
558 delete static_cast<ExtractValueConstantExpr *>(C);
559 else if (isa<InsertValueConstantExpr>(C))
560 delete static_cast<InsertValueConstantExpr *>(C);
561 else if (isa<GetElementPtrConstantExpr>(C))
562 delete static_cast<GetElementPtrConstantExpr *>(C);
563 else if (isa<CompareConstantExpr>(C))
564 delete static_cast<CompareConstantExpr *>(C);
565 else
566 llvm_unreachable("Unexpected constant expr");
567 break;
568 default:
569 llvm_unreachable("Unexpected constant");
570 }
571 }
572
canTrapImpl(const Constant * C,SmallPtrSetImpl<const ConstantExpr * > & NonTrappingOps)573 static bool canTrapImpl(const Constant *C,
574 SmallPtrSetImpl<const ConstantExpr *> &NonTrappingOps) {
575 assert(C->getType()->isFirstClassType() && "Cannot evaluate aggregate vals!");
576 // The only thing that could possibly trap are constant exprs.
577 const ConstantExpr *CE = dyn_cast<ConstantExpr>(C);
578 if (!CE)
579 return false;
580
581 // ConstantExpr traps if any operands can trap.
582 for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) {
583 if (ConstantExpr *Op = dyn_cast<ConstantExpr>(CE->getOperand(i))) {
584 if (NonTrappingOps.insert(Op).second && canTrapImpl(Op, NonTrappingOps))
585 return true;
586 }
587 }
588
589 // Otherwise, only specific operations can trap.
590 switch (CE->getOpcode()) {
591 default:
592 return false;
593 case Instruction::UDiv:
594 case Instruction::SDiv:
595 case Instruction::URem:
596 case Instruction::SRem:
597 // Div and rem can trap if the RHS is not known to be non-zero.
598 if (!isa<ConstantInt>(CE->getOperand(1)) ||CE->getOperand(1)->isNullValue())
599 return true;
600 return false;
601 }
602 }
603
canTrap() const604 bool Constant::canTrap() const {
605 SmallPtrSet<const ConstantExpr *, 4> NonTrappingOps;
606 return canTrapImpl(this, NonTrappingOps);
607 }
608
609 /// Check if C contains a GlobalValue for which Predicate is true.
610 static bool
ConstHasGlobalValuePredicate(const Constant * C,bool (* Predicate)(const GlobalValue *))611 ConstHasGlobalValuePredicate(const Constant *C,
612 bool (*Predicate)(const GlobalValue *)) {
613 SmallPtrSet<const Constant *, 8> Visited;
614 SmallVector<const Constant *, 8> WorkList;
615 WorkList.push_back(C);
616 Visited.insert(C);
617
618 while (!WorkList.empty()) {
619 const Constant *WorkItem = WorkList.pop_back_val();
620 if (const auto *GV = dyn_cast<GlobalValue>(WorkItem))
621 if (Predicate(GV))
622 return true;
623 for (const Value *Op : WorkItem->operands()) {
624 const Constant *ConstOp = dyn_cast<Constant>(Op);
625 if (!ConstOp)
626 continue;
627 if (Visited.insert(ConstOp).second)
628 WorkList.push_back(ConstOp);
629 }
630 }
631 return false;
632 }
633
isThreadDependent() const634 bool Constant::isThreadDependent() const {
635 auto DLLImportPredicate = [](const GlobalValue *GV) {
636 return GV->isThreadLocal();
637 };
638 return ConstHasGlobalValuePredicate(this, DLLImportPredicate);
639 }
640
isDLLImportDependent() const641 bool Constant::isDLLImportDependent() const {
642 auto DLLImportPredicate = [](const GlobalValue *GV) {
643 return GV->hasDLLImportStorageClass();
644 };
645 return ConstHasGlobalValuePredicate(this, DLLImportPredicate);
646 }
647
isConstantUsed() const648 bool Constant::isConstantUsed() const {
649 for (const User *U : users()) {
650 const Constant *UC = dyn_cast<Constant>(U);
651 if (!UC || isa<GlobalValue>(UC))
652 return true;
653
654 if (UC->isConstantUsed())
655 return true;
656 }
657 return false;
658 }
659
needsDynamicRelocation() const660 bool Constant::needsDynamicRelocation() const {
661 return getRelocationInfo() == GlobalRelocation;
662 }
663
needsRelocation() const664 bool Constant::needsRelocation() const {
665 return getRelocationInfo() != NoRelocation;
666 }
667
getRelocationInfo() const668 Constant::PossibleRelocationsTy Constant::getRelocationInfo() const {
669 if (isa<GlobalValue>(this))
670 return GlobalRelocation; // Global reference.
671
672 if (const BlockAddress *BA = dyn_cast<BlockAddress>(this))
673 return BA->getFunction()->getRelocationInfo();
674
675 if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(this)) {
676 if (CE->getOpcode() == Instruction::Sub) {
677 ConstantExpr *LHS = dyn_cast<ConstantExpr>(CE->getOperand(0));
678 ConstantExpr *RHS = dyn_cast<ConstantExpr>(CE->getOperand(1));
679 if (LHS && RHS && LHS->getOpcode() == Instruction::PtrToInt &&
680 RHS->getOpcode() == Instruction::PtrToInt) {
681 Constant *LHSOp0 = LHS->getOperand(0);
682 Constant *RHSOp0 = RHS->getOperand(0);
683
684 // While raw uses of blockaddress need to be relocated, differences
685 // between two of them don't when they are for labels in the same
686 // function. This is a common idiom when creating a table for the
687 // indirect goto extension, so we handle it efficiently here.
688 if (isa<BlockAddress>(LHSOp0) && isa<BlockAddress>(RHSOp0) &&
689 cast<BlockAddress>(LHSOp0)->getFunction() ==
690 cast<BlockAddress>(RHSOp0)->getFunction())
691 return NoRelocation;
692
693 // Relative pointers do not need to be dynamically relocated.
694 if (auto *RHSGV =
695 dyn_cast<GlobalValue>(RHSOp0->stripInBoundsConstantOffsets())) {
696 auto *LHS = LHSOp0->stripInBoundsConstantOffsets();
697 if (auto *LHSGV = dyn_cast<GlobalValue>(LHS)) {
698 if (LHSGV->isDSOLocal() && RHSGV->isDSOLocal())
699 return LocalRelocation;
700 } else if (isa<DSOLocalEquivalent>(LHS)) {
701 if (RHSGV->isDSOLocal())
702 return LocalRelocation;
703 }
704 }
705 }
706 }
707 }
708
709 PossibleRelocationsTy Result = NoRelocation;
710 for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
711 Result =
712 std::max(cast<Constant>(getOperand(i))->getRelocationInfo(), Result);
713
714 return Result;
715 }
716
717 /// If the specified constantexpr is dead, remove it. This involves recursively
718 /// eliminating any dead users of the constantexpr.
removeDeadUsersOfConstant(const Constant * C)719 static bool removeDeadUsersOfConstant(const Constant *C) {
720 if (isa<GlobalValue>(C)) return false; // Cannot remove this
721
722 while (!C->use_empty()) {
723 const Constant *User = dyn_cast<Constant>(C->user_back());
724 if (!User) return false; // Non-constant usage;
725 if (!removeDeadUsersOfConstant(User))
726 return false; // Constant wasn't dead
727 }
728
729 // If C is only used by metadata, it should not be preserved but should have
730 // its uses replaced.
731 if (C->isUsedByMetadata()) {
732 const_cast<Constant *>(C)->replaceAllUsesWith(
733 UndefValue::get(C->getType()));
734 }
735 const_cast<Constant*>(C)->destroyConstant();
736 return true;
737 }
738
739
removeDeadConstantUsers() const740 void Constant::removeDeadConstantUsers() const {
741 Value::const_user_iterator I = user_begin(), E = user_end();
742 Value::const_user_iterator LastNonDeadUser = E;
743 while (I != E) {
744 const Constant *User = dyn_cast<Constant>(*I);
745 if (!User) {
746 LastNonDeadUser = I;
747 ++I;
748 continue;
749 }
750
751 if (!removeDeadUsersOfConstant(User)) {
752 // If the constant wasn't dead, remember that this was the last live use
753 // and move on to the next constant.
754 LastNonDeadUser = I;
755 ++I;
756 continue;
757 }
758
759 // If the constant was dead, then the iterator is invalidated.
760 if (LastNonDeadUser == E)
761 I = user_begin();
762 else
763 I = std::next(LastNonDeadUser);
764 }
765 }
766
replaceUndefsWith(Constant * C,Constant * Replacement)767 Constant *Constant::replaceUndefsWith(Constant *C, Constant *Replacement) {
768 assert(C && Replacement && "Expected non-nullptr constant arguments");
769 Type *Ty = C->getType();
770 if (match(C, m_Undef())) {
771 assert(Ty == Replacement->getType() && "Expected matching types");
772 return Replacement;
773 }
774
775 // Don't know how to deal with this constant.
776 auto *VTy = dyn_cast<FixedVectorType>(Ty);
777 if (!VTy)
778 return C;
779
780 unsigned NumElts = VTy->getNumElements();
781 SmallVector<Constant *, 32> NewC(NumElts);
782 for (unsigned i = 0; i != NumElts; ++i) {
783 Constant *EltC = C->getAggregateElement(i);
784 assert((!EltC || EltC->getType() == Replacement->getType()) &&
785 "Expected matching types");
786 NewC[i] = EltC && match(EltC, m_Undef()) ? Replacement : EltC;
787 }
788 return ConstantVector::get(NewC);
789 }
790
mergeUndefsWith(Constant * C,Constant * Other)791 Constant *Constant::mergeUndefsWith(Constant *C, Constant *Other) {
792 assert(C && Other && "Expected non-nullptr constant arguments");
793 if (match(C, m_Undef()))
794 return C;
795
796 Type *Ty = C->getType();
797 if (match(Other, m_Undef()))
798 return UndefValue::get(Ty);
799
800 auto *VTy = dyn_cast<FixedVectorType>(Ty);
801 if (!VTy)
802 return C;
803
804 Type *EltTy = VTy->getElementType();
805 unsigned NumElts = VTy->getNumElements();
806 assert(isa<FixedVectorType>(Other->getType()) &&
807 cast<FixedVectorType>(Other->getType())->getNumElements() == NumElts &&
808 "Type mismatch");
809
810 bool FoundExtraUndef = false;
811 SmallVector<Constant *, 32> NewC(NumElts);
812 for (unsigned I = 0; I != NumElts; ++I) {
813 NewC[I] = C->getAggregateElement(I);
814 Constant *OtherEltC = Other->getAggregateElement(I);
815 assert(NewC[I] && OtherEltC && "Unknown vector element");
816 if (!match(NewC[I], m_Undef()) && match(OtherEltC, m_Undef())) {
817 NewC[I] = UndefValue::get(EltTy);
818 FoundExtraUndef = true;
819 }
820 }
821 if (FoundExtraUndef)
822 return ConstantVector::get(NewC);
823 return C;
824 }
825
isManifestConstant() const826 bool Constant::isManifestConstant() const {
827 if (isa<ConstantData>(this))
828 return true;
829 if (isa<ConstantAggregate>(this) || isa<ConstantExpr>(this)) {
830 for (const Value *Op : operand_values())
831 if (!cast<Constant>(Op)->isManifestConstant())
832 return false;
833 return true;
834 }
835 return false;
836 }
837
838 //===----------------------------------------------------------------------===//
839 // ConstantInt
840 //===----------------------------------------------------------------------===//
841
ConstantInt(IntegerType * Ty,const APInt & V)842 ConstantInt::ConstantInt(IntegerType *Ty, const APInt &V)
843 : ConstantData(Ty, ConstantIntVal), Val(V) {
844 assert(V.getBitWidth() == Ty->getBitWidth() && "Invalid constant for type");
845 }
846
getTrue(LLVMContext & Context)847 ConstantInt *ConstantInt::getTrue(LLVMContext &Context) {
848 LLVMContextImpl *pImpl = Context.pImpl;
849 if (!pImpl->TheTrueVal)
850 pImpl->TheTrueVal = ConstantInt::get(Type::getInt1Ty(Context), 1);
851 return pImpl->TheTrueVal;
852 }
853
getFalse(LLVMContext & Context)854 ConstantInt *ConstantInt::getFalse(LLVMContext &Context) {
855 LLVMContextImpl *pImpl = Context.pImpl;
856 if (!pImpl->TheFalseVal)
857 pImpl->TheFalseVal = ConstantInt::get(Type::getInt1Ty(Context), 0);
858 return pImpl->TheFalseVal;
859 }
860
getBool(LLVMContext & Context,bool V)861 ConstantInt *ConstantInt::getBool(LLVMContext &Context, bool V) {
862 return V ? getTrue(Context) : getFalse(Context);
863 }
864
getTrue(Type * Ty)865 Constant *ConstantInt::getTrue(Type *Ty) {
866 assert(Ty->isIntOrIntVectorTy(1) && "Type not i1 or vector of i1.");
867 ConstantInt *TrueC = ConstantInt::getTrue(Ty->getContext());
868 if (auto *VTy = dyn_cast<VectorType>(Ty))
869 return ConstantVector::getSplat(VTy->getElementCount(), TrueC);
870 return TrueC;
871 }
872
getFalse(Type * Ty)873 Constant *ConstantInt::getFalse(Type *Ty) {
874 assert(Ty->isIntOrIntVectorTy(1) && "Type not i1 or vector of i1.");
875 ConstantInt *FalseC = ConstantInt::getFalse(Ty->getContext());
876 if (auto *VTy = dyn_cast<VectorType>(Ty))
877 return ConstantVector::getSplat(VTy->getElementCount(), FalseC);
878 return FalseC;
879 }
880
getBool(Type * Ty,bool V)881 Constant *ConstantInt::getBool(Type *Ty, bool V) {
882 return V ? getTrue(Ty) : getFalse(Ty);
883 }
884
885 // Get a ConstantInt from an APInt.
get(LLVMContext & Context,const APInt & V)886 ConstantInt *ConstantInt::get(LLVMContext &Context, const APInt &V) {
887 // get an existing value or the insertion position
888 LLVMContextImpl *pImpl = Context.pImpl;
889 std::unique_ptr<ConstantInt> &Slot = pImpl->IntConstants[V];
890 if (!Slot) {
891 // Get the corresponding integer type for the bit width of the value.
892 IntegerType *ITy = IntegerType::get(Context, V.getBitWidth());
893 Slot.reset(new ConstantInt(ITy, V));
894 }
895 assert(Slot->getType() == IntegerType::get(Context, V.getBitWidth()));
896 return Slot.get();
897 }
898
get(Type * Ty,uint64_t V,bool isSigned)899 Constant *ConstantInt::get(Type *Ty, uint64_t V, bool isSigned) {
900 Constant *C = get(cast<IntegerType>(Ty->getScalarType()), V, isSigned);
901
902 // For vectors, broadcast the value.
903 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
904 return ConstantVector::getSplat(VTy->getElementCount(), C);
905
906 return C;
907 }
908
get(IntegerType * Ty,uint64_t V,bool isSigned)909 ConstantInt *ConstantInt::get(IntegerType *Ty, uint64_t V, bool isSigned) {
910 return get(Ty->getContext(), APInt(Ty->getBitWidth(), V, isSigned));
911 }
912
getSigned(IntegerType * Ty,int64_t V)913 ConstantInt *ConstantInt::getSigned(IntegerType *Ty, int64_t V) {
914 return get(Ty, V, true);
915 }
916
getSigned(Type * Ty,int64_t V)917 Constant *ConstantInt::getSigned(Type *Ty, int64_t V) {
918 return get(Ty, V, true);
919 }
920
get(Type * Ty,const APInt & V)921 Constant *ConstantInt::get(Type *Ty, const APInt& V) {
922 ConstantInt *C = get(Ty->getContext(), V);
923 assert(C->getType() == Ty->getScalarType() &&
924 "ConstantInt type doesn't match the type implied by its value!");
925
926 // For vectors, broadcast the value.
927 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
928 return ConstantVector::getSplat(VTy->getElementCount(), C);
929
930 return C;
931 }
932
get(IntegerType * Ty,StringRef Str,uint8_t radix)933 ConstantInt *ConstantInt::get(IntegerType* Ty, StringRef Str, uint8_t radix) {
934 return get(Ty->getContext(), APInt(Ty->getBitWidth(), Str, radix));
935 }
936
937 /// Remove the constant from the constant table.
destroyConstantImpl()938 void ConstantInt::destroyConstantImpl() {
939 llvm_unreachable("You can't ConstantInt->destroyConstantImpl()!");
940 }
941
942 //===----------------------------------------------------------------------===//
943 // ConstantFP
944 //===----------------------------------------------------------------------===//
945
get(Type * Ty,double V)946 Constant *ConstantFP::get(Type *Ty, double V) {
947 LLVMContext &Context = Ty->getContext();
948
949 APFloat FV(V);
950 bool ignored;
951 FV.convert(Ty->getScalarType()->getFltSemantics(),
952 APFloat::rmNearestTiesToEven, &ignored);
953 Constant *C = get(Context, FV);
954
955 // For vectors, broadcast the value.
956 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
957 return ConstantVector::getSplat(VTy->getElementCount(), C);
958
959 return C;
960 }
961
get(Type * Ty,const APFloat & V)962 Constant *ConstantFP::get(Type *Ty, const APFloat &V) {
963 ConstantFP *C = get(Ty->getContext(), V);
964 assert(C->getType() == Ty->getScalarType() &&
965 "ConstantFP type doesn't match the type implied by its value!");
966
967 // For vectors, broadcast the value.
968 if (auto *VTy = dyn_cast<VectorType>(Ty))
969 return ConstantVector::getSplat(VTy->getElementCount(), C);
970
971 return C;
972 }
973
get(Type * Ty,StringRef Str)974 Constant *ConstantFP::get(Type *Ty, StringRef Str) {
975 LLVMContext &Context = Ty->getContext();
976
977 APFloat FV(Ty->getScalarType()->getFltSemantics(), Str);
978 Constant *C = get(Context, FV);
979
980 // For vectors, broadcast the value.
981 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
982 return ConstantVector::getSplat(VTy->getElementCount(), C);
983
984 return C;
985 }
986
getNaN(Type * Ty,bool Negative,uint64_t Payload)987 Constant *ConstantFP::getNaN(Type *Ty, bool Negative, uint64_t Payload) {
988 const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics();
989 APFloat NaN = APFloat::getNaN(Semantics, Negative, Payload);
990 Constant *C = get(Ty->getContext(), NaN);
991
992 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
993 return ConstantVector::getSplat(VTy->getElementCount(), C);
994
995 return C;
996 }
997
getQNaN(Type * Ty,bool Negative,APInt * Payload)998 Constant *ConstantFP::getQNaN(Type *Ty, bool Negative, APInt *Payload) {
999 const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics();
1000 APFloat NaN = APFloat::getQNaN(Semantics, Negative, Payload);
1001 Constant *C = get(Ty->getContext(), NaN);
1002
1003 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1004 return ConstantVector::getSplat(VTy->getElementCount(), C);
1005
1006 return C;
1007 }
1008
getSNaN(Type * Ty,bool Negative,APInt * Payload)1009 Constant *ConstantFP::getSNaN(Type *Ty, bool Negative, APInt *Payload) {
1010 const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics();
1011 APFloat NaN = APFloat::getSNaN(Semantics, Negative, Payload);
1012 Constant *C = get(Ty->getContext(), NaN);
1013
1014 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1015 return ConstantVector::getSplat(VTy->getElementCount(), C);
1016
1017 return C;
1018 }
1019
getNegativeZero(Type * Ty)1020 Constant *ConstantFP::getNegativeZero(Type *Ty) {
1021 const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics();
1022 APFloat NegZero = APFloat::getZero(Semantics, /*Negative=*/true);
1023 Constant *C = get(Ty->getContext(), NegZero);
1024
1025 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1026 return ConstantVector::getSplat(VTy->getElementCount(), C);
1027
1028 return C;
1029 }
1030
1031
getZeroValueForNegation(Type * Ty)1032 Constant *ConstantFP::getZeroValueForNegation(Type *Ty) {
1033 if (Ty->isFPOrFPVectorTy())
1034 return getNegativeZero(Ty);
1035
1036 return Constant::getNullValue(Ty);
1037 }
1038
1039
1040 // ConstantFP accessors.
get(LLVMContext & Context,const APFloat & V)1041 ConstantFP* ConstantFP::get(LLVMContext &Context, const APFloat& V) {
1042 LLVMContextImpl* pImpl = Context.pImpl;
1043
1044 std::unique_ptr<ConstantFP> &Slot = pImpl->FPConstants[V];
1045
1046 if (!Slot) {
1047 Type *Ty = Type::getFloatingPointTy(Context, V.getSemantics());
1048 Slot.reset(new ConstantFP(Ty, V));
1049 }
1050
1051 return Slot.get();
1052 }
1053
getInfinity(Type * Ty,bool Negative)1054 Constant *ConstantFP::getInfinity(Type *Ty, bool Negative) {
1055 const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics();
1056 Constant *C = get(Ty->getContext(), APFloat::getInf(Semantics, Negative));
1057
1058 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1059 return ConstantVector::getSplat(VTy->getElementCount(), C);
1060
1061 return C;
1062 }
1063
ConstantFP(Type * Ty,const APFloat & V)1064 ConstantFP::ConstantFP(Type *Ty, const APFloat &V)
1065 : ConstantData(Ty, ConstantFPVal), Val(V) {
1066 assert(&V.getSemantics() == &Ty->getFltSemantics() &&
1067 "FP type Mismatch");
1068 }
1069
isExactlyValue(const APFloat & V) const1070 bool ConstantFP::isExactlyValue(const APFloat &V) const {
1071 return Val.bitwiseIsEqual(V);
1072 }
1073
1074 /// Remove the constant from the constant table.
destroyConstantImpl()1075 void ConstantFP::destroyConstantImpl() {
1076 llvm_unreachable("You can't ConstantFP->destroyConstantImpl()!");
1077 }
1078
1079 //===----------------------------------------------------------------------===//
1080 // ConstantAggregateZero Implementation
1081 //===----------------------------------------------------------------------===//
1082
getSequentialElement() const1083 Constant *ConstantAggregateZero::getSequentialElement() const {
1084 if (auto *AT = dyn_cast<ArrayType>(getType()))
1085 return Constant::getNullValue(AT->getElementType());
1086 return Constant::getNullValue(cast<VectorType>(getType())->getElementType());
1087 }
1088
getStructElement(unsigned Elt) const1089 Constant *ConstantAggregateZero::getStructElement(unsigned Elt) const {
1090 return Constant::getNullValue(getType()->getStructElementType(Elt));
1091 }
1092
getElementValue(Constant * C) const1093 Constant *ConstantAggregateZero::getElementValue(Constant *C) const {
1094 if (isa<ArrayType>(getType()) || isa<VectorType>(getType()))
1095 return getSequentialElement();
1096 return getStructElement(cast<ConstantInt>(C)->getZExtValue());
1097 }
1098
getElementValue(unsigned Idx) const1099 Constant *ConstantAggregateZero::getElementValue(unsigned Idx) const {
1100 if (isa<ArrayType>(getType()) || isa<VectorType>(getType()))
1101 return getSequentialElement();
1102 return getStructElement(Idx);
1103 }
1104
getElementCount() const1105 ElementCount ConstantAggregateZero::getElementCount() const {
1106 Type *Ty = getType();
1107 if (auto *AT = dyn_cast<ArrayType>(Ty))
1108 return ElementCount::getFixed(AT->getNumElements());
1109 if (auto *VT = dyn_cast<VectorType>(Ty))
1110 return VT->getElementCount();
1111 return ElementCount::getFixed(Ty->getStructNumElements());
1112 }
1113
1114 //===----------------------------------------------------------------------===//
1115 // UndefValue Implementation
1116 //===----------------------------------------------------------------------===//
1117
getSequentialElement() const1118 UndefValue *UndefValue::getSequentialElement() const {
1119 if (ArrayType *ATy = dyn_cast<ArrayType>(getType()))
1120 return UndefValue::get(ATy->getElementType());
1121 return UndefValue::get(cast<VectorType>(getType())->getElementType());
1122 }
1123
getStructElement(unsigned Elt) const1124 UndefValue *UndefValue::getStructElement(unsigned Elt) const {
1125 return UndefValue::get(getType()->getStructElementType(Elt));
1126 }
1127
getElementValue(Constant * C) const1128 UndefValue *UndefValue::getElementValue(Constant *C) const {
1129 if (isa<ArrayType>(getType()) || isa<VectorType>(getType()))
1130 return getSequentialElement();
1131 return getStructElement(cast<ConstantInt>(C)->getZExtValue());
1132 }
1133
getElementValue(unsigned Idx) const1134 UndefValue *UndefValue::getElementValue(unsigned Idx) const {
1135 if (isa<ArrayType>(getType()) || isa<VectorType>(getType()))
1136 return getSequentialElement();
1137 return getStructElement(Idx);
1138 }
1139
getNumElements() const1140 unsigned UndefValue::getNumElements() const {
1141 Type *Ty = getType();
1142 if (auto *AT = dyn_cast<ArrayType>(Ty))
1143 return AT->getNumElements();
1144 if (auto *VT = dyn_cast<VectorType>(Ty))
1145 return cast<FixedVectorType>(VT)->getNumElements();
1146 return Ty->getStructNumElements();
1147 }
1148
1149 //===----------------------------------------------------------------------===//
1150 // PoisonValue Implementation
1151 //===----------------------------------------------------------------------===//
1152
getSequentialElement() const1153 PoisonValue *PoisonValue::getSequentialElement() const {
1154 if (ArrayType *ATy = dyn_cast<ArrayType>(getType()))
1155 return PoisonValue::get(ATy->getElementType());
1156 return PoisonValue::get(cast<VectorType>(getType())->getElementType());
1157 }
1158
getStructElement(unsigned Elt) const1159 PoisonValue *PoisonValue::getStructElement(unsigned Elt) const {
1160 return PoisonValue::get(getType()->getStructElementType(Elt));
1161 }
1162
getElementValue(Constant * C) const1163 PoisonValue *PoisonValue::getElementValue(Constant *C) const {
1164 if (isa<ArrayType>(getType()) || isa<VectorType>(getType()))
1165 return getSequentialElement();
1166 return getStructElement(cast<ConstantInt>(C)->getZExtValue());
1167 }
1168
getElementValue(unsigned Idx) const1169 PoisonValue *PoisonValue::getElementValue(unsigned Idx) const {
1170 if (isa<ArrayType>(getType()) || isa<VectorType>(getType()))
1171 return getSequentialElement();
1172 return getStructElement(Idx);
1173 }
1174
1175 //===----------------------------------------------------------------------===//
1176 // ConstantXXX Classes
1177 //===----------------------------------------------------------------------===//
1178
1179 template <typename ItTy, typename EltTy>
rangeOnlyContains(ItTy Start,ItTy End,EltTy Elt)1180 static bool rangeOnlyContains(ItTy Start, ItTy End, EltTy Elt) {
1181 for (; Start != End; ++Start)
1182 if (*Start != Elt)
1183 return false;
1184 return true;
1185 }
1186
1187 template <typename SequentialTy, typename ElementTy>
getIntSequenceIfElementsMatch(ArrayRef<Constant * > V)1188 static Constant *getIntSequenceIfElementsMatch(ArrayRef<Constant *> V) {
1189 assert(!V.empty() && "Cannot get empty int sequence.");
1190
1191 SmallVector<ElementTy, 16> Elts;
1192 for (Constant *C : V)
1193 if (auto *CI = dyn_cast<ConstantInt>(C))
1194 Elts.push_back(CI->getZExtValue());
1195 else
1196 return nullptr;
1197 return SequentialTy::get(V[0]->getContext(), Elts);
1198 }
1199
1200 template <typename SequentialTy, typename ElementTy>
getFPSequenceIfElementsMatch(ArrayRef<Constant * > V)1201 static Constant *getFPSequenceIfElementsMatch(ArrayRef<Constant *> V) {
1202 assert(!V.empty() && "Cannot get empty FP sequence.");
1203
1204 SmallVector<ElementTy, 16> Elts;
1205 for (Constant *C : V)
1206 if (auto *CFP = dyn_cast<ConstantFP>(C))
1207 Elts.push_back(CFP->getValueAPF().bitcastToAPInt().getLimitedValue());
1208 else
1209 return nullptr;
1210 return SequentialTy::getFP(V[0]->getType(), Elts);
1211 }
1212
1213 template <typename SequenceTy>
getSequenceIfElementsMatch(Constant * C,ArrayRef<Constant * > V)1214 static Constant *getSequenceIfElementsMatch(Constant *C,
1215 ArrayRef<Constant *> V) {
1216 // We speculatively build the elements here even if it turns out that there is
1217 // a constantexpr or something else weird, since it is so uncommon for that to
1218 // happen.
1219 if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) {
1220 if (CI->getType()->isIntegerTy(8))
1221 return getIntSequenceIfElementsMatch<SequenceTy, uint8_t>(V);
1222 else if (CI->getType()->isIntegerTy(16))
1223 return getIntSequenceIfElementsMatch<SequenceTy, uint16_t>(V);
1224 else if (CI->getType()->isIntegerTy(32))
1225 return getIntSequenceIfElementsMatch<SequenceTy, uint32_t>(V);
1226 else if (CI->getType()->isIntegerTy(64))
1227 return getIntSequenceIfElementsMatch<SequenceTy, uint64_t>(V);
1228 } else if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
1229 if (CFP->getType()->isHalfTy() || CFP->getType()->isBFloatTy())
1230 return getFPSequenceIfElementsMatch<SequenceTy, uint16_t>(V);
1231 else if (CFP->getType()->isFloatTy())
1232 return getFPSequenceIfElementsMatch<SequenceTy, uint32_t>(V);
1233 else if (CFP->getType()->isDoubleTy())
1234 return getFPSequenceIfElementsMatch<SequenceTy, uint64_t>(V);
1235 }
1236
1237 return nullptr;
1238 }
1239
ConstantAggregate(Type * T,ValueTy VT,ArrayRef<Constant * > V)1240 ConstantAggregate::ConstantAggregate(Type *T, ValueTy VT,
1241 ArrayRef<Constant *> V)
1242 : Constant(T, VT, OperandTraits<ConstantAggregate>::op_end(this) - V.size(),
1243 V.size()) {
1244 llvm::copy(V, op_begin());
1245
1246 // Check that types match, unless this is an opaque struct.
1247 if (auto *ST = dyn_cast<StructType>(T)) {
1248 if (ST->isOpaque())
1249 return;
1250 for (unsigned I = 0, E = V.size(); I != E; ++I)
1251 assert(V[I]->getType() == ST->getTypeAtIndex(I) &&
1252 "Initializer for struct element doesn't match!");
1253 }
1254 }
1255
ConstantArray(ArrayType * T,ArrayRef<Constant * > V)1256 ConstantArray::ConstantArray(ArrayType *T, ArrayRef<Constant *> V)
1257 : ConstantAggregate(T, ConstantArrayVal, V) {
1258 assert(V.size() == T->getNumElements() &&
1259 "Invalid initializer for constant array");
1260 }
1261
get(ArrayType * Ty,ArrayRef<Constant * > V)1262 Constant *ConstantArray::get(ArrayType *Ty, ArrayRef<Constant*> V) {
1263 if (Constant *C = getImpl(Ty, V))
1264 return C;
1265 return Ty->getContext().pImpl->ArrayConstants.getOrCreate(Ty, V);
1266 }
1267
getImpl(ArrayType * Ty,ArrayRef<Constant * > V)1268 Constant *ConstantArray::getImpl(ArrayType *Ty, ArrayRef<Constant*> V) {
1269 // Empty arrays are canonicalized to ConstantAggregateZero.
1270 if (V.empty())
1271 return ConstantAggregateZero::get(Ty);
1272
1273 for (unsigned i = 0, e = V.size(); i != e; ++i) {
1274 assert(V[i]->getType() == Ty->getElementType() &&
1275 "Wrong type in array element initializer");
1276 }
1277
1278 // If this is an all-zero array, return a ConstantAggregateZero object. If
1279 // all undef, return an UndefValue, if "all simple", then return a
1280 // ConstantDataArray.
1281 Constant *C = V[0];
1282 if (isa<PoisonValue>(C) && rangeOnlyContains(V.begin(), V.end(), C))
1283 return PoisonValue::get(Ty);
1284
1285 if (isa<UndefValue>(C) && rangeOnlyContains(V.begin(), V.end(), C))
1286 return UndefValue::get(Ty);
1287
1288 if (C->isNullValue() && rangeOnlyContains(V.begin(), V.end(), C))
1289 return ConstantAggregateZero::get(Ty);
1290
1291 // Check to see if all of the elements are ConstantFP or ConstantInt and if
1292 // the element type is compatible with ConstantDataVector. If so, use it.
1293 if (ConstantDataSequential::isElementTypeCompatible(C->getType()))
1294 return getSequenceIfElementsMatch<ConstantDataArray>(C, V);
1295
1296 // Otherwise, we really do want to create a ConstantArray.
1297 return nullptr;
1298 }
1299
getTypeForElements(LLVMContext & Context,ArrayRef<Constant * > V,bool Packed)1300 StructType *ConstantStruct::getTypeForElements(LLVMContext &Context,
1301 ArrayRef<Constant*> V,
1302 bool Packed) {
1303 unsigned VecSize = V.size();
1304 SmallVector<Type*, 16> EltTypes(VecSize);
1305 for (unsigned i = 0; i != VecSize; ++i)
1306 EltTypes[i] = V[i]->getType();
1307
1308 return StructType::get(Context, EltTypes, Packed);
1309 }
1310
1311
getTypeForElements(ArrayRef<Constant * > V,bool Packed)1312 StructType *ConstantStruct::getTypeForElements(ArrayRef<Constant*> V,
1313 bool Packed) {
1314 assert(!V.empty() &&
1315 "ConstantStruct::getTypeForElements cannot be called on empty list");
1316 return getTypeForElements(V[0]->getContext(), V, Packed);
1317 }
1318
ConstantStruct(StructType * T,ArrayRef<Constant * > V)1319 ConstantStruct::ConstantStruct(StructType *T, ArrayRef<Constant *> V)
1320 : ConstantAggregate(T, ConstantStructVal, V) {
1321 assert((T->isOpaque() || V.size() == T->getNumElements()) &&
1322 "Invalid initializer for constant struct");
1323 }
1324
1325 // ConstantStruct accessors.
get(StructType * ST,ArrayRef<Constant * > V)1326 Constant *ConstantStruct::get(StructType *ST, ArrayRef<Constant*> V) {
1327 assert((ST->isOpaque() || ST->getNumElements() == V.size()) &&
1328 "Incorrect # elements specified to ConstantStruct::get");
1329
1330 // Create a ConstantAggregateZero value if all elements are zeros.
1331 bool isZero = true;
1332 bool isUndef = false;
1333 bool isPoison = false;
1334
1335 if (!V.empty()) {
1336 isUndef = isa<UndefValue>(V[0]);
1337 isPoison = isa<PoisonValue>(V[0]);
1338 isZero = V[0]->isNullValue();
1339 // PoisonValue inherits UndefValue, so its check is not necessary.
1340 if (isUndef || isZero) {
1341 for (unsigned i = 0, e = V.size(); i != e; ++i) {
1342 if (!V[i]->isNullValue())
1343 isZero = false;
1344 if (!isa<PoisonValue>(V[i]))
1345 isPoison = false;
1346 if (isa<PoisonValue>(V[i]) || !isa<UndefValue>(V[i]))
1347 isUndef = false;
1348 }
1349 }
1350 }
1351 if (isZero)
1352 return ConstantAggregateZero::get(ST);
1353 if (isPoison)
1354 return PoisonValue::get(ST);
1355 if (isUndef)
1356 return UndefValue::get(ST);
1357
1358 return ST->getContext().pImpl->StructConstants.getOrCreate(ST, V);
1359 }
1360
ConstantVector(VectorType * T,ArrayRef<Constant * > V)1361 ConstantVector::ConstantVector(VectorType *T, ArrayRef<Constant *> V)
1362 : ConstantAggregate(T, ConstantVectorVal, V) {
1363 assert(V.size() == cast<FixedVectorType>(T)->getNumElements() &&
1364 "Invalid initializer for constant vector");
1365 }
1366
1367 // ConstantVector accessors.
get(ArrayRef<Constant * > V)1368 Constant *ConstantVector::get(ArrayRef<Constant*> V) {
1369 if (Constant *C = getImpl(V))
1370 return C;
1371 auto *Ty = FixedVectorType::get(V.front()->getType(), V.size());
1372 return Ty->getContext().pImpl->VectorConstants.getOrCreate(Ty, V);
1373 }
1374
getImpl(ArrayRef<Constant * > V)1375 Constant *ConstantVector::getImpl(ArrayRef<Constant*> V) {
1376 assert(!V.empty() && "Vectors can't be empty");
1377 auto *T = FixedVectorType::get(V.front()->getType(), V.size());
1378
1379 // If this is an all-undef or all-zero vector, return a
1380 // ConstantAggregateZero or UndefValue.
1381 Constant *C = V[0];
1382 bool isZero = C->isNullValue();
1383 bool isUndef = isa<UndefValue>(C);
1384 bool isPoison = isa<PoisonValue>(C);
1385
1386 if (isZero || isUndef) {
1387 for (unsigned i = 1, e = V.size(); i != e; ++i)
1388 if (V[i] != C) {
1389 isZero = isUndef = isPoison = false;
1390 break;
1391 }
1392 }
1393
1394 if (isZero)
1395 return ConstantAggregateZero::get(T);
1396 if (isPoison)
1397 return PoisonValue::get(T);
1398 if (isUndef)
1399 return UndefValue::get(T);
1400
1401 // Check to see if all of the elements are ConstantFP or ConstantInt and if
1402 // the element type is compatible with ConstantDataVector. If so, use it.
1403 if (ConstantDataSequential::isElementTypeCompatible(C->getType()))
1404 return getSequenceIfElementsMatch<ConstantDataVector>(C, V);
1405
1406 // Otherwise, the element type isn't compatible with ConstantDataVector, or
1407 // the operand list contains a ConstantExpr or something else strange.
1408 return nullptr;
1409 }
1410
getSplat(ElementCount EC,Constant * V)1411 Constant *ConstantVector::getSplat(ElementCount EC, Constant *V) {
1412 if (!EC.isScalable()) {
1413 // If this splat is compatible with ConstantDataVector, use it instead of
1414 // ConstantVector.
1415 if ((isa<ConstantFP>(V) || isa<ConstantInt>(V)) &&
1416 ConstantDataSequential::isElementTypeCompatible(V->getType()))
1417 return ConstantDataVector::getSplat(EC.getKnownMinValue(), V);
1418
1419 SmallVector<Constant *, 32> Elts(EC.getKnownMinValue(), V);
1420 return get(Elts);
1421 }
1422
1423 Type *VTy = VectorType::get(V->getType(), EC);
1424
1425 if (V->isNullValue())
1426 return ConstantAggregateZero::get(VTy);
1427 else if (isa<UndefValue>(V))
1428 return UndefValue::get(VTy);
1429
1430 Type *I32Ty = Type::getInt32Ty(VTy->getContext());
1431
1432 // Move scalar into vector.
1433 Constant *UndefV = UndefValue::get(VTy);
1434 V = ConstantExpr::getInsertElement(UndefV, V, ConstantInt::get(I32Ty, 0));
1435 // Build shuffle mask to perform the splat.
1436 SmallVector<int, 8> Zeros(EC.getKnownMinValue(), 0);
1437 // Splat.
1438 return ConstantExpr::getShuffleVector(V, UndefV, Zeros);
1439 }
1440
get(LLVMContext & Context)1441 ConstantTokenNone *ConstantTokenNone::get(LLVMContext &Context) {
1442 LLVMContextImpl *pImpl = Context.pImpl;
1443 if (!pImpl->TheNoneToken)
1444 pImpl->TheNoneToken.reset(new ConstantTokenNone(Context));
1445 return pImpl->TheNoneToken.get();
1446 }
1447
1448 /// Remove the constant from the constant table.
destroyConstantImpl()1449 void ConstantTokenNone::destroyConstantImpl() {
1450 llvm_unreachable("You can't ConstantTokenNone->destroyConstantImpl()!");
1451 }
1452
1453 // Utility function for determining if a ConstantExpr is a CastOp or not. This
1454 // can't be inline because we don't want to #include Instruction.h into
1455 // Constant.h
isCast() const1456 bool ConstantExpr::isCast() const {
1457 return Instruction::isCast(getOpcode());
1458 }
1459
isCompare() const1460 bool ConstantExpr::isCompare() const {
1461 return getOpcode() == Instruction::ICmp || getOpcode() == Instruction::FCmp;
1462 }
1463
isGEPWithNoNotionalOverIndexing() const1464 bool ConstantExpr::isGEPWithNoNotionalOverIndexing() const {
1465 if (getOpcode() != Instruction::GetElementPtr) return false;
1466
1467 gep_type_iterator GEPI = gep_type_begin(this), E = gep_type_end(this);
1468 User::const_op_iterator OI = std::next(this->op_begin());
1469
1470 // The remaining indices may be compile-time known integers within the bounds
1471 // of the corresponding notional static array types.
1472 for (; GEPI != E; ++GEPI, ++OI) {
1473 if (isa<UndefValue>(*OI))
1474 continue;
1475 auto *CI = dyn_cast<ConstantInt>(*OI);
1476 if (!CI || (GEPI.isBoundedSequential() &&
1477 (CI->getValue().getActiveBits() > 64 ||
1478 CI->getZExtValue() >= GEPI.getSequentialNumElements())))
1479 return false;
1480 }
1481
1482 // All the indices checked out.
1483 return true;
1484 }
1485
hasIndices() const1486 bool ConstantExpr::hasIndices() const {
1487 return getOpcode() == Instruction::ExtractValue ||
1488 getOpcode() == Instruction::InsertValue;
1489 }
1490
getIndices() const1491 ArrayRef<unsigned> ConstantExpr::getIndices() const {
1492 if (const ExtractValueConstantExpr *EVCE =
1493 dyn_cast<ExtractValueConstantExpr>(this))
1494 return EVCE->Indices;
1495
1496 return cast<InsertValueConstantExpr>(this)->Indices;
1497 }
1498
getPredicate() const1499 unsigned ConstantExpr::getPredicate() const {
1500 return cast<CompareConstantExpr>(this)->predicate;
1501 }
1502
getShuffleMask() const1503 ArrayRef<int> ConstantExpr::getShuffleMask() const {
1504 return cast<ShuffleVectorConstantExpr>(this)->ShuffleMask;
1505 }
1506
getShuffleMaskForBitcode() const1507 Constant *ConstantExpr::getShuffleMaskForBitcode() const {
1508 return cast<ShuffleVectorConstantExpr>(this)->ShuffleMaskForBitcode;
1509 }
1510
1511 Constant *
getWithOperandReplaced(unsigned OpNo,Constant * Op) const1512 ConstantExpr::getWithOperandReplaced(unsigned OpNo, Constant *Op) const {
1513 assert(Op->getType() == getOperand(OpNo)->getType() &&
1514 "Replacing operand with value of different type!");
1515 if (getOperand(OpNo) == Op)
1516 return const_cast<ConstantExpr*>(this);
1517
1518 SmallVector<Constant*, 8> NewOps;
1519 for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
1520 NewOps.push_back(i == OpNo ? Op : getOperand(i));
1521
1522 return getWithOperands(NewOps);
1523 }
1524
getWithOperands(ArrayRef<Constant * > Ops,Type * Ty,bool OnlyIfReduced,Type * SrcTy) const1525 Constant *ConstantExpr::getWithOperands(ArrayRef<Constant *> Ops, Type *Ty,
1526 bool OnlyIfReduced, Type *SrcTy) const {
1527 assert(Ops.size() == getNumOperands() && "Operand count mismatch!");
1528
1529 // If no operands changed return self.
1530 if (Ty == getType() && std::equal(Ops.begin(), Ops.end(), op_begin()))
1531 return const_cast<ConstantExpr*>(this);
1532
1533 Type *OnlyIfReducedTy = OnlyIfReduced ? Ty : nullptr;
1534 switch (getOpcode()) {
1535 case Instruction::Trunc:
1536 case Instruction::ZExt:
1537 case Instruction::SExt:
1538 case Instruction::FPTrunc:
1539 case Instruction::FPExt:
1540 case Instruction::UIToFP:
1541 case Instruction::SIToFP:
1542 case Instruction::FPToUI:
1543 case Instruction::FPToSI:
1544 case Instruction::PtrToInt:
1545 case Instruction::IntToPtr:
1546 case Instruction::BitCast:
1547 case Instruction::AddrSpaceCast:
1548 return ConstantExpr::getCast(getOpcode(), Ops[0], Ty, OnlyIfReduced);
1549 case Instruction::Select:
1550 return ConstantExpr::getSelect(Ops[0], Ops[1], Ops[2], OnlyIfReducedTy);
1551 case Instruction::InsertElement:
1552 return ConstantExpr::getInsertElement(Ops[0], Ops[1], Ops[2],
1553 OnlyIfReducedTy);
1554 case Instruction::ExtractElement:
1555 return ConstantExpr::getExtractElement(Ops[0], Ops[1], OnlyIfReducedTy);
1556 case Instruction::InsertValue:
1557 return ConstantExpr::getInsertValue(Ops[0], Ops[1], getIndices(),
1558 OnlyIfReducedTy);
1559 case Instruction::ExtractValue:
1560 return ConstantExpr::getExtractValue(Ops[0], getIndices(), OnlyIfReducedTy);
1561 case Instruction::FNeg:
1562 return ConstantExpr::getFNeg(Ops[0]);
1563 case Instruction::ShuffleVector:
1564 return ConstantExpr::getShuffleVector(Ops[0], Ops[1], getShuffleMask(),
1565 OnlyIfReducedTy);
1566 case Instruction::GetElementPtr: {
1567 auto *GEPO = cast<GEPOperator>(this);
1568 assert(SrcTy || (Ops[0]->getType() == getOperand(0)->getType()));
1569 return ConstantExpr::getGetElementPtr(
1570 SrcTy ? SrcTy : GEPO->getSourceElementType(), Ops[0], Ops.slice(1),
1571 GEPO->isInBounds(), GEPO->getInRangeIndex(), OnlyIfReducedTy);
1572 }
1573 case Instruction::ICmp:
1574 case Instruction::FCmp:
1575 return ConstantExpr::getCompare(getPredicate(), Ops[0], Ops[1],
1576 OnlyIfReducedTy);
1577 default:
1578 assert(getNumOperands() == 2 && "Must be binary operator?");
1579 return ConstantExpr::get(getOpcode(), Ops[0], Ops[1], SubclassOptionalData,
1580 OnlyIfReducedTy);
1581 }
1582 }
1583
1584
1585 //===----------------------------------------------------------------------===//
1586 // isValueValidForType implementations
1587
isValueValidForType(Type * Ty,uint64_t Val)1588 bool ConstantInt::isValueValidForType(Type *Ty, uint64_t Val) {
1589 unsigned NumBits = Ty->getIntegerBitWidth(); // assert okay
1590 if (Ty->isIntegerTy(1))
1591 return Val == 0 || Val == 1;
1592 return isUIntN(NumBits, Val);
1593 }
1594
isValueValidForType(Type * Ty,int64_t Val)1595 bool ConstantInt::isValueValidForType(Type *Ty, int64_t Val) {
1596 unsigned NumBits = Ty->getIntegerBitWidth();
1597 if (Ty->isIntegerTy(1))
1598 return Val == 0 || Val == 1 || Val == -1;
1599 return isIntN(NumBits, Val);
1600 }
1601
isValueValidForType(Type * Ty,const APFloat & Val)1602 bool ConstantFP::isValueValidForType(Type *Ty, const APFloat& Val) {
1603 // convert modifies in place, so make a copy.
1604 APFloat Val2 = APFloat(Val);
1605 bool losesInfo;
1606 switch (Ty->getTypeID()) {
1607 default:
1608 return false; // These can't be represented as floating point!
1609
1610 // FIXME rounding mode needs to be more flexible
1611 case Type::HalfTyID: {
1612 if (&Val2.getSemantics() == &APFloat::IEEEhalf())
1613 return true;
1614 Val2.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven, &losesInfo);
1615 return !losesInfo;
1616 }
1617 case Type::BFloatTyID: {
1618 if (&Val2.getSemantics() == &APFloat::BFloat())
1619 return true;
1620 Val2.convert(APFloat::BFloat(), APFloat::rmNearestTiesToEven, &losesInfo);
1621 return !losesInfo;
1622 }
1623 case Type::FloatTyID: {
1624 if (&Val2.getSemantics() == &APFloat::IEEEsingle())
1625 return true;
1626 Val2.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
1627 return !losesInfo;
1628 }
1629 case Type::DoubleTyID: {
1630 if (&Val2.getSemantics() == &APFloat::IEEEhalf() ||
1631 &Val2.getSemantics() == &APFloat::BFloat() ||
1632 &Val2.getSemantics() == &APFloat::IEEEsingle() ||
1633 &Val2.getSemantics() == &APFloat::IEEEdouble())
1634 return true;
1635 Val2.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1636 return !losesInfo;
1637 }
1638 case Type::X86_FP80TyID:
1639 return &Val2.getSemantics() == &APFloat::IEEEhalf() ||
1640 &Val2.getSemantics() == &APFloat::BFloat() ||
1641 &Val2.getSemantics() == &APFloat::IEEEsingle() ||
1642 &Val2.getSemantics() == &APFloat::IEEEdouble() ||
1643 &Val2.getSemantics() == &APFloat::x87DoubleExtended();
1644 case Type::FP128TyID:
1645 return &Val2.getSemantics() == &APFloat::IEEEhalf() ||
1646 &Val2.getSemantics() == &APFloat::BFloat() ||
1647 &Val2.getSemantics() == &APFloat::IEEEsingle() ||
1648 &Val2.getSemantics() == &APFloat::IEEEdouble() ||
1649 &Val2.getSemantics() == &APFloat::IEEEquad();
1650 case Type::PPC_FP128TyID:
1651 return &Val2.getSemantics() == &APFloat::IEEEhalf() ||
1652 &Val2.getSemantics() == &APFloat::BFloat() ||
1653 &Val2.getSemantics() == &APFloat::IEEEsingle() ||
1654 &Val2.getSemantics() == &APFloat::IEEEdouble() ||
1655 &Val2.getSemantics() == &APFloat::PPCDoubleDouble();
1656 }
1657 }
1658
1659
1660 //===----------------------------------------------------------------------===//
1661 // Factory Function Implementation
1662
get(Type * Ty)1663 ConstantAggregateZero *ConstantAggregateZero::get(Type *Ty) {
1664 assert((Ty->isStructTy() || Ty->isArrayTy() || Ty->isVectorTy()) &&
1665 "Cannot create an aggregate zero of non-aggregate type!");
1666
1667 std::unique_ptr<ConstantAggregateZero> &Entry =
1668 Ty->getContext().pImpl->CAZConstants[Ty];
1669 if (!Entry)
1670 Entry.reset(new ConstantAggregateZero(Ty));
1671
1672 return Entry.get();
1673 }
1674
1675 /// Remove the constant from the constant table.
destroyConstantImpl()1676 void ConstantAggregateZero::destroyConstantImpl() {
1677 getContext().pImpl->CAZConstants.erase(getType());
1678 }
1679
1680 /// Remove the constant from the constant table.
destroyConstantImpl()1681 void ConstantArray::destroyConstantImpl() {
1682 getType()->getContext().pImpl->ArrayConstants.remove(this);
1683 }
1684
1685
1686 //---- ConstantStruct::get() implementation...
1687 //
1688
1689 /// Remove the constant from the constant table.
destroyConstantImpl()1690 void ConstantStruct::destroyConstantImpl() {
1691 getType()->getContext().pImpl->StructConstants.remove(this);
1692 }
1693
1694 /// Remove the constant from the constant table.
destroyConstantImpl()1695 void ConstantVector::destroyConstantImpl() {
1696 getType()->getContext().pImpl->VectorConstants.remove(this);
1697 }
1698
getSplatValue(bool AllowUndefs) const1699 Constant *Constant::getSplatValue(bool AllowUndefs) const {
1700 assert(this->getType()->isVectorTy() && "Only valid for vectors!");
1701 if (isa<ConstantAggregateZero>(this))
1702 return getNullValue(cast<VectorType>(getType())->getElementType());
1703 if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this))
1704 return CV->getSplatValue();
1705 if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
1706 return CV->getSplatValue(AllowUndefs);
1707
1708 // Check if this is a constant expression splat of the form returned by
1709 // ConstantVector::getSplat()
1710 const auto *Shuf = dyn_cast<ConstantExpr>(this);
1711 if (Shuf && Shuf->getOpcode() == Instruction::ShuffleVector &&
1712 isa<UndefValue>(Shuf->getOperand(1))) {
1713
1714 const auto *IElt = dyn_cast<ConstantExpr>(Shuf->getOperand(0));
1715 if (IElt && IElt->getOpcode() == Instruction::InsertElement &&
1716 isa<UndefValue>(IElt->getOperand(0))) {
1717
1718 ArrayRef<int> Mask = Shuf->getShuffleMask();
1719 Constant *SplatVal = IElt->getOperand(1);
1720 ConstantInt *Index = dyn_cast<ConstantInt>(IElt->getOperand(2));
1721
1722 if (Index && Index->getValue() == 0 &&
1723 llvm::all_of(Mask, [](int I) { return I == 0; }))
1724 return SplatVal;
1725 }
1726 }
1727
1728 return nullptr;
1729 }
1730
getSplatValue(bool AllowUndefs) const1731 Constant *ConstantVector::getSplatValue(bool AllowUndefs) const {
1732 // Check out first element.
1733 Constant *Elt = getOperand(0);
1734 // Then make sure all remaining elements point to the same value.
1735 for (unsigned I = 1, E = getNumOperands(); I < E; ++I) {
1736 Constant *OpC = getOperand(I);
1737 if (OpC == Elt)
1738 continue;
1739
1740 // Strict mode: any mismatch is not a splat.
1741 if (!AllowUndefs)
1742 return nullptr;
1743
1744 // Allow undefs mode: ignore undefined elements.
1745 if (isa<UndefValue>(OpC))
1746 continue;
1747
1748 // If we do not have a defined element yet, use the current operand.
1749 if (isa<UndefValue>(Elt))
1750 Elt = OpC;
1751
1752 if (OpC != Elt)
1753 return nullptr;
1754 }
1755 return Elt;
1756 }
1757
getUniqueInteger() const1758 const APInt &Constant::getUniqueInteger() const {
1759 if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
1760 return CI->getValue();
1761 assert(this->getSplatValue() && "Doesn't contain a unique integer!");
1762 const Constant *C = this->getAggregateElement(0U);
1763 assert(C && isa<ConstantInt>(C) && "Not a vector of numbers!");
1764 return cast<ConstantInt>(C)->getValue();
1765 }
1766
1767 //---- ConstantPointerNull::get() implementation.
1768 //
1769
get(PointerType * Ty)1770 ConstantPointerNull *ConstantPointerNull::get(PointerType *Ty) {
1771 std::unique_ptr<ConstantPointerNull> &Entry =
1772 Ty->getContext().pImpl->CPNConstants[Ty];
1773 if (!Entry)
1774 Entry.reset(new ConstantPointerNull(Ty));
1775
1776 return Entry.get();
1777 }
1778
1779 /// Remove the constant from the constant table.
destroyConstantImpl()1780 void ConstantPointerNull::destroyConstantImpl() {
1781 getContext().pImpl->CPNConstants.erase(getType());
1782 }
1783
get(Type * Ty)1784 UndefValue *UndefValue::get(Type *Ty) {
1785 std::unique_ptr<UndefValue> &Entry = Ty->getContext().pImpl->UVConstants[Ty];
1786 if (!Entry)
1787 Entry.reset(new UndefValue(Ty));
1788
1789 return Entry.get();
1790 }
1791
1792 /// Remove the constant from the constant table.
destroyConstantImpl()1793 void UndefValue::destroyConstantImpl() {
1794 // Free the constant and any dangling references to it.
1795 if (getValueID() == UndefValueVal) {
1796 getContext().pImpl->UVConstants.erase(getType());
1797 } else if (getValueID() == PoisonValueVal) {
1798 getContext().pImpl->PVConstants.erase(getType());
1799 }
1800 llvm_unreachable("Not a undef or a poison!");
1801 }
1802
get(Type * Ty)1803 PoisonValue *PoisonValue::get(Type *Ty) {
1804 std::unique_ptr<PoisonValue> &Entry = Ty->getContext().pImpl->PVConstants[Ty];
1805 if (!Entry)
1806 Entry.reset(new PoisonValue(Ty));
1807
1808 return Entry.get();
1809 }
1810
1811 /// Remove the constant from the constant table.
destroyConstantImpl()1812 void PoisonValue::destroyConstantImpl() {
1813 // Free the constant and any dangling references to it.
1814 getContext().pImpl->PVConstants.erase(getType());
1815 }
1816
get(BasicBlock * BB)1817 BlockAddress *BlockAddress::get(BasicBlock *BB) {
1818 assert(BB->getParent() && "Block must have a parent");
1819 return get(BB->getParent(), BB);
1820 }
1821
get(Function * F,BasicBlock * BB)1822 BlockAddress *BlockAddress::get(Function *F, BasicBlock *BB) {
1823 BlockAddress *&BA =
1824 F->getContext().pImpl->BlockAddresses[std::make_pair(F, BB)];
1825 if (!BA)
1826 BA = new BlockAddress(F, BB);
1827
1828 assert(BA->getFunction() == F && "Basic block moved between functions");
1829 return BA;
1830 }
1831
BlockAddress(Function * F,BasicBlock * BB)1832 BlockAddress::BlockAddress(Function *F, BasicBlock *BB)
1833 : Constant(Type::getInt8PtrTy(F->getContext()), Value::BlockAddressVal,
1834 &Op<0>(), 2) {
1835 setOperand(0, F);
1836 setOperand(1, BB);
1837 BB->AdjustBlockAddressRefCount(1);
1838 }
1839
lookup(const BasicBlock * BB)1840 BlockAddress *BlockAddress::lookup(const BasicBlock *BB) {
1841 if (!BB->hasAddressTaken())
1842 return nullptr;
1843
1844 const Function *F = BB->getParent();
1845 assert(F && "Block must have a parent");
1846 BlockAddress *BA =
1847 F->getContext().pImpl->BlockAddresses.lookup(std::make_pair(F, BB));
1848 assert(BA && "Refcount and block address map disagree!");
1849 return BA;
1850 }
1851
1852 /// Remove the constant from the constant table.
destroyConstantImpl()1853 void BlockAddress::destroyConstantImpl() {
1854 getFunction()->getType()->getContext().pImpl
1855 ->BlockAddresses.erase(std::make_pair(getFunction(), getBasicBlock()));
1856 getBasicBlock()->AdjustBlockAddressRefCount(-1);
1857 }
1858
handleOperandChangeImpl(Value * From,Value * To)1859 Value *BlockAddress::handleOperandChangeImpl(Value *From, Value *To) {
1860 // This could be replacing either the Basic Block or the Function. In either
1861 // case, we have to remove the map entry.
1862 Function *NewF = getFunction();
1863 BasicBlock *NewBB = getBasicBlock();
1864
1865 if (From == NewF)
1866 NewF = cast<Function>(To->stripPointerCasts());
1867 else {
1868 assert(From == NewBB && "From does not match any operand");
1869 NewBB = cast<BasicBlock>(To);
1870 }
1871
1872 // See if the 'new' entry already exists, if not, just update this in place
1873 // and return early.
1874 BlockAddress *&NewBA =
1875 getContext().pImpl->BlockAddresses[std::make_pair(NewF, NewBB)];
1876 if (NewBA)
1877 return NewBA;
1878
1879 getBasicBlock()->AdjustBlockAddressRefCount(-1);
1880
1881 // Remove the old entry, this can't cause the map to rehash (just a
1882 // tombstone will get added).
1883 getContext().pImpl->BlockAddresses.erase(std::make_pair(getFunction(),
1884 getBasicBlock()));
1885 NewBA = this;
1886 setOperand(0, NewF);
1887 setOperand(1, NewBB);
1888 getBasicBlock()->AdjustBlockAddressRefCount(1);
1889
1890 // If we just want to keep the existing value, then return null.
1891 // Callers know that this means we shouldn't delete this value.
1892 return nullptr;
1893 }
1894
get(GlobalValue * GV)1895 DSOLocalEquivalent *DSOLocalEquivalent::get(GlobalValue *GV) {
1896 DSOLocalEquivalent *&Equiv = GV->getContext().pImpl->DSOLocalEquivalents[GV];
1897 if (!Equiv)
1898 Equiv = new DSOLocalEquivalent(GV);
1899
1900 assert(Equiv->getGlobalValue() == GV &&
1901 "DSOLocalFunction does not match the expected global value");
1902 return Equiv;
1903 }
1904
DSOLocalEquivalent(GlobalValue * GV)1905 DSOLocalEquivalent::DSOLocalEquivalent(GlobalValue *GV)
1906 : Constant(GV->getType(), Value::DSOLocalEquivalentVal, &Op<0>(), 1) {
1907 setOperand(0, GV);
1908 }
1909
1910 /// Remove the constant from the constant table.
destroyConstantImpl()1911 void DSOLocalEquivalent::destroyConstantImpl() {
1912 const GlobalValue *GV = getGlobalValue();
1913 GV->getContext().pImpl->DSOLocalEquivalents.erase(GV);
1914 }
1915
handleOperandChangeImpl(Value * From,Value * To)1916 Value *DSOLocalEquivalent::handleOperandChangeImpl(Value *From, Value *To) {
1917 assert(From == getGlobalValue() && "Changing value does not match operand.");
1918 assert(isa<Constant>(To) && "Can only replace the operands with a constant");
1919
1920 // The replacement is with another global value.
1921 if (const auto *ToObj = dyn_cast<GlobalValue>(To)) {
1922 DSOLocalEquivalent *&NewEquiv =
1923 getContext().pImpl->DSOLocalEquivalents[ToObj];
1924 if (NewEquiv)
1925 return llvm::ConstantExpr::getBitCast(NewEquiv, getType());
1926 }
1927
1928 // If the argument is replaced with a null value, just replace this constant
1929 // with a null value.
1930 if (cast<Constant>(To)->isNullValue())
1931 return To;
1932
1933 // The replacement could be a bitcast or an alias to another function. We can
1934 // replace it with a bitcast to the dso_local_equivalent of that function.
1935 auto *Func = cast<Function>(To->stripPointerCastsAndAliases());
1936 DSOLocalEquivalent *&NewEquiv = getContext().pImpl->DSOLocalEquivalents[Func];
1937 if (NewEquiv)
1938 return llvm::ConstantExpr::getBitCast(NewEquiv, getType());
1939
1940 // Replace this with the new one.
1941 getContext().pImpl->DSOLocalEquivalents.erase(getGlobalValue());
1942 NewEquiv = this;
1943 setOperand(0, Func);
1944
1945 if (Func->getType() != getType()) {
1946 // It is ok to mutate the type here because this constant should always
1947 // reflect the type of the function it's holding.
1948 mutateType(Func->getType());
1949 }
1950 return nullptr;
1951 }
1952
1953 //---- ConstantExpr::get() implementations.
1954 //
1955
1956 /// This is a utility function to handle folding of casts and lookup of the
1957 /// cast in the ExprConstants map. It is used by the various get* methods below.
getFoldedCast(Instruction::CastOps opc,Constant * C,Type * Ty,bool OnlyIfReduced=false)1958 static Constant *getFoldedCast(Instruction::CastOps opc, Constant *C, Type *Ty,
1959 bool OnlyIfReduced = false) {
1960 assert(Ty->isFirstClassType() && "Cannot cast to an aggregate type!");
1961 // Fold a few common cases
1962 if (Constant *FC = ConstantFoldCastInstruction(opc, C, Ty))
1963 return FC;
1964
1965 if (OnlyIfReduced)
1966 return nullptr;
1967
1968 LLVMContextImpl *pImpl = Ty->getContext().pImpl;
1969
1970 // Look up the constant in the table first to ensure uniqueness.
1971 ConstantExprKeyType Key(opc, C);
1972
1973 return pImpl->ExprConstants.getOrCreate(Ty, Key);
1974 }
1975
getCast(unsigned oc,Constant * C,Type * Ty,bool OnlyIfReduced)1976 Constant *ConstantExpr::getCast(unsigned oc, Constant *C, Type *Ty,
1977 bool OnlyIfReduced) {
1978 Instruction::CastOps opc = Instruction::CastOps(oc);
1979 assert(Instruction::isCast(opc) && "opcode out of range");
1980 assert(C && Ty && "Null arguments to getCast");
1981 assert(CastInst::castIsValid(opc, C, Ty) && "Invalid constantexpr cast!");
1982
1983 switch (opc) {
1984 default:
1985 llvm_unreachable("Invalid cast opcode");
1986 case Instruction::Trunc:
1987 return getTrunc(C, Ty, OnlyIfReduced);
1988 case Instruction::ZExt:
1989 return getZExt(C, Ty, OnlyIfReduced);
1990 case Instruction::SExt:
1991 return getSExt(C, Ty, OnlyIfReduced);
1992 case Instruction::FPTrunc:
1993 return getFPTrunc(C, Ty, OnlyIfReduced);
1994 case Instruction::FPExt:
1995 return getFPExtend(C, Ty, OnlyIfReduced);
1996 case Instruction::UIToFP:
1997 return getUIToFP(C, Ty, OnlyIfReduced);
1998 case Instruction::SIToFP:
1999 return getSIToFP(C, Ty, OnlyIfReduced);
2000 case Instruction::FPToUI:
2001 return getFPToUI(C, Ty, OnlyIfReduced);
2002 case Instruction::FPToSI:
2003 return getFPToSI(C, Ty, OnlyIfReduced);
2004 case Instruction::PtrToInt:
2005 return getPtrToInt(C, Ty, OnlyIfReduced);
2006 case Instruction::IntToPtr:
2007 return getIntToPtr(C, Ty, OnlyIfReduced);
2008 case Instruction::BitCast:
2009 return getBitCast(C, Ty, OnlyIfReduced);
2010 case Instruction::AddrSpaceCast:
2011 return getAddrSpaceCast(C, Ty, OnlyIfReduced);
2012 }
2013 }
2014
getZExtOrBitCast(Constant * C,Type * Ty)2015 Constant *ConstantExpr::getZExtOrBitCast(Constant *C, Type *Ty) {
2016 if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
2017 return getBitCast(C, Ty);
2018 return getZExt(C, Ty);
2019 }
2020
getSExtOrBitCast(Constant * C,Type * Ty)2021 Constant *ConstantExpr::getSExtOrBitCast(Constant *C, Type *Ty) {
2022 if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
2023 return getBitCast(C, Ty);
2024 return getSExt(C, Ty);
2025 }
2026
getTruncOrBitCast(Constant * C,Type * Ty)2027 Constant *ConstantExpr::getTruncOrBitCast(Constant *C, Type *Ty) {
2028 if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
2029 return getBitCast(C, Ty);
2030 return getTrunc(C, Ty);
2031 }
2032
getPointerCast(Constant * S,Type * Ty)2033 Constant *ConstantExpr::getPointerCast(Constant *S, Type *Ty) {
2034 assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast");
2035 assert((Ty->isIntOrIntVectorTy() || Ty->isPtrOrPtrVectorTy()) &&
2036 "Invalid cast");
2037
2038 if (Ty->isIntOrIntVectorTy())
2039 return getPtrToInt(S, Ty);
2040
2041 unsigned SrcAS = S->getType()->getPointerAddressSpace();
2042 if (Ty->isPtrOrPtrVectorTy() && SrcAS != Ty->getPointerAddressSpace())
2043 return getAddrSpaceCast(S, Ty);
2044
2045 return getBitCast(S, Ty);
2046 }
2047
getPointerBitCastOrAddrSpaceCast(Constant * S,Type * Ty)2048 Constant *ConstantExpr::getPointerBitCastOrAddrSpaceCast(Constant *S,
2049 Type *Ty) {
2050 assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast");
2051 assert(Ty->isPtrOrPtrVectorTy() && "Invalid cast");
2052
2053 if (S->getType()->getPointerAddressSpace() != Ty->getPointerAddressSpace())
2054 return getAddrSpaceCast(S, Ty);
2055
2056 return getBitCast(S, Ty);
2057 }
2058
getIntegerCast(Constant * C,Type * Ty,bool isSigned)2059 Constant *ConstantExpr::getIntegerCast(Constant *C, Type *Ty, bool isSigned) {
2060 assert(C->getType()->isIntOrIntVectorTy() &&
2061 Ty->isIntOrIntVectorTy() && "Invalid cast");
2062 unsigned SrcBits = C->getType()->getScalarSizeInBits();
2063 unsigned DstBits = Ty->getScalarSizeInBits();
2064 Instruction::CastOps opcode =
2065 (SrcBits == DstBits ? Instruction::BitCast :
2066 (SrcBits > DstBits ? Instruction::Trunc :
2067 (isSigned ? Instruction::SExt : Instruction::ZExt)));
2068 return getCast(opcode, C, Ty);
2069 }
2070
getFPCast(Constant * C,Type * Ty)2071 Constant *ConstantExpr::getFPCast(Constant *C, Type *Ty) {
2072 assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
2073 "Invalid cast");
2074 unsigned SrcBits = C->getType()->getScalarSizeInBits();
2075 unsigned DstBits = Ty->getScalarSizeInBits();
2076 if (SrcBits == DstBits)
2077 return C; // Avoid a useless cast
2078 Instruction::CastOps opcode =
2079 (SrcBits > DstBits ? Instruction::FPTrunc : Instruction::FPExt);
2080 return getCast(opcode, C, Ty);
2081 }
2082
getTrunc(Constant * C,Type * Ty,bool OnlyIfReduced)2083 Constant *ConstantExpr::getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced) {
2084 #ifndef NDEBUG
2085 bool fromVec = isa<VectorType>(C->getType());
2086 bool toVec = isa<VectorType>(Ty);
2087 #endif
2088 assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2089 assert(C->getType()->isIntOrIntVectorTy() && "Trunc operand must be integer");
2090 assert(Ty->isIntOrIntVectorTy() && "Trunc produces only integral");
2091 assert(C->getType()->getScalarSizeInBits() > Ty->getScalarSizeInBits()&&
2092 "SrcTy must be larger than DestTy for Trunc!");
2093
2094 return getFoldedCast(Instruction::Trunc, C, Ty, OnlyIfReduced);
2095 }
2096
getSExt(Constant * C,Type * Ty,bool OnlyIfReduced)2097 Constant *ConstantExpr::getSExt(Constant *C, Type *Ty, bool OnlyIfReduced) {
2098 #ifndef NDEBUG
2099 bool fromVec = isa<VectorType>(C->getType());
2100 bool toVec = isa<VectorType>(Ty);
2101 #endif
2102 assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2103 assert(C->getType()->isIntOrIntVectorTy() && "SExt operand must be integral");
2104 assert(Ty->isIntOrIntVectorTy() && "SExt produces only integer");
2105 assert(C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
2106 "SrcTy must be smaller than DestTy for SExt!");
2107
2108 return getFoldedCast(Instruction::SExt, C, Ty, OnlyIfReduced);
2109 }
2110
getZExt(Constant * C,Type * Ty,bool OnlyIfReduced)2111 Constant *ConstantExpr::getZExt(Constant *C, Type *Ty, bool OnlyIfReduced) {
2112 #ifndef NDEBUG
2113 bool fromVec = isa<VectorType>(C->getType());
2114 bool toVec = isa<VectorType>(Ty);
2115 #endif
2116 assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2117 assert(C->getType()->isIntOrIntVectorTy() && "ZEXt operand must be integral");
2118 assert(Ty->isIntOrIntVectorTy() && "ZExt produces only integer");
2119 assert(C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
2120 "SrcTy must be smaller than DestTy for ZExt!");
2121
2122 return getFoldedCast(Instruction::ZExt, C, Ty, OnlyIfReduced);
2123 }
2124
getFPTrunc(Constant * C,Type * Ty,bool OnlyIfReduced)2125 Constant *ConstantExpr::getFPTrunc(Constant *C, Type *Ty, bool OnlyIfReduced) {
2126 #ifndef NDEBUG
2127 bool fromVec = isa<VectorType>(C->getType());
2128 bool toVec = isa<VectorType>(Ty);
2129 #endif
2130 assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2131 assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
2132 C->getType()->getScalarSizeInBits() > Ty->getScalarSizeInBits()&&
2133 "This is an illegal floating point truncation!");
2134 return getFoldedCast(Instruction::FPTrunc, C, Ty, OnlyIfReduced);
2135 }
2136
getFPExtend(Constant * C,Type * Ty,bool OnlyIfReduced)2137 Constant *ConstantExpr::getFPExtend(Constant *C, Type *Ty, bool OnlyIfReduced) {
2138 #ifndef NDEBUG
2139 bool fromVec = isa<VectorType>(C->getType());
2140 bool toVec = isa<VectorType>(Ty);
2141 #endif
2142 assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2143 assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
2144 C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
2145 "This is an illegal floating point extension!");
2146 return getFoldedCast(Instruction::FPExt, C, Ty, OnlyIfReduced);
2147 }
2148
getUIToFP(Constant * C,Type * Ty,bool OnlyIfReduced)2149 Constant *ConstantExpr::getUIToFP(Constant *C, Type *Ty, bool OnlyIfReduced) {
2150 #ifndef NDEBUG
2151 bool fromVec = isa<VectorType>(C->getType());
2152 bool toVec = isa<VectorType>(Ty);
2153 #endif
2154 assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2155 assert(C->getType()->isIntOrIntVectorTy() && Ty->isFPOrFPVectorTy() &&
2156 "This is an illegal uint to floating point cast!");
2157 return getFoldedCast(Instruction::UIToFP, C, Ty, OnlyIfReduced);
2158 }
2159
getSIToFP(Constant * C,Type * Ty,bool OnlyIfReduced)2160 Constant *ConstantExpr::getSIToFP(Constant *C, Type *Ty, bool OnlyIfReduced) {
2161 #ifndef NDEBUG
2162 bool fromVec = isa<VectorType>(C->getType());
2163 bool toVec = isa<VectorType>(Ty);
2164 #endif
2165 assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2166 assert(C->getType()->isIntOrIntVectorTy() && Ty->isFPOrFPVectorTy() &&
2167 "This is an illegal sint to floating point cast!");
2168 return getFoldedCast(Instruction::SIToFP, C, Ty, OnlyIfReduced);
2169 }
2170
getFPToUI(Constant * C,Type * Ty,bool OnlyIfReduced)2171 Constant *ConstantExpr::getFPToUI(Constant *C, Type *Ty, bool OnlyIfReduced) {
2172 #ifndef NDEBUG
2173 bool fromVec = isa<VectorType>(C->getType());
2174 bool toVec = isa<VectorType>(Ty);
2175 #endif
2176 assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2177 assert(C->getType()->isFPOrFPVectorTy() && Ty->isIntOrIntVectorTy() &&
2178 "This is an illegal floating point to uint cast!");
2179 return getFoldedCast(Instruction::FPToUI, C, Ty, OnlyIfReduced);
2180 }
2181
getFPToSI(Constant * C,Type * Ty,bool OnlyIfReduced)2182 Constant *ConstantExpr::getFPToSI(Constant *C, Type *Ty, bool OnlyIfReduced) {
2183 #ifndef NDEBUG
2184 bool fromVec = isa<VectorType>(C->getType());
2185 bool toVec = isa<VectorType>(Ty);
2186 #endif
2187 assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2188 assert(C->getType()->isFPOrFPVectorTy() && Ty->isIntOrIntVectorTy() &&
2189 "This is an illegal floating point to sint cast!");
2190 return getFoldedCast(Instruction::FPToSI, C, Ty, OnlyIfReduced);
2191 }
2192
getPtrToInt(Constant * C,Type * DstTy,bool OnlyIfReduced)2193 Constant *ConstantExpr::getPtrToInt(Constant *C, Type *DstTy,
2194 bool OnlyIfReduced) {
2195 assert(C->getType()->isPtrOrPtrVectorTy() &&
2196 "PtrToInt source must be pointer or pointer vector");
2197 assert(DstTy->isIntOrIntVectorTy() &&
2198 "PtrToInt destination must be integer or integer vector");
2199 assert(isa<VectorType>(C->getType()) == isa<VectorType>(DstTy));
2200 if (isa<VectorType>(C->getType()))
2201 assert(cast<FixedVectorType>(C->getType())->getNumElements() ==
2202 cast<FixedVectorType>(DstTy)->getNumElements() &&
2203 "Invalid cast between a different number of vector elements");
2204 return getFoldedCast(Instruction::PtrToInt, C, DstTy, OnlyIfReduced);
2205 }
2206
getIntToPtr(Constant * C,Type * DstTy,bool OnlyIfReduced)2207 Constant *ConstantExpr::getIntToPtr(Constant *C, Type *DstTy,
2208 bool OnlyIfReduced) {
2209 assert(C->getType()->isIntOrIntVectorTy() &&
2210 "IntToPtr source must be integer or integer vector");
2211 assert(DstTy->isPtrOrPtrVectorTy() &&
2212 "IntToPtr destination must be a pointer or pointer vector");
2213 assert(isa<VectorType>(C->getType()) == isa<VectorType>(DstTy));
2214 if (isa<VectorType>(C->getType()))
2215 assert(cast<VectorType>(C->getType())->getElementCount() ==
2216 cast<VectorType>(DstTy)->getElementCount() &&
2217 "Invalid cast between a different number of vector elements");
2218 return getFoldedCast(Instruction::IntToPtr, C, DstTy, OnlyIfReduced);
2219 }
2220
getBitCast(Constant * C,Type * DstTy,bool OnlyIfReduced)2221 Constant *ConstantExpr::getBitCast(Constant *C, Type *DstTy,
2222 bool OnlyIfReduced) {
2223 assert(CastInst::castIsValid(Instruction::BitCast, C, DstTy) &&
2224 "Invalid constantexpr bitcast!");
2225
2226 // It is common to ask for a bitcast of a value to its own type, handle this
2227 // speedily.
2228 if (C->getType() == DstTy) return C;
2229
2230 return getFoldedCast(Instruction::BitCast, C, DstTy, OnlyIfReduced);
2231 }
2232
getAddrSpaceCast(Constant * C,Type * DstTy,bool OnlyIfReduced)2233 Constant *ConstantExpr::getAddrSpaceCast(Constant *C, Type *DstTy,
2234 bool OnlyIfReduced) {
2235 assert(CastInst::castIsValid(Instruction::AddrSpaceCast, C, DstTy) &&
2236 "Invalid constantexpr addrspacecast!");
2237
2238 // Canonicalize addrspacecasts between different pointer types by first
2239 // bitcasting the pointer type and then converting the address space.
2240 PointerType *SrcScalarTy = cast<PointerType>(C->getType()->getScalarType());
2241 PointerType *DstScalarTy = cast<PointerType>(DstTy->getScalarType());
2242 Type *DstElemTy = DstScalarTy->getElementType();
2243 if (SrcScalarTy->getElementType() != DstElemTy) {
2244 Type *MidTy = PointerType::get(DstElemTy, SrcScalarTy->getAddressSpace());
2245 if (VectorType *VT = dyn_cast<VectorType>(DstTy)) {
2246 // Handle vectors of pointers.
2247 MidTy = FixedVectorType::get(MidTy,
2248 cast<FixedVectorType>(VT)->getNumElements());
2249 }
2250 C = getBitCast(C, MidTy);
2251 }
2252 return getFoldedCast(Instruction::AddrSpaceCast, C, DstTy, OnlyIfReduced);
2253 }
2254
get(unsigned Opcode,Constant * C,unsigned Flags,Type * OnlyIfReducedTy)2255 Constant *ConstantExpr::get(unsigned Opcode, Constant *C, unsigned Flags,
2256 Type *OnlyIfReducedTy) {
2257 // Check the operands for consistency first.
2258 assert(Instruction::isUnaryOp(Opcode) &&
2259 "Invalid opcode in unary constant expression");
2260
2261 #ifndef NDEBUG
2262 switch (Opcode) {
2263 case Instruction::FNeg:
2264 assert(C->getType()->isFPOrFPVectorTy() &&
2265 "Tried to create a floating-point operation on a "
2266 "non-floating-point type!");
2267 break;
2268 default:
2269 break;
2270 }
2271 #endif
2272
2273 if (Constant *FC = ConstantFoldUnaryInstruction(Opcode, C))
2274 return FC;
2275
2276 if (OnlyIfReducedTy == C->getType())
2277 return nullptr;
2278
2279 Constant *ArgVec[] = { C };
2280 ConstantExprKeyType Key(Opcode, ArgVec, 0, Flags);
2281
2282 LLVMContextImpl *pImpl = C->getContext().pImpl;
2283 return pImpl->ExprConstants.getOrCreate(C->getType(), Key);
2284 }
2285
get(unsigned Opcode,Constant * C1,Constant * C2,unsigned Flags,Type * OnlyIfReducedTy)2286 Constant *ConstantExpr::get(unsigned Opcode, Constant *C1, Constant *C2,
2287 unsigned Flags, Type *OnlyIfReducedTy) {
2288 // Check the operands for consistency first.
2289 assert(Instruction::isBinaryOp(Opcode) &&
2290 "Invalid opcode in binary constant expression");
2291 assert(C1->getType() == C2->getType() &&
2292 "Operand types in binary constant expression should match");
2293
2294 #ifndef NDEBUG
2295 switch (Opcode) {
2296 case Instruction::Add:
2297 case Instruction::Sub:
2298 case Instruction::Mul:
2299 case Instruction::UDiv:
2300 case Instruction::SDiv:
2301 case Instruction::URem:
2302 case Instruction::SRem:
2303 assert(C1->getType()->isIntOrIntVectorTy() &&
2304 "Tried to create an integer operation on a non-integer type!");
2305 break;
2306 case Instruction::FAdd:
2307 case Instruction::FSub:
2308 case Instruction::FMul:
2309 case Instruction::FDiv:
2310 case Instruction::FRem:
2311 assert(C1->getType()->isFPOrFPVectorTy() &&
2312 "Tried to create a floating-point operation on a "
2313 "non-floating-point type!");
2314 break;
2315 case Instruction::And:
2316 case Instruction::Or:
2317 case Instruction::Xor:
2318 assert(C1->getType()->isIntOrIntVectorTy() &&
2319 "Tried to create a logical operation on a non-integral type!");
2320 break;
2321 case Instruction::Shl:
2322 case Instruction::LShr:
2323 case Instruction::AShr:
2324 assert(C1->getType()->isIntOrIntVectorTy() &&
2325 "Tried to create a shift operation on a non-integer type!");
2326 break;
2327 default:
2328 break;
2329 }
2330 #endif
2331
2332 if (Constant *FC = ConstantFoldBinaryInstruction(Opcode, C1, C2))
2333 return FC;
2334
2335 if (OnlyIfReducedTy == C1->getType())
2336 return nullptr;
2337
2338 Constant *ArgVec[] = { C1, C2 };
2339 ConstantExprKeyType Key(Opcode, ArgVec, 0, Flags);
2340
2341 LLVMContextImpl *pImpl = C1->getContext().pImpl;
2342 return pImpl->ExprConstants.getOrCreate(C1->getType(), Key);
2343 }
2344
getSizeOf(Type * Ty)2345 Constant *ConstantExpr::getSizeOf(Type* Ty) {
2346 // sizeof is implemented as: (i64) gep (Ty*)null, 1
2347 // Note that a non-inbounds gep is used, as null isn't within any object.
2348 Constant *GEPIdx = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1);
2349 Constant *GEP = getGetElementPtr(
2350 Ty, Constant::getNullValue(PointerType::getUnqual(Ty)), GEPIdx);
2351 return getPtrToInt(GEP,
2352 Type::getInt64Ty(Ty->getContext()));
2353 }
2354
getAlignOf(Type * Ty)2355 Constant *ConstantExpr::getAlignOf(Type* Ty) {
2356 // alignof is implemented as: (i64) gep ({i1,Ty}*)null, 0, 1
2357 // Note that a non-inbounds gep is used, as null isn't within any object.
2358 Type *AligningTy = StructType::get(Type::getInt1Ty(Ty->getContext()), Ty);
2359 Constant *NullPtr = Constant::getNullValue(AligningTy->getPointerTo(0));
2360 Constant *Zero = ConstantInt::get(Type::getInt64Ty(Ty->getContext()), 0);
2361 Constant *One = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1);
2362 Constant *Indices[2] = { Zero, One };
2363 Constant *GEP = getGetElementPtr(AligningTy, NullPtr, Indices);
2364 return getPtrToInt(GEP,
2365 Type::getInt64Ty(Ty->getContext()));
2366 }
2367
getOffsetOf(StructType * STy,unsigned FieldNo)2368 Constant *ConstantExpr::getOffsetOf(StructType* STy, unsigned FieldNo) {
2369 return getOffsetOf(STy, ConstantInt::get(Type::getInt32Ty(STy->getContext()),
2370 FieldNo));
2371 }
2372
getOffsetOf(Type * Ty,Constant * FieldNo)2373 Constant *ConstantExpr::getOffsetOf(Type* Ty, Constant *FieldNo) {
2374 // offsetof is implemented as: (i64) gep (Ty*)null, 0, FieldNo
2375 // Note that a non-inbounds gep is used, as null isn't within any object.
2376 Constant *GEPIdx[] = {
2377 ConstantInt::get(Type::getInt64Ty(Ty->getContext()), 0),
2378 FieldNo
2379 };
2380 Constant *GEP = getGetElementPtr(
2381 Ty, Constant::getNullValue(PointerType::getUnqual(Ty)), GEPIdx);
2382 return getPtrToInt(GEP,
2383 Type::getInt64Ty(Ty->getContext()));
2384 }
2385
getCompare(unsigned short Predicate,Constant * C1,Constant * C2,bool OnlyIfReduced)2386 Constant *ConstantExpr::getCompare(unsigned short Predicate, Constant *C1,
2387 Constant *C2, bool OnlyIfReduced) {
2388 assert(C1->getType() == C2->getType() && "Op types should be identical!");
2389
2390 switch (Predicate) {
2391 default: llvm_unreachable("Invalid CmpInst predicate");
2392 case CmpInst::FCMP_FALSE: case CmpInst::FCMP_OEQ: case CmpInst::FCMP_OGT:
2393 case CmpInst::FCMP_OGE: case CmpInst::FCMP_OLT: case CmpInst::FCMP_OLE:
2394 case CmpInst::FCMP_ONE: case CmpInst::FCMP_ORD: case CmpInst::FCMP_UNO:
2395 case CmpInst::FCMP_UEQ: case CmpInst::FCMP_UGT: case CmpInst::FCMP_UGE:
2396 case CmpInst::FCMP_ULT: case CmpInst::FCMP_ULE: case CmpInst::FCMP_UNE:
2397 case CmpInst::FCMP_TRUE:
2398 return getFCmp(Predicate, C1, C2, OnlyIfReduced);
2399
2400 case CmpInst::ICMP_EQ: case CmpInst::ICMP_NE: case CmpInst::ICMP_UGT:
2401 case CmpInst::ICMP_UGE: case CmpInst::ICMP_ULT: case CmpInst::ICMP_ULE:
2402 case CmpInst::ICMP_SGT: case CmpInst::ICMP_SGE: case CmpInst::ICMP_SLT:
2403 case CmpInst::ICMP_SLE:
2404 return getICmp(Predicate, C1, C2, OnlyIfReduced);
2405 }
2406 }
2407
getSelect(Constant * C,Constant * V1,Constant * V2,Type * OnlyIfReducedTy)2408 Constant *ConstantExpr::getSelect(Constant *C, Constant *V1, Constant *V2,
2409 Type *OnlyIfReducedTy) {
2410 assert(!SelectInst::areInvalidOperands(C, V1, V2)&&"Invalid select operands");
2411
2412 if (Constant *SC = ConstantFoldSelectInstruction(C, V1, V2))
2413 return SC; // Fold common cases
2414
2415 if (OnlyIfReducedTy == V1->getType())
2416 return nullptr;
2417
2418 Constant *ArgVec[] = { C, V1, V2 };
2419 ConstantExprKeyType Key(Instruction::Select, ArgVec);
2420
2421 LLVMContextImpl *pImpl = C->getContext().pImpl;
2422 return pImpl->ExprConstants.getOrCreate(V1->getType(), Key);
2423 }
2424
getGetElementPtr(Type * Ty,Constant * C,ArrayRef<Value * > Idxs,bool InBounds,Optional<unsigned> InRangeIndex,Type * OnlyIfReducedTy)2425 Constant *ConstantExpr::getGetElementPtr(Type *Ty, Constant *C,
2426 ArrayRef<Value *> Idxs, bool InBounds,
2427 Optional<unsigned> InRangeIndex,
2428 Type *OnlyIfReducedTy) {
2429 if (!Ty)
2430 Ty = cast<PointerType>(C->getType()->getScalarType())->getElementType();
2431 else
2432 assert(Ty ==
2433 cast<PointerType>(C->getType()->getScalarType())->getElementType());
2434
2435 if (Constant *FC =
2436 ConstantFoldGetElementPtr(Ty, C, InBounds, InRangeIndex, Idxs))
2437 return FC; // Fold a few common cases.
2438
2439 // Get the result type of the getelementptr!
2440 Type *DestTy = GetElementPtrInst::getIndexedType(Ty, Idxs);
2441 assert(DestTy && "GEP indices invalid!");
2442 unsigned AS = C->getType()->getPointerAddressSpace();
2443 Type *ReqTy = DestTy->getPointerTo(AS);
2444
2445 auto EltCount = ElementCount::getFixed(0);
2446 if (VectorType *VecTy = dyn_cast<VectorType>(C->getType()))
2447 EltCount = VecTy->getElementCount();
2448 else
2449 for (auto Idx : Idxs)
2450 if (VectorType *VecTy = dyn_cast<VectorType>(Idx->getType()))
2451 EltCount = VecTy->getElementCount();
2452
2453 if (EltCount.isNonZero())
2454 ReqTy = VectorType::get(ReqTy, EltCount);
2455
2456 if (OnlyIfReducedTy == ReqTy)
2457 return nullptr;
2458
2459 // Look up the constant in the table first to ensure uniqueness
2460 std::vector<Constant*> ArgVec;
2461 ArgVec.reserve(1 + Idxs.size());
2462 ArgVec.push_back(C);
2463 auto GTI = gep_type_begin(Ty, Idxs), GTE = gep_type_end(Ty, Idxs);
2464 for (; GTI != GTE; ++GTI) {
2465 auto *Idx = cast<Constant>(GTI.getOperand());
2466 assert(
2467 (!isa<VectorType>(Idx->getType()) ||
2468 cast<VectorType>(Idx->getType())->getElementCount() == EltCount) &&
2469 "getelementptr index type missmatch");
2470
2471 if (GTI.isStruct() && Idx->getType()->isVectorTy()) {
2472 Idx = Idx->getSplatValue();
2473 } else if (GTI.isSequential() && EltCount.isNonZero() &&
2474 !Idx->getType()->isVectorTy()) {
2475 Idx = ConstantVector::getSplat(EltCount, Idx);
2476 }
2477 ArgVec.push_back(Idx);
2478 }
2479
2480 unsigned SubClassOptionalData = InBounds ? GEPOperator::IsInBounds : 0;
2481 if (InRangeIndex && *InRangeIndex < 63)
2482 SubClassOptionalData |= (*InRangeIndex + 1) << 1;
2483 const ConstantExprKeyType Key(Instruction::GetElementPtr, ArgVec, 0,
2484 SubClassOptionalData, None, None, Ty);
2485
2486 LLVMContextImpl *pImpl = C->getContext().pImpl;
2487 return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
2488 }
2489
getICmp(unsigned short pred,Constant * LHS,Constant * RHS,bool OnlyIfReduced)2490 Constant *ConstantExpr::getICmp(unsigned short pred, Constant *LHS,
2491 Constant *RHS, bool OnlyIfReduced) {
2492 assert(LHS->getType() == RHS->getType());
2493 assert(CmpInst::isIntPredicate((CmpInst::Predicate)pred) &&
2494 "Invalid ICmp Predicate");
2495
2496 if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS))
2497 return FC; // Fold a few common cases...
2498
2499 if (OnlyIfReduced)
2500 return nullptr;
2501
2502 // Look up the constant in the table first to ensure uniqueness
2503 Constant *ArgVec[] = { LHS, RHS };
2504 // Get the key type with both the opcode and predicate
2505 const ConstantExprKeyType Key(Instruction::ICmp, ArgVec, pred);
2506
2507 Type *ResultTy = Type::getInt1Ty(LHS->getContext());
2508 if (VectorType *VT = dyn_cast<VectorType>(LHS->getType()))
2509 ResultTy = VectorType::get(ResultTy, VT->getElementCount());
2510
2511 LLVMContextImpl *pImpl = LHS->getType()->getContext().pImpl;
2512 return pImpl->ExprConstants.getOrCreate(ResultTy, Key);
2513 }
2514
getFCmp(unsigned short pred,Constant * LHS,Constant * RHS,bool OnlyIfReduced)2515 Constant *ConstantExpr::getFCmp(unsigned short pred, Constant *LHS,
2516 Constant *RHS, bool OnlyIfReduced) {
2517 assert(LHS->getType() == RHS->getType());
2518 assert(CmpInst::isFPPredicate((CmpInst::Predicate)pred) &&
2519 "Invalid FCmp Predicate");
2520
2521 if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS))
2522 return FC; // Fold a few common cases...
2523
2524 if (OnlyIfReduced)
2525 return nullptr;
2526
2527 // Look up the constant in the table first to ensure uniqueness
2528 Constant *ArgVec[] = { LHS, RHS };
2529 // Get the key type with both the opcode and predicate
2530 const ConstantExprKeyType Key(Instruction::FCmp, ArgVec, pred);
2531
2532 Type *ResultTy = Type::getInt1Ty(LHS->getContext());
2533 if (VectorType *VT = dyn_cast<VectorType>(LHS->getType()))
2534 ResultTy = VectorType::get(ResultTy, VT->getElementCount());
2535
2536 LLVMContextImpl *pImpl = LHS->getType()->getContext().pImpl;
2537 return pImpl->ExprConstants.getOrCreate(ResultTy, Key);
2538 }
2539
getExtractElement(Constant * Val,Constant * Idx,Type * OnlyIfReducedTy)2540 Constant *ConstantExpr::getExtractElement(Constant *Val, Constant *Idx,
2541 Type *OnlyIfReducedTy) {
2542 assert(Val->getType()->isVectorTy() &&
2543 "Tried to create extractelement operation on non-vector type!");
2544 assert(Idx->getType()->isIntegerTy() &&
2545 "Extractelement index must be an integer type!");
2546
2547 if (Constant *FC = ConstantFoldExtractElementInstruction(Val, Idx))
2548 return FC; // Fold a few common cases.
2549
2550 Type *ReqTy = cast<VectorType>(Val->getType())->getElementType();
2551 if (OnlyIfReducedTy == ReqTy)
2552 return nullptr;
2553
2554 // Look up the constant in the table first to ensure uniqueness
2555 Constant *ArgVec[] = { Val, Idx };
2556 const ConstantExprKeyType Key(Instruction::ExtractElement, ArgVec);
2557
2558 LLVMContextImpl *pImpl = Val->getContext().pImpl;
2559 return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
2560 }
2561
getInsertElement(Constant * Val,Constant * Elt,Constant * Idx,Type * OnlyIfReducedTy)2562 Constant *ConstantExpr::getInsertElement(Constant *Val, Constant *Elt,
2563 Constant *Idx, Type *OnlyIfReducedTy) {
2564 assert(Val->getType()->isVectorTy() &&
2565 "Tried to create insertelement operation on non-vector type!");
2566 assert(Elt->getType() == cast<VectorType>(Val->getType())->getElementType() &&
2567 "Insertelement types must match!");
2568 assert(Idx->getType()->isIntegerTy() &&
2569 "Insertelement index must be i32 type!");
2570
2571 if (Constant *FC = ConstantFoldInsertElementInstruction(Val, Elt, Idx))
2572 return FC; // Fold a few common cases.
2573
2574 if (OnlyIfReducedTy == Val->getType())
2575 return nullptr;
2576
2577 // Look up the constant in the table first to ensure uniqueness
2578 Constant *ArgVec[] = { Val, Elt, Idx };
2579 const ConstantExprKeyType Key(Instruction::InsertElement, ArgVec);
2580
2581 LLVMContextImpl *pImpl = Val->getContext().pImpl;
2582 return pImpl->ExprConstants.getOrCreate(Val->getType(), Key);
2583 }
2584
getShuffleVector(Constant * V1,Constant * V2,ArrayRef<int> Mask,Type * OnlyIfReducedTy)2585 Constant *ConstantExpr::getShuffleVector(Constant *V1, Constant *V2,
2586 ArrayRef<int> Mask,
2587 Type *OnlyIfReducedTy) {
2588 assert(ShuffleVectorInst::isValidOperands(V1, V2, Mask) &&
2589 "Invalid shuffle vector constant expr operands!");
2590
2591 if (Constant *FC = ConstantFoldShuffleVectorInstruction(V1, V2, Mask))
2592 return FC; // Fold a few common cases.
2593
2594 unsigned NElts = Mask.size();
2595 auto V1VTy = cast<VectorType>(V1->getType());
2596 Type *EltTy = V1VTy->getElementType();
2597 bool TypeIsScalable = isa<ScalableVectorType>(V1VTy);
2598 Type *ShufTy = VectorType::get(EltTy, NElts, TypeIsScalable);
2599
2600 if (OnlyIfReducedTy == ShufTy)
2601 return nullptr;
2602
2603 // Look up the constant in the table first to ensure uniqueness
2604 Constant *ArgVec[] = {V1, V2};
2605 ConstantExprKeyType Key(Instruction::ShuffleVector, ArgVec, 0, 0, None, Mask);
2606
2607 LLVMContextImpl *pImpl = ShufTy->getContext().pImpl;
2608 return pImpl->ExprConstants.getOrCreate(ShufTy, Key);
2609 }
2610
getInsertValue(Constant * Agg,Constant * Val,ArrayRef<unsigned> Idxs,Type * OnlyIfReducedTy)2611 Constant *ConstantExpr::getInsertValue(Constant *Agg, Constant *Val,
2612 ArrayRef<unsigned> Idxs,
2613 Type *OnlyIfReducedTy) {
2614 assert(Agg->getType()->isFirstClassType() &&
2615 "Non-first-class type for constant insertvalue expression");
2616
2617 assert(ExtractValueInst::getIndexedType(Agg->getType(),
2618 Idxs) == Val->getType() &&
2619 "insertvalue indices invalid!");
2620 Type *ReqTy = Val->getType();
2621
2622 if (Constant *FC = ConstantFoldInsertValueInstruction(Agg, Val, Idxs))
2623 return FC;
2624
2625 if (OnlyIfReducedTy == ReqTy)
2626 return nullptr;
2627
2628 Constant *ArgVec[] = { Agg, Val };
2629 const ConstantExprKeyType Key(Instruction::InsertValue, ArgVec, 0, 0, Idxs);
2630
2631 LLVMContextImpl *pImpl = Agg->getContext().pImpl;
2632 return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
2633 }
2634
getExtractValue(Constant * Agg,ArrayRef<unsigned> Idxs,Type * OnlyIfReducedTy)2635 Constant *ConstantExpr::getExtractValue(Constant *Agg, ArrayRef<unsigned> Idxs,
2636 Type *OnlyIfReducedTy) {
2637 assert(Agg->getType()->isFirstClassType() &&
2638 "Tried to create extractelement operation on non-first-class type!");
2639
2640 Type *ReqTy = ExtractValueInst::getIndexedType(Agg->getType(), Idxs);
2641 (void)ReqTy;
2642 assert(ReqTy && "extractvalue indices invalid!");
2643
2644 assert(Agg->getType()->isFirstClassType() &&
2645 "Non-first-class type for constant extractvalue expression");
2646 if (Constant *FC = ConstantFoldExtractValueInstruction(Agg, Idxs))
2647 return FC;
2648
2649 if (OnlyIfReducedTy == ReqTy)
2650 return nullptr;
2651
2652 Constant *ArgVec[] = { Agg };
2653 const ConstantExprKeyType Key(Instruction::ExtractValue, ArgVec, 0, 0, Idxs);
2654
2655 LLVMContextImpl *pImpl = Agg->getContext().pImpl;
2656 return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
2657 }
2658
getNeg(Constant * C,bool HasNUW,bool HasNSW)2659 Constant *ConstantExpr::getNeg(Constant *C, bool HasNUW, bool HasNSW) {
2660 assert(C->getType()->isIntOrIntVectorTy() &&
2661 "Cannot NEG a nonintegral value!");
2662 return getSub(ConstantFP::getZeroValueForNegation(C->getType()),
2663 C, HasNUW, HasNSW);
2664 }
2665
getFNeg(Constant * C)2666 Constant *ConstantExpr::getFNeg(Constant *C) {
2667 assert(C->getType()->isFPOrFPVectorTy() &&
2668 "Cannot FNEG a non-floating-point value!");
2669 return get(Instruction::FNeg, C);
2670 }
2671
getNot(Constant * C)2672 Constant *ConstantExpr::getNot(Constant *C) {
2673 assert(C->getType()->isIntOrIntVectorTy() &&
2674 "Cannot NOT a nonintegral value!");
2675 return get(Instruction::Xor, C, Constant::getAllOnesValue(C->getType()));
2676 }
2677
getAdd(Constant * C1,Constant * C2,bool HasNUW,bool HasNSW)2678 Constant *ConstantExpr::getAdd(Constant *C1, Constant *C2,
2679 bool HasNUW, bool HasNSW) {
2680 unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
2681 (HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0);
2682 return get(Instruction::Add, C1, C2, Flags);
2683 }
2684
getFAdd(Constant * C1,Constant * C2)2685 Constant *ConstantExpr::getFAdd(Constant *C1, Constant *C2) {
2686 return get(Instruction::FAdd, C1, C2);
2687 }
2688
getSub(Constant * C1,Constant * C2,bool HasNUW,bool HasNSW)2689 Constant *ConstantExpr::getSub(Constant *C1, Constant *C2,
2690 bool HasNUW, bool HasNSW) {
2691 unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
2692 (HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0);
2693 return get(Instruction::Sub, C1, C2, Flags);
2694 }
2695
getFSub(Constant * C1,Constant * C2)2696 Constant *ConstantExpr::getFSub(Constant *C1, Constant *C2) {
2697 return get(Instruction::FSub, C1, C2);
2698 }
2699
getMul(Constant * C1,Constant * C2,bool HasNUW,bool HasNSW)2700 Constant *ConstantExpr::getMul(Constant *C1, Constant *C2,
2701 bool HasNUW, bool HasNSW) {
2702 unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
2703 (HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0);
2704 return get(Instruction::Mul, C1, C2, Flags);
2705 }
2706
getFMul(Constant * C1,Constant * C2)2707 Constant *ConstantExpr::getFMul(Constant *C1, Constant *C2) {
2708 return get(Instruction::FMul, C1, C2);
2709 }
2710
getUDiv(Constant * C1,Constant * C2,bool isExact)2711 Constant *ConstantExpr::getUDiv(Constant *C1, Constant *C2, bool isExact) {
2712 return get(Instruction::UDiv, C1, C2,
2713 isExact ? PossiblyExactOperator::IsExact : 0);
2714 }
2715
getSDiv(Constant * C1,Constant * C2,bool isExact)2716 Constant *ConstantExpr::getSDiv(Constant *C1, Constant *C2, bool isExact) {
2717 return get(Instruction::SDiv, C1, C2,
2718 isExact ? PossiblyExactOperator::IsExact : 0);
2719 }
2720
getFDiv(Constant * C1,Constant * C2)2721 Constant *ConstantExpr::getFDiv(Constant *C1, Constant *C2) {
2722 return get(Instruction::FDiv, C1, C2);
2723 }
2724
getURem(Constant * C1,Constant * C2)2725 Constant *ConstantExpr::getURem(Constant *C1, Constant *C2) {
2726 return get(Instruction::URem, C1, C2);
2727 }
2728
getSRem(Constant * C1,Constant * C2)2729 Constant *ConstantExpr::getSRem(Constant *C1, Constant *C2) {
2730 return get(Instruction::SRem, C1, C2);
2731 }
2732
getFRem(Constant * C1,Constant * C2)2733 Constant *ConstantExpr::getFRem(Constant *C1, Constant *C2) {
2734 return get(Instruction::FRem, C1, C2);
2735 }
2736
getAnd(Constant * C1,Constant * C2)2737 Constant *ConstantExpr::getAnd(Constant *C1, Constant *C2) {
2738 return get(Instruction::And, C1, C2);
2739 }
2740
getOr(Constant * C1,Constant * C2)2741 Constant *ConstantExpr::getOr(Constant *C1, Constant *C2) {
2742 return get(Instruction::Or, C1, C2);
2743 }
2744
getXor(Constant * C1,Constant * C2)2745 Constant *ConstantExpr::getXor(Constant *C1, Constant *C2) {
2746 return get(Instruction::Xor, C1, C2);
2747 }
2748
getUMin(Constant * C1,Constant * C2)2749 Constant *ConstantExpr::getUMin(Constant *C1, Constant *C2) {
2750 Constant *Cmp = ConstantExpr::getICmp(CmpInst::ICMP_ULT, C1, C2);
2751 return getSelect(Cmp, C1, C2);
2752 }
2753
getShl(Constant * C1,Constant * C2,bool HasNUW,bool HasNSW)2754 Constant *ConstantExpr::getShl(Constant *C1, Constant *C2,
2755 bool HasNUW, bool HasNSW) {
2756 unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
2757 (HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0);
2758 return get(Instruction::Shl, C1, C2, Flags);
2759 }
2760
getLShr(Constant * C1,Constant * C2,bool isExact)2761 Constant *ConstantExpr::getLShr(Constant *C1, Constant *C2, bool isExact) {
2762 return get(Instruction::LShr, C1, C2,
2763 isExact ? PossiblyExactOperator::IsExact : 0);
2764 }
2765
getAShr(Constant * C1,Constant * C2,bool isExact)2766 Constant *ConstantExpr::getAShr(Constant *C1, Constant *C2, bool isExact) {
2767 return get(Instruction::AShr, C1, C2,
2768 isExact ? PossiblyExactOperator::IsExact : 0);
2769 }
2770
getExactLogBase2(Constant * C)2771 Constant *ConstantExpr::getExactLogBase2(Constant *C) {
2772 Type *Ty = C->getType();
2773 const APInt *IVal;
2774 if (match(C, m_APInt(IVal)) && IVal->isPowerOf2())
2775 return ConstantInt::get(Ty, IVal->logBase2());
2776
2777 // FIXME: We can extract pow of 2 of splat constant for scalable vectors.
2778 auto *VecTy = dyn_cast<FixedVectorType>(Ty);
2779 if (!VecTy)
2780 return nullptr;
2781
2782 SmallVector<Constant *, 4> Elts;
2783 for (unsigned I = 0, E = VecTy->getNumElements(); I != E; ++I) {
2784 Constant *Elt = C->getAggregateElement(I);
2785 if (!Elt)
2786 return nullptr;
2787 // Note that log2(iN undef) is *NOT* iN undef, because log2(iN undef) u< N.
2788 if (isa<UndefValue>(Elt)) {
2789 Elts.push_back(Constant::getNullValue(Ty->getScalarType()));
2790 continue;
2791 }
2792 if (!match(Elt, m_APInt(IVal)) || !IVal->isPowerOf2())
2793 return nullptr;
2794 Elts.push_back(ConstantInt::get(Ty->getScalarType(), IVal->logBase2()));
2795 }
2796
2797 return ConstantVector::get(Elts);
2798 }
2799
getBinOpIdentity(unsigned Opcode,Type * Ty,bool AllowRHSConstant)2800 Constant *ConstantExpr::getBinOpIdentity(unsigned Opcode, Type *Ty,
2801 bool AllowRHSConstant) {
2802 assert(Instruction::isBinaryOp(Opcode) && "Only binops allowed");
2803
2804 // Commutative opcodes: it does not matter if AllowRHSConstant is set.
2805 if (Instruction::isCommutative(Opcode)) {
2806 switch (Opcode) {
2807 case Instruction::Add: // X + 0 = X
2808 case Instruction::Or: // X | 0 = X
2809 case Instruction::Xor: // X ^ 0 = X
2810 return Constant::getNullValue(Ty);
2811 case Instruction::Mul: // X * 1 = X
2812 return ConstantInt::get(Ty, 1);
2813 case Instruction::And: // X & -1 = X
2814 return Constant::getAllOnesValue(Ty);
2815 case Instruction::FAdd: // X + -0.0 = X
2816 // TODO: If the fadd has 'nsz', should we return +0.0?
2817 return ConstantFP::getNegativeZero(Ty);
2818 case Instruction::FMul: // X * 1.0 = X
2819 return ConstantFP::get(Ty, 1.0);
2820 default:
2821 llvm_unreachable("Every commutative binop has an identity constant");
2822 }
2823 }
2824
2825 // Non-commutative opcodes: AllowRHSConstant must be set.
2826 if (!AllowRHSConstant)
2827 return nullptr;
2828
2829 switch (Opcode) {
2830 case Instruction::Sub: // X - 0 = X
2831 case Instruction::Shl: // X << 0 = X
2832 case Instruction::LShr: // X >>u 0 = X
2833 case Instruction::AShr: // X >> 0 = X
2834 case Instruction::FSub: // X - 0.0 = X
2835 return Constant::getNullValue(Ty);
2836 case Instruction::SDiv: // X / 1 = X
2837 case Instruction::UDiv: // X /u 1 = X
2838 return ConstantInt::get(Ty, 1);
2839 case Instruction::FDiv: // X / 1.0 = X
2840 return ConstantFP::get(Ty, 1.0);
2841 default:
2842 return nullptr;
2843 }
2844 }
2845
getBinOpAbsorber(unsigned Opcode,Type * Ty)2846 Constant *ConstantExpr::getBinOpAbsorber(unsigned Opcode, Type *Ty) {
2847 switch (Opcode) {
2848 default:
2849 // Doesn't have an absorber.
2850 return nullptr;
2851
2852 case Instruction::Or:
2853 return Constant::getAllOnesValue(Ty);
2854
2855 case Instruction::And:
2856 case Instruction::Mul:
2857 return Constant::getNullValue(Ty);
2858 }
2859 }
2860
2861 /// Remove the constant from the constant table.
destroyConstantImpl()2862 void ConstantExpr::destroyConstantImpl() {
2863 getType()->getContext().pImpl->ExprConstants.remove(this);
2864 }
2865
getOpcodeName() const2866 const char *ConstantExpr::getOpcodeName() const {
2867 return Instruction::getOpcodeName(getOpcode());
2868 }
2869
GetElementPtrConstantExpr(Type * SrcElementTy,Constant * C,ArrayRef<Constant * > IdxList,Type * DestTy)2870 GetElementPtrConstantExpr::GetElementPtrConstantExpr(
2871 Type *SrcElementTy, Constant *C, ArrayRef<Constant *> IdxList, Type *DestTy)
2872 : ConstantExpr(DestTy, Instruction::GetElementPtr,
2873 OperandTraits<GetElementPtrConstantExpr>::op_end(this) -
2874 (IdxList.size() + 1),
2875 IdxList.size() + 1),
2876 SrcElementTy(SrcElementTy),
2877 ResElementTy(GetElementPtrInst::getIndexedType(SrcElementTy, IdxList)) {
2878 Op<0>() = C;
2879 Use *OperandList = getOperandList();
2880 for (unsigned i = 0, E = IdxList.size(); i != E; ++i)
2881 OperandList[i+1] = IdxList[i];
2882 }
2883
getSourceElementType() const2884 Type *GetElementPtrConstantExpr::getSourceElementType() const {
2885 return SrcElementTy;
2886 }
2887
getResultElementType() const2888 Type *GetElementPtrConstantExpr::getResultElementType() const {
2889 return ResElementTy;
2890 }
2891
2892 //===----------------------------------------------------------------------===//
2893 // ConstantData* implementations
2894
getElementType() const2895 Type *ConstantDataSequential::getElementType() const {
2896 if (ArrayType *ATy = dyn_cast<ArrayType>(getType()))
2897 return ATy->getElementType();
2898 return cast<VectorType>(getType())->getElementType();
2899 }
2900
getRawDataValues() const2901 StringRef ConstantDataSequential::getRawDataValues() const {
2902 return StringRef(DataElements, getNumElements()*getElementByteSize());
2903 }
2904
isElementTypeCompatible(Type * Ty)2905 bool ConstantDataSequential::isElementTypeCompatible(Type *Ty) {
2906 if (Ty->isHalfTy() || Ty->isBFloatTy() || Ty->isFloatTy() || Ty->isDoubleTy())
2907 return true;
2908 if (auto *IT = dyn_cast<IntegerType>(Ty)) {
2909 switch (IT->getBitWidth()) {
2910 case 8:
2911 case 16:
2912 case 32:
2913 case 64:
2914 return true;
2915 default: break;
2916 }
2917 }
2918 return false;
2919 }
2920
getNumElements() const2921 unsigned ConstantDataSequential::getNumElements() const {
2922 if (ArrayType *AT = dyn_cast<ArrayType>(getType()))
2923 return AT->getNumElements();
2924 return cast<FixedVectorType>(getType())->getNumElements();
2925 }
2926
2927
getElementByteSize() const2928 uint64_t ConstantDataSequential::getElementByteSize() const {
2929 return getElementType()->getPrimitiveSizeInBits()/8;
2930 }
2931
2932 /// Return the start of the specified element.
getElementPointer(unsigned Elt) const2933 const char *ConstantDataSequential::getElementPointer(unsigned Elt) const {
2934 assert(Elt < getNumElements() && "Invalid Elt");
2935 return DataElements+Elt*getElementByteSize();
2936 }
2937
2938
2939 /// Return true if the array is empty or all zeros.
isAllZeros(StringRef Arr)2940 static bool isAllZeros(StringRef Arr) {
2941 for (char I : Arr)
2942 if (I != 0)
2943 return false;
2944 return true;
2945 }
2946
2947 /// This is the underlying implementation of all of the
2948 /// ConstantDataSequential::get methods. They all thunk down to here, providing
2949 /// the correct element type. We take the bytes in as a StringRef because
2950 /// we *want* an underlying "char*" to avoid TBAA type punning violations.
getImpl(StringRef Elements,Type * Ty)2951 Constant *ConstantDataSequential::getImpl(StringRef Elements, Type *Ty) {
2952 #ifndef NDEBUG
2953 if (ArrayType *ATy = dyn_cast<ArrayType>(Ty))
2954 assert(isElementTypeCompatible(ATy->getElementType()));
2955 else
2956 assert(isElementTypeCompatible(cast<VectorType>(Ty)->getElementType()));
2957 #endif
2958 // If the elements are all zero or there are no elements, return a CAZ, which
2959 // is more dense and canonical.
2960 if (isAllZeros(Elements))
2961 return ConstantAggregateZero::get(Ty);
2962
2963 // Do a lookup to see if we have already formed one of these.
2964 auto &Slot =
2965 *Ty->getContext()
2966 .pImpl->CDSConstants.insert(std::make_pair(Elements, nullptr))
2967 .first;
2968
2969 // The bucket can point to a linked list of different CDS's that have the same
2970 // body but different types. For example, 0,0,0,1 could be a 4 element array
2971 // of i8, or a 1-element array of i32. They'll both end up in the same
2972 /// StringMap bucket, linked up by their Next pointers. Walk the list.
2973 std::unique_ptr<ConstantDataSequential> *Entry = &Slot.second;
2974 for (; *Entry; Entry = &(*Entry)->Next)
2975 if ((*Entry)->getType() == Ty)
2976 return Entry->get();
2977
2978 // Okay, we didn't get a hit. Create a node of the right class, link it in,
2979 // and return it.
2980 if (isa<ArrayType>(Ty)) {
2981 // Use reset because std::make_unique can't access the constructor.
2982 Entry->reset(new ConstantDataArray(Ty, Slot.first().data()));
2983 return Entry->get();
2984 }
2985
2986 assert(isa<VectorType>(Ty));
2987 // Use reset because std::make_unique can't access the constructor.
2988 Entry->reset(new ConstantDataVector(Ty, Slot.first().data()));
2989 return Entry->get();
2990 }
2991
destroyConstantImpl()2992 void ConstantDataSequential::destroyConstantImpl() {
2993 // Remove the constant from the StringMap.
2994 StringMap<std::unique_ptr<ConstantDataSequential>> &CDSConstants =
2995 getType()->getContext().pImpl->CDSConstants;
2996
2997 auto Slot = CDSConstants.find(getRawDataValues());
2998
2999 assert(Slot != CDSConstants.end() && "CDS not found in uniquing table");
3000
3001 std::unique_ptr<ConstantDataSequential> *Entry = &Slot->getValue();
3002
3003 // Remove the entry from the hash table.
3004 if (!(*Entry)->Next) {
3005 // If there is only one value in the bucket (common case) it must be this
3006 // entry, and removing the entry should remove the bucket completely.
3007 assert(Entry->get() == this && "Hash mismatch in ConstantDataSequential");
3008 getContext().pImpl->CDSConstants.erase(Slot);
3009 return;
3010 }
3011
3012 // Otherwise, there are multiple entries linked off the bucket, unlink the
3013 // node we care about but keep the bucket around.
3014 while (true) {
3015 std::unique_ptr<ConstantDataSequential> &Node = *Entry;
3016 assert(Node && "Didn't find entry in its uniquing hash table!");
3017 // If we found our entry, unlink it from the list and we're done.
3018 if (Node.get() == this) {
3019 Node = std::move(Node->Next);
3020 return;
3021 }
3022
3023 Entry = &Node->Next;
3024 }
3025 }
3026
3027 /// getFP() constructors - Return a constant of array type with a float
3028 /// element type taken from argument `ElementType', and count taken from
3029 /// argument `Elts'. The amount of bits of the contained type must match the
3030 /// number of bits of the type contained in the passed in ArrayRef.
3031 /// (i.e. half or bfloat for 16bits, float for 32bits, double for 64bits) Note
3032 /// that this can return a ConstantAggregateZero object.
getFP(Type * ElementType,ArrayRef<uint16_t> Elts)3033 Constant *ConstantDataArray::getFP(Type *ElementType, ArrayRef<uint16_t> Elts) {
3034 assert((ElementType->isHalfTy() || ElementType->isBFloatTy()) &&
3035 "Element type is not a 16-bit float type");
3036 Type *Ty = ArrayType::get(ElementType, Elts.size());
3037 const char *Data = reinterpret_cast<const char *>(Elts.data());
3038 return getImpl(StringRef(Data, Elts.size() * 2), Ty);
3039 }
getFP(Type * ElementType,ArrayRef<uint32_t> Elts)3040 Constant *ConstantDataArray::getFP(Type *ElementType, ArrayRef<uint32_t> Elts) {
3041 assert(ElementType->isFloatTy() && "Element type is not a 32-bit float type");
3042 Type *Ty = ArrayType::get(ElementType, Elts.size());
3043 const char *Data = reinterpret_cast<const char *>(Elts.data());
3044 return getImpl(StringRef(Data, Elts.size() * 4), Ty);
3045 }
getFP(Type * ElementType,ArrayRef<uint64_t> Elts)3046 Constant *ConstantDataArray::getFP(Type *ElementType, ArrayRef<uint64_t> Elts) {
3047 assert(ElementType->isDoubleTy() &&
3048 "Element type is not a 64-bit float type");
3049 Type *Ty = ArrayType::get(ElementType, Elts.size());
3050 const char *Data = reinterpret_cast<const char *>(Elts.data());
3051 return getImpl(StringRef(Data, Elts.size() * 8), Ty);
3052 }
3053
getString(LLVMContext & Context,StringRef Str,bool AddNull)3054 Constant *ConstantDataArray::getString(LLVMContext &Context,
3055 StringRef Str, bool AddNull) {
3056 if (!AddNull) {
3057 const uint8_t *Data = Str.bytes_begin();
3058 return get(Context, makeArrayRef(Data, Str.size()));
3059 }
3060
3061 SmallVector<uint8_t, 64> ElementVals;
3062 ElementVals.append(Str.begin(), Str.end());
3063 ElementVals.push_back(0);
3064 return get(Context, ElementVals);
3065 }
3066
3067 /// get() constructors - Return a constant with vector type with an element
3068 /// count and element type matching the ArrayRef passed in. Note that this
3069 /// can return a ConstantAggregateZero object.
get(LLVMContext & Context,ArrayRef<uint8_t> Elts)3070 Constant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<uint8_t> Elts){
3071 auto *Ty = FixedVectorType::get(Type::getInt8Ty(Context), Elts.size());
3072 const char *Data = reinterpret_cast<const char *>(Elts.data());
3073 return getImpl(StringRef(Data, Elts.size() * 1), Ty);
3074 }
get(LLVMContext & Context,ArrayRef<uint16_t> Elts)3075 Constant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<uint16_t> Elts){
3076 auto *Ty = FixedVectorType::get(Type::getInt16Ty(Context), Elts.size());
3077 const char *Data = reinterpret_cast<const char *>(Elts.data());
3078 return getImpl(StringRef(Data, Elts.size() * 2), Ty);
3079 }
get(LLVMContext & Context,ArrayRef<uint32_t> Elts)3080 Constant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<uint32_t> Elts){
3081 auto *Ty = FixedVectorType::get(Type::getInt32Ty(Context), Elts.size());
3082 const char *Data = reinterpret_cast<const char *>(Elts.data());
3083 return getImpl(StringRef(Data, Elts.size() * 4), Ty);
3084 }
get(LLVMContext & Context,ArrayRef<uint64_t> Elts)3085 Constant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<uint64_t> Elts){
3086 auto *Ty = FixedVectorType::get(Type::getInt64Ty(Context), Elts.size());
3087 const char *Data = reinterpret_cast<const char *>(Elts.data());
3088 return getImpl(StringRef(Data, Elts.size() * 8), Ty);
3089 }
get(LLVMContext & Context,ArrayRef<float> Elts)3090 Constant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<float> Elts) {
3091 auto *Ty = FixedVectorType::get(Type::getFloatTy(Context), Elts.size());
3092 const char *Data = reinterpret_cast<const char *>(Elts.data());
3093 return getImpl(StringRef(Data, Elts.size() * 4), Ty);
3094 }
get(LLVMContext & Context,ArrayRef<double> Elts)3095 Constant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<double> Elts) {
3096 auto *Ty = FixedVectorType::get(Type::getDoubleTy(Context), Elts.size());
3097 const char *Data = reinterpret_cast<const char *>(Elts.data());
3098 return getImpl(StringRef(Data, Elts.size() * 8), Ty);
3099 }
3100
3101 /// getFP() constructors - Return a constant of vector type with a float
3102 /// element type taken from argument `ElementType', and count taken from
3103 /// argument `Elts'. The amount of bits of the contained type must match the
3104 /// number of bits of the type contained in the passed in ArrayRef.
3105 /// (i.e. half or bfloat for 16bits, float for 32bits, double for 64bits) Note
3106 /// that this can return a ConstantAggregateZero object.
getFP(Type * ElementType,ArrayRef<uint16_t> Elts)3107 Constant *ConstantDataVector::getFP(Type *ElementType,
3108 ArrayRef<uint16_t> Elts) {
3109 assert((ElementType->isHalfTy() || ElementType->isBFloatTy()) &&
3110 "Element type is not a 16-bit float type");
3111 auto *Ty = FixedVectorType::get(ElementType, Elts.size());
3112 const char *Data = reinterpret_cast<const char *>(Elts.data());
3113 return getImpl(StringRef(Data, Elts.size() * 2), Ty);
3114 }
getFP(Type * ElementType,ArrayRef<uint32_t> Elts)3115 Constant *ConstantDataVector::getFP(Type *ElementType,
3116 ArrayRef<uint32_t> Elts) {
3117 assert(ElementType->isFloatTy() && "Element type is not a 32-bit float type");
3118 auto *Ty = FixedVectorType::get(ElementType, Elts.size());
3119 const char *Data = reinterpret_cast<const char *>(Elts.data());
3120 return getImpl(StringRef(Data, Elts.size() * 4), Ty);
3121 }
getFP(Type * ElementType,ArrayRef<uint64_t> Elts)3122 Constant *ConstantDataVector::getFP(Type *ElementType,
3123 ArrayRef<uint64_t> Elts) {
3124 assert(ElementType->isDoubleTy() &&
3125 "Element type is not a 64-bit float type");
3126 auto *Ty = FixedVectorType::get(ElementType, Elts.size());
3127 const char *Data = reinterpret_cast<const char *>(Elts.data());
3128 return getImpl(StringRef(Data, Elts.size() * 8), Ty);
3129 }
3130
getSplat(unsigned NumElts,Constant * V)3131 Constant *ConstantDataVector::getSplat(unsigned NumElts, Constant *V) {
3132 assert(isElementTypeCompatible(V->getType()) &&
3133 "Element type not compatible with ConstantData");
3134 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
3135 if (CI->getType()->isIntegerTy(8)) {
3136 SmallVector<uint8_t, 16> Elts(NumElts, CI->getZExtValue());
3137 return get(V->getContext(), Elts);
3138 }
3139 if (CI->getType()->isIntegerTy(16)) {
3140 SmallVector<uint16_t, 16> Elts(NumElts, CI->getZExtValue());
3141 return get(V->getContext(), Elts);
3142 }
3143 if (CI->getType()->isIntegerTy(32)) {
3144 SmallVector<uint32_t, 16> Elts(NumElts, CI->getZExtValue());
3145 return get(V->getContext(), Elts);
3146 }
3147 assert(CI->getType()->isIntegerTy(64) && "Unsupported ConstantData type");
3148 SmallVector<uint64_t, 16> Elts(NumElts, CI->getZExtValue());
3149 return get(V->getContext(), Elts);
3150 }
3151
3152 if (ConstantFP *CFP = dyn_cast<ConstantFP>(V)) {
3153 if (CFP->getType()->isHalfTy()) {
3154 SmallVector<uint16_t, 16> Elts(
3155 NumElts, CFP->getValueAPF().bitcastToAPInt().getLimitedValue());
3156 return getFP(V->getType(), Elts);
3157 }
3158 if (CFP->getType()->isBFloatTy()) {
3159 SmallVector<uint16_t, 16> Elts(
3160 NumElts, CFP->getValueAPF().bitcastToAPInt().getLimitedValue());
3161 return getFP(V->getType(), Elts);
3162 }
3163 if (CFP->getType()->isFloatTy()) {
3164 SmallVector<uint32_t, 16> Elts(
3165 NumElts, CFP->getValueAPF().bitcastToAPInt().getLimitedValue());
3166 return getFP(V->getType(), Elts);
3167 }
3168 if (CFP->getType()->isDoubleTy()) {
3169 SmallVector<uint64_t, 16> Elts(
3170 NumElts, CFP->getValueAPF().bitcastToAPInt().getLimitedValue());
3171 return getFP(V->getType(), Elts);
3172 }
3173 }
3174 return ConstantVector::getSplat(ElementCount::getFixed(NumElts), V);
3175 }
3176
3177
getElementAsInteger(unsigned Elt) const3178 uint64_t ConstantDataSequential::getElementAsInteger(unsigned Elt) const {
3179 assert(isa<IntegerType>(getElementType()) &&
3180 "Accessor can only be used when element is an integer");
3181 const char *EltPtr = getElementPointer(Elt);
3182
3183 // The data is stored in host byte order, make sure to cast back to the right
3184 // type to load with the right endianness.
3185 switch (getElementType()->getIntegerBitWidth()) {
3186 default: llvm_unreachable("Invalid bitwidth for CDS");
3187 case 8:
3188 return *reinterpret_cast<const uint8_t *>(EltPtr);
3189 case 16:
3190 return *reinterpret_cast<const uint16_t *>(EltPtr);
3191 case 32:
3192 return *reinterpret_cast<const uint32_t *>(EltPtr);
3193 case 64:
3194 return *reinterpret_cast<const uint64_t *>(EltPtr);
3195 }
3196 }
3197
getElementAsAPInt(unsigned Elt) const3198 APInt ConstantDataSequential::getElementAsAPInt(unsigned Elt) const {
3199 assert(isa<IntegerType>(getElementType()) &&
3200 "Accessor can only be used when element is an integer");
3201 const char *EltPtr = getElementPointer(Elt);
3202
3203 // The data is stored in host byte order, make sure to cast back to the right
3204 // type to load with the right endianness.
3205 switch (getElementType()->getIntegerBitWidth()) {
3206 default: llvm_unreachable("Invalid bitwidth for CDS");
3207 case 8: {
3208 auto EltVal = *reinterpret_cast<const uint8_t *>(EltPtr);
3209 return APInt(8, EltVal);
3210 }
3211 case 16: {
3212 auto EltVal = *reinterpret_cast<const uint16_t *>(EltPtr);
3213 return APInt(16, EltVal);
3214 }
3215 case 32: {
3216 auto EltVal = *reinterpret_cast<const uint32_t *>(EltPtr);
3217 return APInt(32, EltVal);
3218 }
3219 case 64: {
3220 auto EltVal = *reinterpret_cast<const uint64_t *>(EltPtr);
3221 return APInt(64, EltVal);
3222 }
3223 }
3224 }
3225
getElementAsAPFloat(unsigned Elt) const3226 APFloat ConstantDataSequential::getElementAsAPFloat(unsigned Elt) const {
3227 const char *EltPtr = getElementPointer(Elt);
3228
3229 switch (getElementType()->getTypeID()) {
3230 default:
3231 llvm_unreachable("Accessor can only be used when element is float/double!");
3232 case Type::HalfTyID: {
3233 auto EltVal = *reinterpret_cast<const uint16_t *>(EltPtr);
3234 return APFloat(APFloat::IEEEhalf(), APInt(16, EltVal));
3235 }
3236 case Type::BFloatTyID: {
3237 auto EltVal = *reinterpret_cast<const uint16_t *>(EltPtr);
3238 return APFloat(APFloat::BFloat(), APInt(16, EltVal));
3239 }
3240 case Type::FloatTyID: {
3241 auto EltVal = *reinterpret_cast<const uint32_t *>(EltPtr);
3242 return APFloat(APFloat::IEEEsingle(), APInt(32, EltVal));
3243 }
3244 case Type::DoubleTyID: {
3245 auto EltVal = *reinterpret_cast<const uint64_t *>(EltPtr);
3246 return APFloat(APFloat::IEEEdouble(), APInt(64, EltVal));
3247 }
3248 }
3249 }
3250
getElementAsFloat(unsigned Elt) const3251 float ConstantDataSequential::getElementAsFloat(unsigned Elt) const {
3252 assert(getElementType()->isFloatTy() &&
3253 "Accessor can only be used when element is a 'float'");
3254 return *reinterpret_cast<const float *>(getElementPointer(Elt));
3255 }
3256
getElementAsDouble(unsigned Elt) const3257 double ConstantDataSequential::getElementAsDouble(unsigned Elt) const {
3258 assert(getElementType()->isDoubleTy() &&
3259 "Accessor can only be used when element is a 'float'");
3260 return *reinterpret_cast<const double *>(getElementPointer(Elt));
3261 }
3262
getElementAsConstant(unsigned Elt) const3263 Constant *ConstantDataSequential::getElementAsConstant(unsigned Elt) const {
3264 if (getElementType()->isHalfTy() || getElementType()->isBFloatTy() ||
3265 getElementType()->isFloatTy() || getElementType()->isDoubleTy())
3266 return ConstantFP::get(getContext(), getElementAsAPFloat(Elt));
3267
3268 return ConstantInt::get(getElementType(), getElementAsInteger(Elt));
3269 }
3270
isString(unsigned CharSize) const3271 bool ConstantDataSequential::isString(unsigned CharSize) const {
3272 return isa<ArrayType>(getType()) && getElementType()->isIntegerTy(CharSize);
3273 }
3274
isCString() const3275 bool ConstantDataSequential::isCString() const {
3276 if (!isString())
3277 return false;
3278
3279 StringRef Str = getAsString();
3280
3281 // The last value must be nul.
3282 if (Str.back() != 0) return false;
3283
3284 // Other elements must be non-nul.
3285 return Str.drop_back().find(0) == StringRef::npos;
3286 }
3287
isSplatData() const3288 bool ConstantDataVector::isSplatData() const {
3289 const char *Base = getRawDataValues().data();
3290
3291 // Compare elements 1+ to the 0'th element.
3292 unsigned EltSize = getElementByteSize();
3293 for (unsigned i = 1, e = getNumElements(); i != e; ++i)
3294 if (memcmp(Base, Base+i*EltSize, EltSize))
3295 return false;
3296
3297 return true;
3298 }
3299
isSplat() const3300 bool ConstantDataVector::isSplat() const {
3301 if (!IsSplatSet) {
3302 IsSplatSet = true;
3303 IsSplat = isSplatData();
3304 }
3305 return IsSplat;
3306 }
3307
getSplatValue() const3308 Constant *ConstantDataVector::getSplatValue() const {
3309 // If they're all the same, return the 0th one as a representative.
3310 return isSplat() ? getElementAsConstant(0) : nullptr;
3311 }
3312
3313 //===----------------------------------------------------------------------===//
3314 // handleOperandChange implementations
3315
3316 /// Update this constant array to change uses of
3317 /// 'From' to be uses of 'To'. This must update the uniquing data structures
3318 /// etc.
3319 ///
3320 /// Note that we intentionally replace all uses of From with To here. Consider
3321 /// a large array that uses 'From' 1000 times. By handling this case all here,
3322 /// ConstantArray::handleOperandChange is only invoked once, and that
3323 /// single invocation handles all 1000 uses. Handling them one at a time would
3324 /// work, but would be really slow because it would have to unique each updated
3325 /// array instance.
3326 ///
handleOperandChange(Value * From,Value * To)3327 void Constant::handleOperandChange(Value *From, Value *To) {
3328 Value *Replacement = nullptr;
3329 switch (getValueID()) {
3330 default:
3331 llvm_unreachable("Not a constant!");
3332 #define HANDLE_CONSTANT(Name) \
3333 case Value::Name##Val: \
3334 Replacement = cast<Name>(this)->handleOperandChangeImpl(From, To); \
3335 break;
3336 #include "llvm/IR/Value.def"
3337 }
3338
3339 // If handleOperandChangeImpl returned nullptr, then it handled
3340 // replacing itself and we don't want to delete or replace anything else here.
3341 if (!Replacement)
3342 return;
3343
3344 // I do need to replace this with an existing value.
3345 assert(Replacement != this && "I didn't contain From!");
3346
3347 // Everyone using this now uses the replacement.
3348 replaceAllUsesWith(Replacement);
3349
3350 // Delete the old constant!
3351 destroyConstant();
3352 }
3353
handleOperandChangeImpl(Value * From,Value * To)3354 Value *ConstantArray::handleOperandChangeImpl(Value *From, Value *To) {
3355 assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
3356 Constant *ToC = cast<Constant>(To);
3357
3358 SmallVector<Constant*, 8> Values;
3359 Values.reserve(getNumOperands()); // Build replacement array.
3360
3361 // Fill values with the modified operands of the constant array. Also,
3362 // compute whether this turns into an all-zeros array.
3363 unsigned NumUpdated = 0;
3364
3365 // Keep track of whether all the values in the array are "ToC".
3366 bool AllSame = true;
3367 Use *OperandList = getOperandList();
3368 unsigned OperandNo = 0;
3369 for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) {
3370 Constant *Val = cast<Constant>(O->get());
3371 if (Val == From) {
3372 OperandNo = (O - OperandList);
3373 Val = ToC;
3374 ++NumUpdated;
3375 }
3376 Values.push_back(Val);
3377 AllSame &= Val == ToC;
3378 }
3379
3380 if (AllSame && ToC->isNullValue())
3381 return ConstantAggregateZero::get(getType());
3382
3383 if (AllSame && isa<UndefValue>(ToC))
3384 return UndefValue::get(getType());
3385
3386 // Check for any other type of constant-folding.
3387 if (Constant *C = getImpl(getType(), Values))
3388 return C;
3389
3390 // Update to the new value.
3391 return getContext().pImpl->ArrayConstants.replaceOperandsInPlace(
3392 Values, this, From, ToC, NumUpdated, OperandNo);
3393 }
3394
handleOperandChangeImpl(Value * From,Value * To)3395 Value *ConstantStruct::handleOperandChangeImpl(Value *From, Value *To) {
3396 assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
3397 Constant *ToC = cast<Constant>(To);
3398
3399 Use *OperandList = getOperandList();
3400
3401 SmallVector<Constant*, 8> Values;
3402 Values.reserve(getNumOperands()); // Build replacement struct.
3403
3404 // Fill values with the modified operands of the constant struct. Also,
3405 // compute whether this turns into an all-zeros struct.
3406 unsigned NumUpdated = 0;
3407 bool AllSame = true;
3408 unsigned OperandNo = 0;
3409 for (Use *O = OperandList, *E = OperandList + getNumOperands(); O != E; ++O) {
3410 Constant *Val = cast<Constant>(O->get());
3411 if (Val == From) {
3412 OperandNo = (O - OperandList);
3413 Val = ToC;
3414 ++NumUpdated;
3415 }
3416 Values.push_back(Val);
3417 AllSame &= Val == ToC;
3418 }
3419
3420 if (AllSame && ToC->isNullValue())
3421 return ConstantAggregateZero::get(getType());
3422
3423 if (AllSame && isa<UndefValue>(ToC))
3424 return UndefValue::get(getType());
3425
3426 // Update to the new value.
3427 return getContext().pImpl->StructConstants.replaceOperandsInPlace(
3428 Values, this, From, ToC, NumUpdated, OperandNo);
3429 }
3430
handleOperandChangeImpl(Value * From,Value * To)3431 Value *ConstantVector::handleOperandChangeImpl(Value *From, Value *To) {
3432 assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
3433 Constant *ToC = cast<Constant>(To);
3434
3435 SmallVector<Constant*, 8> Values;
3436 Values.reserve(getNumOperands()); // Build replacement array...
3437 unsigned NumUpdated = 0;
3438 unsigned OperandNo = 0;
3439 for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
3440 Constant *Val = getOperand(i);
3441 if (Val == From) {
3442 OperandNo = i;
3443 ++NumUpdated;
3444 Val = ToC;
3445 }
3446 Values.push_back(Val);
3447 }
3448
3449 if (Constant *C = getImpl(Values))
3450 return C;
3451
3452 // Update to the new value.
3453 return getContext().pImpl->VectorConstants.replaceOperandsInPlace(
3454 Values, this, From, ToC, NumUpdated, OperandNo);
3455 }
3456
handleOperandChangeImpl(Value * From,Value * ToV)3457 Value *ConstantExpr::handleOperandChangeImpl(Value *From, Value *ToV) {
3458 assert(isa<Constant>(ToV) && "Cannot make Constant refer to non-constant!");
3459 Constant *To = cast<Constant>(ToV);
3460
3461 SmallVector<Constant*, 8> NewOps;
3462 unsigned NumUpdated = 0;
3463 unsigned OperandNo = 0;
3464 for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
3465 Constant *Op = getOperand(i);
3466 if (Op == From) {
3467 OperandNo = i;
3468 ++NumUpdated;
3469 Op = To;
3470 }
3471 NewOps.push_back(Op);
3472 }
3473 assert(NumUpdated && "I didn't contain From!");
3474
3475 if (Constant *C = getWithOperands(NewOps, getType(), true))
3476 return C;
3477
3478 // Update to the new value.
3479 return getContext().pImpl->ExprConstants.replaceOperandsInPlace(
3480 NewOps, this, From, To, NumUpdated, OperandNo);
3481 }
3482
getAsInstruction() const3483 Instruction *ConstantExpr::getAsInstruction() const {
3484 SmallVector<Value *, 4> ValueOperands(operands());
3485 ArrayRef<Value*> Ops(ValueOperands);
3486
3487 switch (getOpcode()) {
3488 case Instruction::Trunc:
3489 case Instruction::ZExt:
3490 case Instruction::SExt:
3491 case Instruction::FPTrunc:
3492 case Instruction::FPExt:
3493 case Instruction::UIToFP:
3494 case Instruction::SIToFP:
3495 case Instruction::FPToUI:
3496 case Instruction::FPToSI:
3497 case Instruction::PtrToInt:
3498 case Instruction::IntToPtr:
3499 case Instruction::BitCast:
3500 case Instruction::AddrSpaceCast:
3501 return CastInst::Create((Instruction::CastOps)getOpcode(),
3502 Ops[0], getType());
3503 case Instruction::Select:
3504 return SelectInst::Create(Ops[0], Ops[1], Ops[2]);
3505 case Instruction::InsertElement:
3506 return InsertElementInst::Create(Ops[0], Ops[1], Ops[2]);
3507 case Instruction::ExtractElement:
3508 return ExtractElementInst::Create(Ops[0], Ops[1]);
3509 case Instruction::InsertValue:
3510 return InsertValueInst::Create(Ops[0], Ops[1], getIndices());
3511 case Instruction::ExtractValue:
3512 return ExtractValueInst::Create(Ops[0], getIndices());
3513 case Instruction::ShuffleVector:
3514 return new ShuffleVectorInst(Ops[0], Ops[1], getShuffleMask());
3515
3516 case Instruction::GetElementPtr: {
3517 const auto *GO = cast<GEPOperator>(this);
3518 if (GO->isInBounds())
3519 return GetElementPtrInst::CreateInBounds(GO->getSourceElementType(),
3520 Ops[0], Ops.slice(1));
3521 return GetElementPtrInst::Create(GO->getSourceElementType(), Ops[0],
3522 Ops.slice(1));
3523 }
3524 case Instruction::ICmp:
3525 case Instruction::FCmp:
3526 return CmpInst::Create((Instruction::OtherOps)getOpcode(),
3527 (CmpInst::Predicate)getPredicate(), Ops[0], Ops[1]);
3528 case Instruction::FNeg:
3529 return UnaryOperator::Create((Instruction::UnaryOps)getOpcode(), Ops[0]);
3530 default:
3531 assert(getNumOperands() == 2 && "Must be binary operator?");
3532 BinaryOperator *BO =
3533 BinaryOperator::Create((Instruction::BinaryOps)getOpcode(),
3534 Ops[0], Ops[1]);
3535 if (isa<OverflowingBinaryOperator>(BO)) {
3536 BO->setHasNoUnsignedWrap(SubclassOptionalData &
3537 OverflowingBinaryOperator::NoUnsignedWrap);
3538 BO->setHasNoSignedWrap(SubclassOptionalData &
3539 OverflowingBinaryOperator::NoSignedWrap);
3540 }
3541 if (isa<PossiblyExactOperator>(BO))
3542 BO->setIsExact(SubclassOptionalData & PossiblyExactOperator::IsExact);
3543 return BO;
3544 }
3545 }
3546