1 //===-- llvm/Constants.h - Constant class subclass definitions --*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 /// @file 10 /// This file contains the declarations for the subclasses of Constant, 11 /// which represent the different flavors of constant values that live in LLVM. 12 /// Note that Constants are immutable (once created they never change) and are 13 /// fully shared by structural equivalence. This means that two structurally 14 /// equivalent constants will always have the same address. Constants are 15 /// created on demand as needed and never deleted: thus clients don't have to 16 /// worry about the lifetime of the objects. 17 // 18 //===----------------------------------------------------------------------===// 19 20 #ifndef LLVM_IR_CONSTANTS_H 21 #define LLVM_IR_CONSTANTS_H 22 23 #include "llvm/ADT/APFloat.h" 24 #include "llvm/ADT/APInt.h" 25 #include "llvm/ADT/ArrayRef.h" 26 #include "llvm/ADT/None.h" 27 #include "llvm/ADT/Optional.h" 28 #include "llvm/ADT/STLExtras.h" 29 #include "llvm/ADT/StringRef.h" 30 #include "llvm/IR/Constant.h" 31 #include "llvm/IR/DerivedTypes.h" 32 #include "llvm/IR/OperandTraits.h" 33 #include "llvm/IR/User.h" 34 #include "llvm/IR/Value.h" 35 #include "llvm/Support/Casting.h" 36 #include "llvm/Support/Compiler.h" 37 #include "llvm/Support/ErrorHandling.h" 38 #include <cassert> 39 #include <cstddef> 40 #include <cstdint> 41 42 namespace llvm { 43 44 class ArrayType; 45 class IntegerType; 46 class PointerType; 47 class SequentialType; 48 class StructType; 49 class VectorType; 50 template <class ConstantClass> struct ConstantAggrKeyType; 51 52 /// Base class for constants with no operands. 53 /// 54 /// These constants have no operands; they represent their data directly. 55 /// Since they can be in use by unrelated modules (and are never based on 56 /// GlobalValues), it never makes sense to RAUW them. 57 class ConstantData : public Constant { 58 friend class Constant; 59 60 Value *handleOperandChangeImpl(Value *From, Value *To) { 61 llvm_unreachable("Constant data does not have operands!"); 62 } 63 64 protected: 65 explicit ConstantData(Type *Ty, ValueTy VT) : Constant(Ty, VT, nullptr, 0) {} 66 67 void *operator new(size_t s) { return User::operator new(s, 0); } 68 69 public: 70 ConstantData(const ConstantData &) = delete; 71 72 /// Methods to support type inquiry through isa, cast, and dyn_cast. 73 static bool classof(const Value *V) { 74 return V->getValueID() >= ConstantDataFirstVal && 75 V->getValueID() <= ConstantDataLastVal; 76 } 77 }; 78 79 //===----------------------------------------------------------------------===// 80 /// This is the shared class of boolean and integer constants. This class 81 /// represents both boolean and integral constants. 82 /// Class for constant integers. 83 class ConstantInt final : public ConstantData { 84 friend class Constant; 85 86 APInt Val; 87 88 ConstantInt(IntegerType *Ty, const APInt& V); 89 90 void destroyConstantImpl(); 91 92 public: 93 ConstantInt(const ConstantInt &) = delete; 94 95 static ConstantInt *getTrue(LLVMContext &Context); 96 static ConstantInt *getFalse(LLVMContext &Context); 97 static Constant *getTrue(Type *Ty); 98 static Constant *getFalse(Type *Ty); 99 100 /// If Ty is a vector type, return a Constant with a splat of the given 101 /// value. Otherwise return a ConstantInt for the given value. 102 static Constant *get(Type *Ty, uint64_t V, bool isSigned = false); 103 104 /// Return a ConstantInt with the specified integer value for the specified 105 /// type. If the type is wider than 64 bits, the value will be zero-extended 106 /// to fit the type, unless isSigned is true, in which case the value will 107 /// be interpreted as a 64-bit signed integer and sign-extended to fit 108 /// the type. 109 /// Get a ConstantInt for a specific value. 110 static ConstantInt *get(IntegerType *Ty, uint64_t V, 111 bool isSigned = false); 112 113 /// Return a ConstantInt with the specified value for the specified type. The 114 /// value V will be canonicalized to a an unsigned APInt. Accessing it with 115 /// either getSExtValue() or getZExtValue() will yield a correctly sized and 116 /// signed value for the type Ty. 117 /// Get a ConstantInt for a specific signed value. 118 static ConstantInt *getSigned(IntegerType *Ty, int64_t V); 119 static Constant *getSigned(Type *Ty, int64_t V); 120 121 /// Return a ConstantInt with the specified value and an implied Type. The 122 /// type is the integer type that corresponds to the bit width of the value. 123 static ConstantInt *get(LLVMContext &Context, const APInt &V); 124 125 /// Return a ConstantInt constructed from the string strStart with the given 126 /// radix. 127 static ConstantInt *get(IntegerType *Ty, StringRef Str, 128 uint8_t radix); 129 130 /// If Ty is a vector type, return a Constant with a splat of the given 131 /// value. Otherwise return a ConstantInt for the given value. 132 static Constant *get(Type* Ty, const APInt& V); 133 134 /// Return the constant as an APInt value reference. This allows clients to 135 /// obtain a full-precision copy of the value. 136 /// Return the constant's value. 137 inline const APInt &getValue() const { 138 return Val; 139 } 140 141 /// getBitWidth - Return the bitwidth of this constant. 142 unsigned getBitWidth() const { return Val.getBitWidth(); } 143 144 /// Return the constant as a 64-bit unsigned integer value after it 145 /// has been zero extended as appropriate for the type of this constant. Note 146 /// that this method can assert if the value does not fit in 64 bits. 147 /// Return the zero extended value. 148 inline uint64_t getZExtValue() const { 149 return Val.getZExtValue(); 150 } 151 152 /// Return the constant as a 64-bit integer value after it has been sign 153 /// extended as appropriate for the type of this constant. Note that 154 /// this method can assert if the value does not fit in 64 bits. 155 /// Return the sign extended value. 156 inline int64_t getSExtValue() const { 157 return Val.getSExtValue(); 158 } 159 160 /// A helper method that can be used to determine if the constant contained 161 /// within is equal to a constant. This only works for very small values, 162 /// because this is all that can be represented with all types. 163 /// Determine if this constant's value is same as an unsigned char. 164 bool equalsInt(uint64_t V) const { 165 return Val == V; 166 } 167 168 /// getType - Specialize the getType() method to always return an IntegerType, 169 /// which reduces the amount of casting needed in parts of the compiler. 170 /// 171 inline IntegerType *getType() const { 172 return cast<IntegerType>(Value::getType()); 173 } 174 175 /// This static method returns true if the type Ty is big enough to 176 /// represent the value V. This can be used to avoid having the get method 177 /// assert when V is larger than Ty can represent. Note that there are two 178 /// versions of this method, one for unsigned and one for signed integers. 179 /// Although ConstantInt canonicalizes everything to an unsigned integer, 180 /// the signed version avoids callers having to convert a signed quantity 181 /// to the appropriate unsigned type before calling the method. 182 /// @returns true if V is a valid value for type Ty 183 /// Determine if the value is in range for the given type. 184 static bool isValueValidForType(Type *Ty, uint64_t V); 185 static bool isValueValidForType(Type *Ty, int64_t V); 186 187 bool isNegative() const { return Val.isNegative(); } 188 189 /// This is just a convenience method to make client code smaller for a 190 /// common code. It also correctly performs the comparison without the 191 /// potential for an assertion from getZExtValue(). 192 bool isZero() const { 193 return Val.isNullValue(); 194 } 195 196 /// This is just a convenience method to make client code smaller for a 197 /// common case. It also correctly performs the comparison without the 198 /// potential for an assertion from getZExtValue(). 199 /// Determine if the value is one. 200 bool isOne() const { 201 return Val.isOneValue(); 202 } 203 204 /// This function will return true iff every bit in this constant is set 205 /// to true. 206 /// @returns true iff this constant's bits are all set to true. 207 /// Determine if the value is all ones. 208 bool isMinusOne() const { 209 return Val.isAllOnesValue(); 210 } 211 212 /// This function will return true iff this constant represents the largest 213 /// value that may be represented by the constant's type. 214 /// @returns true iff this is the largest value that may be represented 215 /// by this type. 216 /// Determine if the value is maximal. 217 bool isMaxValue(bool isSigned) const { 218 if (isSigned) 219 return Val.isMaxSignedValue(); 220 else 221 return Val.isMaxValue(); 222 } 223 224 /// This function will return true iff this constant represents the smallest 225 /// value that may be represented by this constant's type. 226 /// @returns true if this is the smallest value that may be represented by 227 /// this type. 228 /// Determine if the value is minimal. 229 bool isMinValue(bool isSigned) const { 230 if (isSigned) 231 return Val.isMinSignedValue(); 232 else 233 return Val.isMinValue(); 234 } 235 236 /// This function will return true iff this constant represents a value with 237 /// active bits bigger than 64 bits or a value greater than the given uint64_t 238 /// value. 239 /// @returns true iff this constant is greater or equal to the given number. 240 /// Determine if the value is greater or equal to the given number. 241 bool uge(uint64_t Num) const { 242 return Val.uge(Num); 243 } 244 245 /// getLimitedValue - If the value is smaller than the specified limit, 246 /// return it, otherwise return the limit value. This causes the value 247 /// to saturate to the limit. 248 /// @returns the min of the value of the constant and the specified value 249 /// Get the constant's value with a saturation limit 250 uint64_t getLimitedValue(uint64_t Limit = ~0ULL) const { 251 return Val.getLimitedValue(Limit); 252 } 253 254 /// Methods to support type inquiry through isa, cast, and dyn_cast. 255 static bool classof(const Value *V) { 256 return V->getValueID() == ConstantIntVal; 257 } 258 }; 259 260 //===----------------------------------------------------------------------===// 261 /// ConstantFP - Floating Point Values [float, double] 262 /// 263 class ConstantFP final : public ConstantData { 264 friend class Constant; 265 266 APFloat Val; 267 268 ConstantFP(Type *Ty, const APFloat& V); 269 270 void destroyConstantImpl(); 271 272 public: 273 ConstantFP(const ConstantFP &) = delete; 274 275 /// Floating point negation must be implemented with f(x) = -0.0 - x. This 276 /// method returns the negative zero constant for floating point or vector 277 /// floating point types; for all other types, it returns the null value. 278 static Constant *getZeroValueForNegation(Type *Ty); 279 280 /// This returns a ConstantFP, or a vector containing a splat of a ConstantFP, 281 /// for the specified value in the specified type. This should only be used 282 /// for simple constant values like 2.0/1.0 etc, that are known-valid both as 283 /// host double and as the target format. 284 static Constant *get(Type* Ty, double V); 285 286 /// If Ty is a vector type, return a Constant with a splat of the given 287 /// value. Otherwise return a ConstantFP for the given value. 288 static Constant *get(Type *Ty, const APFloat &V); 289 290 static Constant *get(Type* Ty, StringRef Str); 291 static ConstantFP *get(LLVMContext &Context, const APFloat &V); 292 static Constant *getNaN(Type *Ty, bool Negative = false, uint64_t Payload = 0); 293 static Constant *getQNaN(Type *Ty, bool Negative = false, 294 APInt *Payload = nullptr); 295 static Constant *getSNaN(Type *Ty, bool Negative = false, 296 APInt *Payload = nullptr); 297 static Constant *getNegativeZero(Type *Ty); 298 static Constant *getInfinity(Type *Ty, bool Negative = false); 299 300 /// Return true if Ty is big enough to represent V. 301 static bool isValueValidForType(Type *Ty, const APFloat &V); 302 inline const APFloat &getValueAPF() const { return Val; } 303 304 /// Return true if the value is positive or negative zero. 305 bool isZero() const { return Val.isZero(); } 306 307 /// Return true if the sign bit is set. 308 bool isNegative() const { return Val.isNegative(); } 309 310 /// Return true if the value is infinity 311 bool isInfinity() const { return Val.isInfinity(); } 312 313 /// Return true if the value is a NaN. 314 bool isNaN() const { return Val.isNaN(); } 315 316 /// We don't rely on operator== working on double values, as it returns true 317 /// for things that are clearly not equal, like -0.0 and 0.0. 318 /// As such, this method can be used to do an exact bit-for-bit comparison of 319 /// two floating point values. The version with a double operand is retained 320 /// because it's so convenient to write isExactlyValue(2.0), but please use 321 /// it only for simple constants. 322 bool isExactlyValue(const APFloat &V) const; 323 324 bool isExactlyValue(double V) const { 325 bool ignored; 326 APFloat FV(V); 327 FV.convert(Val.getSemantics(), APFloat::rmNearestTiesToEven, &ignored); 328 return isExactlyValue(FV); 329 } 330 331 /// Methods for support type inquiry through isa, cast, and dyn_cast: 332 static bool classof(const Value *V) { 333 return V->getValueID() == ConstantFPVal; 334 } 335 }; 336 337 //===----------------------------------------------------------------------===// 338 /// All zero aggregate value 339 /// 340 class ConstantAggregateZero final : public ConstantData { 341 friend class Constant; 342 343 explicit ConstantAggregateZero(Type *Ty) 344 : ConstantData(Ty, ConstantAggregateZeroVal) {} 345 346 void destroyConstantImpl(); 347 348 public: 349 ConstantAggregateZero(const ConstantAggregateZero &) = delete; 350 351 static ConstantAggregateZero *get(Type *Ty); 352 353 /// If this CAZ has array or vector type, return a zero with the right element 354 /// type. 355 Constant *getSequentialElement() const; 356 357 /// If this CAZ has struct type, return a zero with the right element type for 358 /// the specified element. 359 Constant *getStructElement(unsigned Elt) const; 360 361 /// Return a zero of the right value for the specified GEP index if we can, 362 /// otherwise return null (e.g. if C is a ConstantExpr). 363 Constant *getElementValue(Constant *C) const; 364 365 /// Return a zero of the right value for the specified GEP index. 366 Constant *getElementValue(unsigned Idx) const; 367 368 /// Return the number of elements in the array, vector, or struct. 369 unsigned getNumElements() const; 370 371 /// Methods for support type inquiry through isa, cast, and dyn_cast: 372 /// 373 static bool classof(const Value *V) { 374 return V->getValueID() == ConstantAggregateZeroVal; 375 } 376 }; 377 378 /// Base class for aggregate constants (with operands). 379 /// 380 /// These constants are aggregates of other constants, which are stored as 381 /// operands. 382 /// 383 /// Subclasses are \a ConstantStruct, \a ConstantArray, and \a 384 /// ConstantVector. 385 /// 386 /// \note Some subclasses of \a ConstantData are semantically aggregates -- 387 /// such as \a ConstantDataArray -- but are not subclasses of this because they 388 /// use operands. 389 class ConstantAggregate : public Constant { 390 protected: 391 ConstantAggregate(CompositeType *T, ValueTy VT, ArrayRef<Constant *> V); 392 393 public: 394 /// Transparently provide more efficient getOperand methods. 395 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant); 396 397 /// Methods for support type inquiry through isa, cast, and dyn_cast: 398 static bool classof(const Value *V) { 399 return V->getValueID() >= ConstantAggregateFirstVal && 400 V->getValueID() <= ConstantAggregateLastVal; 401 } 402 }; 403 404 template <> 405 struct OperandTraits<ConstantAggregate> 406 : public VariadicOperandTraits<ConstantAggregate> {}; 407 408 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantAggregate, Constant) 409 410 //===----------------------------------------------------------------------===// 411 /// ConstantArray - Constant Array Declarations 412 /// 413 class ConstantArray final : public ConstantAggregate { 414 friend struct ConstantAggrKeyType<ConstantArray>; 415 friend class Constant; 416 417 ConstantArray(ArrayType *T, ArrayRef<Constant *> Val); 418 419 void destroyConstantImpl(); 420 Value *handleOperandChangeImpl(Value *From, Value *To); 421 422 public: 423 // ConstantArray accessors 424 static Constant *get(ArrayType *T, ArrayRef<Constant*> V); 425 426 private: 427 static Constant *getImpl(ArrayType *T, ArrayRef<Constant *> V); 428 429 public: 430 /// Specialize the getType() method to always return an ArrayType, 431 /// which reduces the amount of casting needed in parts of the compiler. 432 inline ArrayType *getType() const { 433 return cast<ArrayType>(Value::getType()); 434 } 435 436 /// Methods for support type inquiry through isa, cast, and dyn_cast: 437 static bool classof(const Value *V) { 438 return V->getValueID() == ConstantArrayVal; 439 } 440 }; 441 442 //===----------------------------------------------------------------------===// 443 // Constant Struct Declarations 444 // 445 class ConstantStruct final : public ConstantAggregate { 446 friend struct ConstantAggrKeyType<ConstantStruct>; 447 friend class Constant; 448 449 ConstantStruct(StructType *T, ArrayRef<Constant *> Val); 450 451 void destroyConstantImpl(); 452 Value *handleOperandChangeImpl(Value *From, Value *To); 453 454 public: 455 // ConstantStruct accessors 456 static Constant *get(StructType *T, ArrayRef<Constant*> V); 457 458 template <typename... Csts> 459 static typename std::enable_if<are_base_of<Constant, Csts...>::value, 460 Constant *>::type 461 get(StructType *T, Csts *... Vs) { 462 SmallVector<Constant *, 8> Values({Vs...}); 463 return get(T, Values); 464 } 465 466 /// Return an anonymous struct that has the specified elements. 467 /// If the struct is possibly empty, then you must specify a context. 468 static Constant *getAnon(ArrayRef<Constant*> V, bool Packed = false) { 469 return get(getTypeForElements(V, Packed), V); 470 } 471 static Constant *getAnon(LLVMContext &Ctx, 472 ArrayRef<Constant*> V, bool Packed = false) { 473 return get(getTypeForElements(Ctx, V, Packed), V); 474 } 475 476 /// Return an anonymous struct type to use for a constant with the specified 477 /// set of elements. The list must not be empty. 478 static StructType *getTypeForElements(ArrayRef<Constant*> V, 479 bool Packed = false); 480 /// This version of the method allows an empty list. 481 static StructType *getTypeForElements(LLVMContext &Ctx, 482 ArrayRef<Constant*> V, 483 bool Packed = false); 484 485 /// Specialization - reduce amount of casting. 486 inline StructType *getType() const { 487 return cast<StructType>(Value::getType()); 488 } 489 490 /// Methods for support type inquiry through isa, cast, and dyn_cast: 491 static bool classof(const Value *V) { 492 return V->getValueID() == ConstantStructVal; 493 } 494 }; 495 496 //===----------------------------------------------------------------------===// 497 /// Constant Vector Declarations 498 /// 499 class ConstantVector final : public ConstantAggregate { 500 friend struct ConstantAggrKeyType<ConstantVector>; 501 friend class Constant; 502 503 ConstantVector(VectorType *T, ArrayRef<Constant *> Val); 504 505 void destroyConstantImpl(); 506 Value *handleOperandChangeImpl(Value *From, Value *To); 507 508 public: 509 // ConstantVector accessors 510 static Constant *get(ArrayRef<Constant*> V); 511 512 private: 513 static Constant *getImpl(ArrayRef<Constant *> V); 514 515 public: 516 /// Return a ConstantVector with the specified constant in each element. 517 static Constant *getSplat(unsigned NumElts, Constant *Elt); 518 519 /// Specialize the getType() method to always return a VectorType, 520 /// which reduces the amount of casting needed in parts of the compiler. 521 inline VectorType *getType() const { 522 return cast<VectorType>(Value::getType()); 523 } 524 525 /// If this is a splat constant, meaning that all of the elements have the 526 /// same value, return that value. Otherwise return NULL. 527 Constant *getSplatValue() const; 528 529 /// Methods for support type inquiry through isa, cast, and dyn_cast: 530 static bool classof(const Value *V) { 531 return V->getValueID() == ConstantVectorVal; 532 } 533 }; 534 535 //===----------------------------------------------------------------------===// 536 /// A constant pointer value that points to null 537 /// 538 class ConstantPointerNull final : public ConstantData { 539 friend class Constant; 540 541 explicit ConstantPointerNull(PointerType *T) 542 : ConstantData(T, Value::ConstantPointerNullVal) {} 543 544 void destroyConstantImpl(); 545 546 public: 547 ConstantPointerNull(const ConstantPointerNull &) = delete; 548 549 /// Static factory methods - Return objects of the specified value 550 static ConstantPointerNull *get(PointerType *T); 551 552 /// Specialize the getType() method to always return an PointerType, 553 /// which reduces the amount of casting needed in parts of the compiler. 554 inline PointerType *getType() const { 555 return cast<PointerType>(Value::getType()); 556 } 557 558 /// Methods for support type inquiry through isa, cast, and dyn_cast: 559 static bool classof(const Value *V) { 560 return V->getValueID() == ConstantPointerNullVal; 561 } 562 }; 563 564 //===----------------------------------------------------------------------===// 565 /// ConstantDataSequential - A vector or array constant whose element type is a 566 /// simple 1/2/4/8-byte integer or float/double, and whose elements are just 567 /// simple data values (i.e. ConstantInt/ConstantFP). This Constant node has no 568 /// operands because it stores all of the elements of the constant as densely 569 /// packed data, instead of as Value*'s. 570 /// 571 /// This is the common base class of ConstantDataArray and ConstantDataVector. 572 /// 573 class ConstantDataSequential : public ConstantData { 574 friend class LLVMContextImpl; 575 friend class Constant; 576 577 /// A pointer to the bytes underlying this constant (which is owned by the 578 /// uniquing StringMap). 579 const char *DataElements; 580 581 /// This forms a link list of ConstantDataSequential nodes that have 582 /// the same value but different type. For example, 0,0,0,1 could be a 4 583 /// element array of i8, or a 1-element array of i32. They'll both end up in 584 /// the same StringMap bucket, linked up. 585 ConstantDataSequential *Next; 586 587 void destroyConstantImpl(); 588 589 protected: 590 explicit ConstantDataSequential(Type *ty, ValueTy VT, const char *Data) 591 : ConstantData(ty, VT), DataElements(Data), Next(nullptr) {} 592 ~ConstantDataSequential() { delete Next; } 593 594 static Constant *getImpl(StringRef Bytes, Type *Ty); 595 596 public: 597 ConstantDataSequential(const ConstantDataSequential &) = delete; 598 599 /// Return true if a ConstantDataSequential can be formed with a vector or 600 /// array of the specified element type. 601 /// ConstantDataArray only works with normal float and int types that are 602 /// stored densely in memory, not with things like i42 or x86_f80. 603 static bool isElementTypeCompatible(Type *Ty); 604 605 /// If this is a sequential container of integers (of any size), return the 606 /// specified element in the low bits of a uint64_t. 607 uint64_t getElementAsInteger(unsigned i) const; 608 609 /// If this is a sequential container of integers (of any size), return the 610 /// specified element as an APInt. 611 APInt getElementAsAPInt(unsigned i) const; 612 613 /// If this is a sequential container of floating point type, return the 614 /// specified element as an APFloat. 615 APFloat getElementAsAPFloat(unsigned i) const; 616 617 /// If this is an sequential container of floats, return the specified element 618 /// as a float. 619 float getElementAsFloat(unsigned i) const; 620 621 /// If this is an sequential container of doubles, return the specified 622 /// element as a double. 623 double getElementAsDouble(unsigned i) const; 624 625 /// Return a Constant for a specified index's element. 626 /// Note that this has to compute a new constant to return, so it isn't as 627 /// efficient as getElementAsInteger/Float/Double. 628 Constant *getElementAsConstant(unsigned i) const; 629 630 /// Specialize the getType() method to always return a SequentialType, which 631 /// reduces the amount of casting needed in parts of the compiler. 632 inline SequentialType *getType() const { 633 return cast<SequentialType>(Value::getType()); 634 } 635 636 /// Return the element type of the array/vector. 637 Type *getElementType() const; 638 639 /// Return the number of elements in the array or vector. 640 unsigned getNumElements() const; 641 642 /// Return the size (in bytes) of each element in the array/vector. 643 /// The size of the elements is known to be a multiple of one byte. 644 uint64_t getElementByteSize() const; 645 646 /// This method returns true if this is an array of \p CharSize integers. 647 bool isString(unsigned CharSize = 8) const; 648 649 /// This method returns true if the array "isString", ends with a null byte, 650 /// and does not contains any other null bytes. 651 bool isCString() const; 652 653 /// If this array is isString(), then this method returns the array as a 654 /// StringRef. Otherwise, it asserts out. 655 StringRef getAsString() const { 656 assert(isString() && "Not a string"); 657 return getRawDataValues(); 658 } 659 660 /// If this array is isCString(), then this method returns the array (without 661 /// the trailing null byte) as a StringRef. Otherwise, it asserts out. 662 StringRef getAsCString() const { 663 assert(isCString() && "Isn't a C string"); 664 StringRef Str = getAsString(); 665 return Str.substr(0, Str.size()-1); 666 } 667 668 /// Return the raw, underlying, bytes of this data. Note that this is an 669 /// extremely tricky thing to work with, as it exposes the host endianness of 670 /// the data elements. 671 StringRef getRawDataValues() const; 672 673 /// Methods for support type inquiry through isa, cast, and dyn_cast: 674 static bool classof(const Value *V) { 675 return V->getValueID() == ConstantDataArrayVal || 676 V->getValueID() == ConstantDataVectorVal; 677 } 678 679 private: 680 const char *getElementPointer(unsigned Elt) const; 681 }; 682 683 //===----------------------------------------------------------------------===// 684 /// An array constant whose element type is a simple 1/2/4/8-byte integer or 685 /// float/double, and whose elements are just simple data values 686 /// (i.e. ConstantInt/ConstantFP). This Constant node has no operands because it 687 /// stores all of the elements of the constant as densely packed data, instead 688 /// of as Value*'s. 689 class ConstantDataArray final : public ConstantDataSequential { 690 friend class ConstantDataSequential; 691 692 explicit ConstantDataArray(Type *ty, const char *Data) 693 : ConstantDataSequential(ty, ConstantDataArrayVal, Data) {} 694 695 public: 696 ConstantDataArray(const ConstantDataArray &) = delete; 697 698 /// get() constructor - Return a constant with array type with an element 699 /// count and element type matching the ArrayRef passed in. Note that this 700 /// can return a ConstantAggregateZero object. 701 template <typename ElementTy> 702 static Constant *get(LLVMContext &Context, ArrayRef<ElementTy> Elts) { 703 const char *Data = reinterpret_cast<const char *>(Elts.data()); 704 return getRaw(StringRef(Data, Elts.size() * sizeof(ElementTy)), Elts.size(), 705 Type::getScalarTy<ElementTy>(Context)); 706 } 707 708 /// get() constructor - ArrayTy needs to be compatible with 709 /// ArrayRef<ElementTy>. Calls get(LLVMContext, ArrayRef<ElementTy>). 710 template <typename ArrayTy> 711 static Constant *get(LLVMContext &Context, ArrayTy &Elts) { 712 return ConstantDataArray::get(Context, makeArrayRef(Elts)); 713 } 714 715 /// get() constructor - Return a constant with array type with an element 716 /// count and element type matching the NumElements and ElementTy parameters 717 /// passed in. Note that this can return a ConstantAggregateZero object. 718 /// ElementTy needs to be one of i8/i16/i32/i64/float/double. Data is the 719 /// buffer containing the elements. Be careful to make sure Data uses the 720 /// right endianness, the buffer will be used as-is. 721 static Constant *getRaw(StringRef Data, uint64_t NumElements, Type *ElementTy) { 722 Type *Ty = ArrayType::get(ElementTy, NumElements); 723 return getImpl(Data, Ty); 724 } 725 726 /// getFP() constructors - Return a constant with array type with an element 727 /// count and element type of float with precision matching the number of 728 /// bits in the ArrayRef passed in. (i.e. half for 16bits, float for 32bits, 729 /// double for 64bits) Note that this can return a ConstantAggregateZero 730 /// object. 731 static Constant *getFP(LLVMContext &Context, ArrayRef<uint16_t> Elts); 732 static Constant *getFP(LLVMContext &Context, ArrayRef<uint32_t> Elts); 733 static Constant *getFP(LLVMContext &Context, ArrayRef<uint64_t> Elts); 734 735 /// This method constructs a CDS and initializes it with a text string. 736 /// The default behavior (AddNull==true) causes a null terminator to 737 /// be placed at the end of the array (increasing the length of the string by 738 /// one more than the StringRef would normally indicate. Pass AddNull=false 739 /// to disable this behavior. 740 static Constant *getString(LLVMContext &Context, StringRef Initializer, 741 bool AddNull = true); 742 743 /// Specialize the getType() method to always return an ArrayType, 744 /// which reduces the amount of casting needed in parts of the compiler. 745 inline ArrayType *getType() const { 746 return cast<ArrayType>(Value::getType()); 747 } 748 749 /// Methods for support type inquiry through isa, cast, and dyn_cast: 750 static bool classof(const Value *V) { 751 return V->getValueID() == ConstantDataArrayVal; 752 } 753 }; 754 755 //===----------------------------------------------------------------------===// 756 /// A vector constant whose element type is a simple 1/2/4/8-byte integer or 757 /// float/double, and whose elements are just simple data values 758 /// (i.e. ConstantInt/ConstantFP). This Constant node has no operands because it 759 /// stores all of the elements of the constant as densely packed data, instead 760 /// of as Value*'s. 761 class ConstantDataVector final : public ConstantDataSequential { 762 friend class ConstantDataSequential; 763 764 explicit ConstantDataVector(Type *ty, const char *Data) 765 : ConstantDataSequential(ty, ConstantDataVectorVal, Data) {} 766 767 public: 768 ConstantDataVector(const ConstantDataVector &) = delete; 769 770 /// get() constructors - Return a constant with vector type with an element 771 /// count and element type matching the ArrayRef passed in. Note that this 772 /// can return a ConstantAggregateZero object. 773 static Constant *get(LLVMContext &Context, ArrayRef<uint8_t> Elts); 774 static Constant *get(LLVMContext &Context, ArrayRef<uint16_t> Elts); 775 static Constant *get(LLVMContext &Context, ArrayRef<uint32_t> Elts); 776 static Constant *get(LLVMContext &Context, ArrayRef<uint64_t> Elts); 777 static Constant *get(LLVMContext &Context, ArrayRef<float> Elts); 778 static Constant *get(LLVMContext &Context, ArrayRef<double> Elts); 779 780 /// getFP() constructors - Return a constant with vector type with an element 781 /// count and element type of float with the precision matching the number of 782 /// bits in the ArrayRef passed in. (i.e. half for 16bits, float for 32bits, 783 /// double for 64bits) Note that this can return a ConstantAggregateZero 784 /// object. 785 static Constant *getFP(LLVMContext &Context, ArrayRef<uint16_t> Elts); 786 static Constant *getFP(LLVMContext &Context, ArrayRef<uint32_t> Elts); 787 static Constant *getFP(LLVMContext &Context, ArrayRef<uint64_t> Elts); 788 789 /// Return a ConstantVector with the specified constant in each element. 790 /// The specified constant has to be a of a compatible type (i8/i16/ 791 /// i32/i64/float/double) and must be a ConstantFP or ConstantInt. 792 static Constant *getSplat(unsigned NumElts, Constant *Elt); 793 794 /// Returns true if this is a splat constant, meaning that all elements have 795 /// the same value. 796 bool isSplat() const; 797 798 /// If this is a splat constant, meaning that all of the elements have the 799 /// same value, return that value. Otherwise return NULL. 800 Constant *getSplatValue() const; 801 802 /// Specialize the getType() method to always return a VectorType, 803 /// which reduces the amount of casting needed in parts of the compiler. 804 inline VectorType *getType() const { 805 return cast<VectorType>(Value::getType()); 806 } 807 808 /// Methods for support type inquiry through isa, cast, and dyn_cast: 809 static bool classof(const Value *V) { 810 return V->getValueID() == ConstantDataVectorVal; 811 } 812 }; 813 814 //===----------------------------------------------------------------------===// 815 /// A constant token which is empty 816 /// 817 class ConstantTokenNone final : public ConstantData { 818 friend class Constant; 819 820 explicit ConstantTokenNone(LLVMContext &Context) 821 : ConstantData(Type::getTokenTy(Context), ConstantTokenNoneVal) {} 822 823 void destroyConstantImpl(); 824 825 public: 826 ConstantTokenNone(const ConstantTokenNone &) = delete; 827 828 /// Return the ConstantTokenNone. 829 static ConstantTokenNone *get(LLVMContext &Context); 830 831 /// Methods to support type inquiry through isa, cast, and dyn_cast. 832 static bool classof(const Value *V) { 833 return V->getValueID() == ConstantTokenNoneVal; 834 } 835 }; 836 837 /// The address of a basic block. 838 /// 839 class BlockAddress final : public Constant { 840 friend class Constant; 841 842 BlockAddress(Function *F, BasicBlock *BB); 843 844 void *operator new(size_t s) { return User::operator new(s, 2); } 845 846 void destroyConstantImpl(); 847 Value *handleOperandChangeImpl(Value *From, Value *To); 848 849 public: 850 /// Return a BlockAddress for the specified function and basic block. 851 static BlockAddress *get(Function *F, BasicBlock *BB); 852 853 /// Return a BlockAddress for the specified basic block. The basic 854 /// block must be embedded into a function. 855 static BlockAddress *get(BasicBlock *BB); 856 857 /// Lookup an existing \c BlockAddress constant for the given BasicBlock. 858 /// 859 /// \returns 0 if \c !BB->hasAddressTaken(), otherwise the \c BlockAddress. 860 static BlockAddress *lookup(const BasicBlock *BB); 861 862 /// Transparently provide more efficient getOperand methods. 863 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 864 865 Function *getFunction() const { return (Function*)Op<0>().get(); } 866 BasicBlock *getBasicBlock() const { return (BasicBlock*)Op<1>().get(); } 867 868 /// Methods for support type inquiry through isa, cast, and dyn_cast: 869 static bool classof(const Value *V) { 870 return V->getValueID() == BlockAddressVal; 871 } 872 }; 873 874 template <> 875 struct OperandTraits<BlockAddress> : 876 public FixedNumOperandTraits<BlockAddress, 2> { 877 }; 878 879 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BlockAddress, Value) 880 881 //===----------------------------------------------------------------------===// 882 /// A constant value that is initialized with an expression using 883 /// other constant values. 884 /// 885 /// This class uses the standard Instruction opcodes to define the various 886 /// constant expressions. The Opcode field for the ConstantExpr class is 887 /// maintained in the Value::SubclassData field. 888 class ConstantExpr : public Constant { 889 friend struct ConstantExprKeyType; 890 friend class Constant; 891 892 void destroyConstantImpl(); 893 Value *handleOperandChangeImpl(Value *From, Value *To); 894 895 protected: 896 ConstantExpr(Type *ty, unsigned Opcode, Use *Ops, unsigned NumOps) 897 : Constant(ty, ConstantExprVal, Ops, NumOps) { 898 // Operation type (an Instruction opcode) is stored as the SubclassData. 899 setValueSubclassData(Opcode); 900 } 901 902 public: 903 // Static methods to construct a ConstantExpr of different kinds. Note that 904 // these methods may return a object that is not an instance of the 905 // ConstantExpr class, because they will attempt to fold the constant 906 // expression into something simpler if possible. 907 908 /// getAlignOf constant expr - computes the alignment of a type in a target 909 /// independent way (Note: the return type is an i64). 910 static Constant *getAlignOf(Type *Ty); 911 912 /// getSizeOf constant expr - computes the (alloc) size of a type (in 913 /// address-units, not bits) in a target independent way (Note: the return 914 /// type is an i64). 915 /// 916 static Constant *getSizeOf(Type *Ty); 917 918 /// getOffsetOf constant expr - computes the offset of a struct field in a 919 /// target independent way (Note: the return type is an i64). 920 /// 921 static Constant *getOffsetOf(StructType *STy, unsigned FieldNo); 922 923 /// getOffsetOf constant expr - This is a generalized form of getOffsetOf, 924 /// which supports any aggregate type, and any Constant index. 925 /// 926 static Constant *getOffsetOf(Type *Ty, Constant *FieldNo); 927 928 static Constant *getNeg(Constant *C, bool HasNUW = false, bool HasNSW =false); 929 static Constant *getFNeg(Constant *C); 930 static Constant *getNot(Constant *C); 931 static Constant *getAdd(Constant *C1, Constant *C2, 932 bool HasNUW = false, bool HasNSW = false); 933 static Constant *getFAdd(Constant *C1, Constant *C2); 934 static Constant *getSub(Constant *C1, Constant *C2, 935 bool HasNUW = false, bool HasNSW = false); 936 static Constant *getFSub(Constant *C1, Constant *C2); 937 static Constant *getMul(Constant *C1, Constant *C2, 938 bool HasNUW = false, bool HasNSW = false); 939 static Constant *getFMul(Constant *C1, Constant *C2); 940 static Constant *getUDiv(Constant *C1, Constant *C2, bool isExact = false); 941 static Constant *getSDiv(Constant *C1, Constant *C2, bool isExact = false); 942 static Constant *getFDiv(Constant *C1, Constant *C2); 943 static Constant *getURem(Constant *C1, Constant *C2); 944 static Constant *getSRem(Constant *C1, Constant *C2); 945 static Constant *getFRem(Constant *C1, Constant *C2); 946 static Constant *getAnd(Constant *C1, Constant *C2); 947 static Constant *getOr(Constant *C1, Constant *C2); 948 static Constant *getXor(Constant *C1, Constant *C2); 949 static Constant *getShl(Constant *C1, Constant *C2, 950 bool HasNUW = false, bool HasNSW = false); 951 static Constant *getLShr(Constant *C1, Constant *C2, bool isExact = false); 952 static Constant *getAShr(Constant *C1, Constant *C2, bool isExact = false); 953 static Constant *getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced = false); 954 static Constant *getSExt(Constant *C, Type *Ty, bool OnlyIfReduced = false); 955 static Constant *getZExt(Constant *C, Type *Ty, bool OnlyIfReduced = false); 956 static Constant *getFPTrunc(Constant *C, Type *Ty, 957 bool OnlyIfReduced = false); 958 static Constant *getFPExtend(Constant *C, Type *Ty, 959 bool OnlyIfReduced = false); 960 static Constant *getUIToFP(Constant *C, Type *Ty, bool OnlyIfReduced = false); 961 static Constant *getSIToFP(Constant *C, Type *Ty, bool OnlyIfReduced = false); 962 static Constant *getFPToUI(Constant *C, Type *Ty, bool OnlyIfReduced = false); 963 static Constant *getFPToSI(Constant *C, Type *Ty, bool OnlyIfReduced = false); 964 static Constant *getPtrToInt(Constant *C, Type *Ty, 965 bool OnlyIfReduced = false); 966 static Constant *getIntToPtr(Constant *C, Type *Ty, 967 bool OnlyIfReduced = false); 968 static Constant *getBitCast(Constant *C, Type *Ty, 969 bool OnlyIfReduced = false); 970 static Constant *getAddrSpaceCast(Constant *C, Type *Ty, 971 bool OnlyIfReduced = false); 972 973 static Constant *getNSWNeg(Constant *C) { return getNeg(C, false, true); } 974 static Constant *getNUWNeg(Constant *C) { return getNeg(C, true, false); } 975 976 static Constant *getNSWAdd(Constant *C1, Constant *C2) { 977 return getAdd(C1, C2, false, true); 978 } 979 980 static Constant *getNUWAdd(Constant *C1, Constant *C2) { 981 return getAdd(C1, C2, true, false); 982 } 983 984 static Constant *getNSWSub(Constant *C1, Constant *C2) { 985 return getSub(C1, C2, false, true); 986 } 987 988 static Constant *getNUWSub(Constant *C1, Constant *C2) { 989 return getSub(C1, C2, true, false); 990 } 991 992 static Constant *getNSWMul(Constant *C1, Constant *C2) { 993 return getMul(C1, C2, false, true); 994 } 995 996 static Constant *getNUWMul(Constant *C1, Constant *C2) { 997 return getMul(C1, C2, true, false); 998 } 999 1000 static Constant *getNSWShl(Constant *C1, Constant *C2) { 1001 return getShl(C1, C2, false, true); 1002 } 1003 1004 static Constant *getNUWShl(Constant *C1, Constant *C2) { 1005 return getShl(C1, C2, true, false); 1006 } 1007 1008 static Constant *getExactSDiv(Constant *C1, Constant *C2) { 1009 return getSDiv(C1, C2, true); 1010 } 1011 1012 static Constant *getExactUDiv(Constant *C1, Constant *C2) { 1013 return getUDiv(C1, C2, true); 1014 } 1015 1016 static Constant *getExactAShr(Constant *C1, Constant *C2) { 1017 return getAShr(C1, C2, true); 1018 } 1019 1020 static Constant *getExactLShr(Constant *C1, Constant *C2) { 1021 return getLShr(C1, C2, true); 1022 } 1023 1024 /// Return the identity constant for a binary opcode. 1025 /// The identity constant C is defined as X op C = X and C op X = X for every 1026 /// X when the binary operation is commutative. If the binop is not 1027 /// commutative, callers can acquire the operand 1 identity constant by 1028 /// setting AllowRHSConstant to true. For example, any shift has a zero 1029 /// identity constant for operand 1: X shift 0 = X. 1030 /// Return nullptr if the operator does not have an identity constant. 1031 static Constant *getBinOpIdentity(unsigned Opcode, Type *Ty, 1032 bool AllowRHSConstant = false); 1033 1034 /// Return the absorbing element for the given binary 1035 /// operation, i.e. a constant C such that X op C = C and C op X = C for 1036 /// every X. For example, this returns zero for integer multiplication. 1037 /// It returns null if the operator doesn't have an absorbing element. 1038 static Constant *getBinOpAbsorber(unsigned Opcode, Type *Ty); 1039 1040 /// Transparently provide more efficient getOperand methods. 1041 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant); 1042 1043 /// Convenience function for getting a Cast operation. 1044 /// 1045 /// \param ops The opcode for the conversion 1046 /// \param C The constant to be converted 1047 /// \param Ty The type to which the constant is converted 1048 /// \param OnlyIfReduced see \a getWithOperands() docs. 1049 static Constant *getCast(unsigned ops, Constant *C, Type *Ty, 1050 bool OnlyIfReduced = false); 1051 1052 // Create a ZExt or BitCast cast constant expression 1053 static Constant *getZExtOrBitCast( 1054 Constant *C, ///< The constant to zext or bitcast 1055 Type *Ty ///< The type to zext or bitcast C to 1056 ); 1057 1058 // Create a SExt or BitCast cast constant expression 1059 static Constant *getSExtOrBitCast( 1060 Constant *C, ///< The constant to sext or bitcast 1061 Type *Ty ///< The type to sext or bitcast C to 1062 ); 1063 1064 // Create a Trunc or BitCast cast constant expression 1065 static Constant *getTruncOrBitCast( 1066 Constant *C, ///< The constant to trunc or bitcast 1067 Type *Ty ///< The type to trunc or bitcast C to 1068 ); 1069 1070 /// Create a BitCast, AddrSpaceCast, or a PtrToInt cast constant 1071 /// expression. 1072 static Constant *getPointerCast( 1073 Constant *C, ///< The pointer value to be casted (operand 0) 1074 Type *Ty ///< The type to which cast should be made 1075 ); 1076 1077 /// Create a BitCast or AddrSpaceCast for a pointer type depending on 1078 /// the address space. 1079 static Constant *getPointerBitCastOrAddrSpaceCast( 1080 Constant *C, ///< The constant to addrspacecast or bitcast 1081 Type *Ty ///< The type to bitcast or addrspacecast C to 1082 ); 1083 1084 /// Create a ZExt, Bitcast or Trunc for integer -> integer casts 1085 static Constant *getIntegerCast( 1086 Constant *C, ///< The integer constant to be casted 1087 Type *Ty, ///< The integer type to cast to 1088 bool isSigned ///< Whether C should be treated as signed or not 1089 ); 1090 1091 /// Create a FPExt, Bitcast or FPTrunc for fp -> fp casts 1092 static Constant *getFPCast( 1093 Constant *C, ///< The integer constant to be casted 1094 Type *Ty ///< The integer type to cast to 1095 ); 1096 1097 /// Return true if this is a convert constant expression 1098 bool isCast() const; 1099 1100 /// Return true if this is a compare constant expression 1101 bool isCompare() const; 1102 1103 /// Return true if this is an insertvalue or extractvalue expression, 1104 /// and the getIndices() method may be used. 1105 bool hasIndices() const; 1106 1107 /// Return true if this is a getelementptr expression and all 1108 /// the index operands are compile-time known integers within the 1109 /// corresponding notional static array extents. Note that this is 1110 /// not equivalant to, a subset of, or a superset of the "inbounds" 1111 /// property. 1112 bool isGEPWithNoNotionalOverIndexing() const; 1113 1114 /// Select constant expr 1115 /// 1116 /// \param OnlyIfReducedTy see \a getWithOperands() docs. 1117 static Constant *getSelect(Constant *C, Constant *V1, Constant *V2, 1118 Type *OnlyIfReducedTy = nullptr); 1119 1120 /// get - Return a unary operator constant expression, 1121 /// folding if possible. 1122 /// 1123 /// \param OnlyIfReducedTy see \a getWithOperands() docs. 1124 static Constant *get(unsigned Opcode, Constant *C1, unsigned Flags = 0, 1125 Type *OnlyIfReducedTy = nullptr); 1126 1127 /// get - Return a binary or shift operator constant expression, 1128 /// folding if possible. 1129 /// 1130 /// \param OnlyIfReducedTy see \a getWithOperands() docs. 1131 static Constant *get(unsigned Opcode, Constant *C1, Constant *C2, 1132 unsigned Flags = 0, Type *OnlyIfReducedTy = nullptr); 1133 1134 /// Return an ICmp or FCmp comparison operator constant expression. 1135 /// 1136 /// \param OnlyIfReduced see \a getWithOperands() docs. 1137 static Constant *getCompare(unsigned short pred, Constant *C1, Constant *C2, 1138 bool OnlyIfReduced = false); 1139 1140 /// get* - Return some common constants without having to 1141 /// specify the full Instruction::OPCODE identifier. 1142 /// 1143 static Constant *getICmp(unsigned short pred, Constant *LHS, Constant *RHS, 1144 bool OnlyIfReduced = false); 1145 static Constant *getFCmp(unsigned short pred, Constant *LHS, Constant *RHS, 1146 bool OnlyIfReduced = false); 1147 1148 /// Getelementptr form. Value* is only accepted for convenience; 1149 /// all elements must be Constants. 1150 /// 1151 /// \param InRangeIndex the inrange index if present or None. 1152 /// \param OnlyIfReducedTy see \a getWithOperands() docs. 1153 static Constant *getGetElementPtr(Type *Ty, Constant *C, 1154 ArrayRef<Constant *> IdxList, 1155 bool InBounds = false, 1156 Optional<unsigned> InRangeIndex = None, 1157 Type *OnlyIfReducedTy = nullptr) { 1158 return getGetElementPtr( 1159 Ty, C, makeArrayRef((Value * const *)IdxList.data(), IdxList.size()), 1160 InBounds, InRangeIndex, OnlyIfReducedTy); 1161 } 1162 static Constant *getGetElementPtr(Type *Ty, Constant *C, Constant *Idx, 1163 bool InBounds = false, 1164 Optional<unsigned> InRangeIndex = None, 1165 Type *OnlyIfReducedTy = nullptr) { 1166 // This form of the function only exists to avoid ambiguous overload 1167 // warnings about whether to convert Idx to ArrayRef<Constant *> or 1168 // ArrayRef<Value *>. 1169 return getGetElementPtr(Ty, C, cast<Value>(Idx), InBounds, InRangeIndex, 1170 OnlyIfReducedTy); 1171 } 1172 static Constant *getGetElementPtr(Type *Ty, Constant *C, 1173 ArrayRef<Value *> IdxList, 1174 bool InBounds = false, 1175 Optional<unsigned> InRangeIndex = None, 1176 Type *OnlyIfReducedTy = nullptr); 1177 1178 /// Create an "inbounds" getelementptr. See the documentation for the 1179 /// "inbounds" flag in LangRef.html for details. 1180 static Constant *getInBoundsGetElementPtr(Type *Ty, Constant *C, 1181 ArrayRef<Constant *> IdxList) { 1182 return getGetElementPtr(Ty, C, IdxList, true); 1183 } 1184 static Constant *getInBoundsGetElementPtr(Type *Ty, Constant *C, 1185 Constant *Idx) { 1186 // This form of the function only exists to avoid ambiguous overload 1187 // warnings about whether to convert Idx to ArrayRef<Constant *> or 1188 // ArrayRef<Value *>. 1189 return getGetElementPtr(Ty, C, Idx, true); 1190 } 1191 static Constant *getInBoundsGetElementPtr(Type *Ty, Constant *C, 1192 ArrayRef<Value *> IdxList) { 1193 return getGetElementPtr(Ty, C, IdxList, true); 1194 } 1195 1196 static Constant *getExtractElement(Constant *Vec, Constant *Idx, 1197 Type *OnlyIfReducedTy = nullptr); 1198 static Constant *getInsertElement(Constant *Vec, Constant *Elt, Constant *Idx, 1199 Type *OnlyIfReducedTy = nullptr); 1200 static Constant *getShuffleVector(Constant *V1, Constant *V2, Constant *Mask, 1201 Type *OnlyIfReducedTy = nullptr); 1202 static Constant *getExtractValue(Constant *Agg, ArrayRef<unsigned> Idxs, 1203 Type *OnlyIfReducedTy = nullptr); 1204 static Constant *getInsertValue(Constant *Agg, Constant *Val, 1205 ArrayRef<unsigned> Idxs, 1206 Type *OnlyIfReducedTy = nullptr); 1207 1208 /// Return the opcode at the root of this constant expression 1209 unsigned getOpcode() const { return getSubclassDataFromValue(); } 1210 1211 /// Return the ICMP or FCMP predicate value. Assert if this is not an ICMP or 1212 /// FCMP constant expression. 1213 unsigned getPredicate() const; 1214 1215 /// Assert that this is an insertvalue or exactvalue 1216 /// expression and return the list of indices. 1217 ArrayRef<unsigned> getIndices() const; 1218 1219 /// Return a string representation for an opcode. 1220 const char *getOpcodeName() const; 1221 1222 /// Return a constant expression identical to this one, but with the specified 1223 /// operand set to the specified value. 1224 Constant *getWithOperandReplaced(unsigned OpNo, Constant *Op) const; 1225 1226 /// This returns the current constant expression with the operands replaced 1227 /// with the specified values. The specified array must have the same number 1228 /// of operands as our current one. 1229 Constant *getWithOperands(ArrayRef<Constant*> Ops) const { 1230 return getWithOperands(Ops, getType()); 1231 } 1232 1233 /// Get the current expression with the operands replaced. 1234 /// 1235 /// Return the current constant expression with the operands replaced with \c 1236 /// Ops and the type with \c Ty. The new operands must have the same number 1237 /// as the current ones. 1238 /// 1239 /// If \c OnlyIfReduced is \c true, nullptr will be returned unless something 1240 /// gets constant-folded, the type changes, or the expression is otherwise 1241 /// canonicalized. This parameter should almost always be \c false. 1242 Constant *getWithOperands(ArrayRef<Constant *> Ops, Type *Ty, 1243 bool OnlyIfReduced = false, 1244 Type *SrcTy = nullptr) const; 1245 1246 /// Returns an Instruction which implements the same operation as this 1247 /// ConstantExpr. The instruction is not linked to any basic block. 1248 /// 1249 /// A better approach to this could be to have a constructor for Instruction 1250 /// which would take a ConstantExpr parameter, but that would have spread 1251 /// implementation details of ConstantExpr outside of Constants.cpp, which 1252 /// would make it harder to remove ConstantExprs altogether. 1253 Instruction *getAsInstruction(); 1254 1255 /// Methods for support type inquiry through isa, cast, and dyn_cast: 1256 static bool classof(const Value *V) { 1257 return V->getValueID() == ConstantExprVal; 1258 } 1259 1260 private: 1261 // Shadow Value::setValueSubclassData with a private forwarding method so that 1262 // subclasses cannot accidentally use it. 1263 void setValueSubclassData(unsigned short D) { 1264 Value::setValueSubclassData(D); 1265 } 1266 }; 1267 1268 template <> 1269 struct OperandTraits<ConstantExpr> : 1270 public VariadicOperandTraits<ConstantExpr, 1> { 1271 }; 1272 1273 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantExpr, Constant) 1274 1275 //===----------------------------------------------------------------------===// 1276 /// 'undef' values are things that do not have specified contents. 1277 /// These are used for a variety of purposes, including global variable 1278 /// initializers and operands to instructions. 'undef' values can occur with 1279 /// any first-class type. 1280 /// 1281 /// Undef values aren't exactly constants; if they have multiple uses, they 1282 /// can appear to have different bit patterns at each use. See 1283 /// LangRef.html#undefvalues for details. 1284 /// 1285 class UndefValue final : public ConstantData { 1286 friend class Constant; 1287 1288 explicit UndefValue(Type *T) : ConstantData(T, UndefValueVal) {} 1289 1290 void destroyConstantImpl(); 1291 1292 public: 1293 UndefValue(const UndefValue &) = delete; 1294 1295 /// Static factory methods - Return an 'undef' object of the specified type. 1296 static UndefValue *get(Type *T); 1297 1298 /// If this Undef has array or vector type, return a undef with the right 1299 /// element type. 1300 UndefValue *getSequentialElement() const; 1301 1302 /// If this undef has struct type, return a undef with the right element type 1303 /// for the specified element. 1304 UndefValue *getStructElement(unsigned Elt) const; 1305 1306 /// Return an undef of the right value for the specified GEP index if we can, 1307 /// otherwise return null (e.g. if C is a ConstantExpr). 1308 UndefValue *getElementValue(Constant *C) const; 1309 1310 /// Return an undef of the right value for the specified GEP index. 1311 UndefValue *getElementValue(unsigned Idx) const; 1312 1313 /// Return the number of elements in the array, vector, or struct. 1314 unsigned getNumElements() const; 1315 1316 /// Methods for support type inquiry through isa, cast, and dyn_cast: 1317 static bool classof(const Value *V) { 1318 return V->getValueID() == UndefValueVal; 1319 } 1320 }; 1321 1322 } // end namespace llvm 1323 1324 #endif // LLVM_IR_CONSTANTS_H 1325