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