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