1 //===- llvm/Value.h - Definition of the Value class -------------*- 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 // This file declares the Value class. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_IR_VALUE_H 14 #define LLVM_IR_VALUE_H 15 16 #include "llvm-c/Types.h" 17 #include "llvm/ADT/STLExtras.h" 18 #include "llvm/ADT/StringRef.h" 19 #include "llvm/ADT/iterator_range.h" 20 #include "llvm/IR/Use.h" 21 #include "llvm/Support/Alignment.h" 22 #include "llvm/Support/CBindingWrapping.h" 23 #include "llvm/Support/Casting.h" 24 #include <cassert> 25 #include <iterator> 26 #include <memory> 27 28 namespace llvm { 29 30 class APInt; 31 class Argument; 32 class BasicBlock; 33 class Constant; 34 class ConstantData; 35 class ConstantAggregate; 36 class DataLayout; 37 class Function; 38 class GlobalAlias; 39 class GlobalIFunc; 40 class GlobalObject; 41 class GlobalValue; 42 class GlobalVariable; 43 class InlineAsm; 44 class Instruction; 45 class LLVMContext; 46 class MDNode; 47 class Module; 48 class ModuleSlotTracker; 49 class raw_ostream; 50 template<typename ValueTy> class StringMapEntry; 51 class Twine; 52 class Type; 53 class User; 54 55 using ValueName = StringMapEntry<Value *>; 56 57 //===----------------------------------------------------------------------===// 58 // Value Class 59 //===----------------------------------------------------------------------===// 60 61 /// LLVM Value Representation 62 /// 63 /// This is a very important LLVM class. It is the base class of all values 64 /// computed by a program that may be used as operands to other values. Value is 65 /// the super class of other important classes such as Instruction and Function. 66 /// All Values have a Type. Type is not a subclass of Value. Some values can 67 /// have a name and they belong to some Module. Setting the name on the Value 68 /// automatically updates the module's symbol table. 69 /// 70 /// Every value has a "use list" that keeps track of which other Values are 71 /// using this Value. A Value can also have an arbitrary number of ValueHandle 72 /// objects that watch it and listen to RAUW and Destroy events. See 73 /// llvm/IR/ValueHandle.h for details. 74 class Value { 75 Type *VTy; 76 Use *UseList; 77 78 friend class ValueAsMetadata; // Allow access to IsUsedByMD. 79 friend class ValueHandleBase; 80 81 const unsigned char SubclassID; // Subclass identifier (for isa/dyn_cast) 82 unsigned char HasValueHandle : 1; // Has a ValueHandle pointing to this? 83 84 protected: 85 /// Hold subclass data that can be dropped. 86 /// 87 /// This member is similar to SubclassData, however it is for holding 88 /// information which may be used to aid optimization, but which may be 89 /// cleared to zero without affecting conservative interpretation. 90 unsigned char SubclassOptionalData : 7; 91 92 private: 93 /// Hold arbitrary subclass data. 94 /// 95 /// This member is defined by this class, but is not used for anything. 96 /// Subclasses can use it to hold whatever state they find useful. This 97 /// field is initialized to zero by the ctor. 98 unsigned short SubclassData; 99 100 protected: 101 /// The number of operands in the subclass. 102 /// 103 /// This member is defined by this class, but not used for anything. 104 /// Subclasses can use it to store their number of operands, if they have 105 /// any. 106 /// 107 /// This is stored here to save space in User on 64-bit hosts. Since most 108 /// instances of Value have operands, 32-bit hosts aren't significantly 109 /// affected. 110 /// 111 /// Note, this should *NOT* be used directly by any class other than User. 112 /// User uses this value to find the Use list. 113 enum : unsigned { NumUserOperandsBits = 27 }; 114 unsigned NumUserOperands : NumUserOperandsBits; 115 116 // Use the same type as the bitfield above so that MSVC will pack them. 117 unsigned IsUsedByMD : 1; 118 unsigned HasName : 1; 119 unsigned HasMetadata : 1; // Has metadata attached to this? 120 unsigned HasHungOffUses : 1; 121 unsigned HasDescriptor : 1; 122 123 private: 124 template <typename UseT> // UseT == 'Use' or 'const Use' 125 class use_iterator_impl { 126 friend class Value; 127 128 UseT *U; 129 130 explicit use_iterator_impl(UseT *u) : U(u) {} 131 132 public: 133 using iterator_category = std::forward_iterator_tag; 134 using value_type = UseT *; 135 using difference_type = std::ptrdiff_t; 136 using pointer = value_type *; 137 using reference = value_type &; 138 139 use_iterator_impl() : U() {} 140 141 bool operator==(const use_iterator_impl &x) const { return U == x.U; } 142 bool operator!=(const use_iterator_impl &x) const { return !operator==(x); } 143 144 use_iterator_impl &operator++() { // Preincrement 145 assert(U && "Cannot increment end iterator!"); 146 U = U->getNext(); 147 return *this; 148 } 149 150 use_iterator_impl operator++(int) { // Postincrement 151 auto tmp = *this; 152 ++*this; 153 return tmp; 154 } 155 156 UseT &operator*() const { 157 assert(U && "Cannot dereference end iterator!"); 158 return *U; 159 } 160 161 UseT *operator->() const { return &operator*(); } 162 163 operator use_iterator_impl<const UseT>() const { 164 return use_iterator_impl<const UseT>(U); 165 } 166 }; 167 168 template <typename UserTy> // UserTy == 'User' or 'const User' 169 class user_iterator_impl { 170 use_iterator_impl<Use> UI; 171 explicit user_iterator_impl(Use *U) : UI(U) {} 172 friend class Value; 173 174 public: 175 using iterator_category = std::forward_iterator_tag; 176 using value_type = UserTy *; 177 using difference_type = std::ptrdiff_t; 178 using pointer = value_type *; 179 using reference = value_type &; 180 181 user_iterator_impl() = default; 182 183 bool operator==(const user_iterator_impl &x) const { return UI == x.UI; } 184 bool operator!=(const user_iterator_impl &x) const { return !operator==(x); } 185 186 /// Returns true if this iterator is equal to user_end() on the value. 187 bool atEnd() const { return *this == user_iterator_impl(); } 188 189 user_iterator_impl &operator++() { // Preincrement 190 ++UI; 191 return *this; 192 } 193 194 user_iterator_impl operator++(int) { // Postincrement 195 auto tmp = *this; 196 ++*this; 197 return tmp; 198 } 199 200 // Retrieve a pointer to the current User. 201 UserTy *operator*() const { 202 return UI->getUser(); 203 } 204 205 UserTy *operator->() const { return operator*(); } 206 207 operator user_iterator_impl<const UserTy>() const { 208 return user_iterator_impl<const UserTy>(*UI); 209 } 210 211 Use &getUse() const { return *UI; } 212 }; 213 214 protected: 215 Value(Type *Ty, unsigned scid); 216 217 /// Value's destructor should be virtual by design, but that would require 218 /// that Value and all of its subclasses have a vtable that effectively 219 /// duplicates the information in the value ID. As a size optimization, the 220 /// destructor has been protected, and the caller should manually call 221 /// deleteValue. 222 ~Value(); // Use deleteValue() to delete a generic Value. 223 224 public: 225 Value(const Value &) = delete; 226 Value &operator=(const Value &) = delete; 227 228 /// Delete a pointer to a generic Value. 229 void deleteValue(); 230 231 /// Support for debugging, callable in GDB: V->dump() 232 void dump() const; 233 234 /// Implement operator<< on Value. 235 /// @{ 236 void print(raw_ostream &O, bool IsForDebug = false) const; 237 void print(raw_ostream &O, ModuleSlotTracker &MST, 238 bool IsForDebug = false) const; 239 /// @} 240 241 /// Print the name of this Value out to the specified raw_ostream. 242 /// 243 /// This is useful when you just want to print 'int %reg126', not the 244 /// instruction that generated it. If you specify a Module for context, then 245 /// even constanst get pretty-printed; for example, the type of a null 246 /// pointer is printed symbolically. 247 /// @{ 248 void printAsOperand(raw_ostream &O, bool PrintType = true, 249 const Module *M = nullptr) const; 250 void printAsOperand(raw_ostream &O, bool PrintType, 251 ModuleSlotTracker &MST) const; 252 /// @} 253 254 /// All values are typed, get the type of this value. 255 Type *getType() const { return VTy; } 256 257 /// All values hold a context through their type. 258 LLVMContext &getContext() const; 259 260 // All values can potentially be named. 261 bool hasName() const { return HasName; } 262 ValueName *getValueName() const; 263 void setValueName(ValueName *VN); 264 265 private: 266 void destroyValueName(); 267 enum class ReplaceMetadataUses { No, Yes }; 268 void doRAUW(Value *New, ReplaceMetadataUses); 269 void setNameImpl(const Twine &Name); 270 271 public: 272 /// Return a constant reference to the value's name. 273 /// 274 /// This guaranteed to return the same reference as long as the value is not 275 /// modified. If the value has a name, this does a hashtable lookup, so it's 276 /// not free. 277 StringRef getName() const; 278 279 /// Change the name of the value. 280 /// 281 /// Choose a new unique name if the provided name is taken. 282 /// 283 /// \param Name The new name; or "" if the value's name should be removed. 284 void setName(const Twine &Name); 285 286 /// Transfer the name from V to this value. 287 /// 288 /// After taking V's name, sets V's name to empty. 289 /// 290 /// \note It is an error to call V->takeName(V). 291 void takeName(Value *V); 292 293 #ifndef NDEBUG 294 std::string getNameOrAsOperand() const; 295 #endif 296 297 /// Change all uses of this to point to a new Value. 298 /// 299 /// Go through the uses list for this definition and make each use point to 300 /// "V" instead of "this". After this completes, 'this's use list is 301 /// guaranteed to be empty. 302 void replaceAllUsesWith(Value *V); 303 304 /// Change non-metadata uses of this to point to a new Value. 305 /// 306 /// Go through the uses list for this definition and make each use point to 307 /// "V" instead of "this". This function skips metadata entries in the list. 308 void replaceNonMetadataUsesWith(Value *V); 309 310 /// Go through the uses list for this definition and make each use point 311 /// to "V" if the callback ShouldReplace returns true for the given Use. 312 /// Unlike replaceAllUsesWith() this function does not support basic block 313 /// values. 314 void replaceUsesWithIf(Value *New, 315 llvm::function_ref<bool(Use &U)> ShouldReplace); 316 317 /// replaceUsesOutsideBlock - Go through the uses list for this definition and 318 /// make each use point to "V" instead of "this" when the use is outside the 319 /// block. 'This's use list is expected to have at least one element. 320 /// Unlike replaceAllUsesWith() this function does not support basic block 321 /// values. 322 void replaceUsesOutsideBlock(Value *V, BasicBlock *BB); 323 324 //---------------------------------------------------------------------- 325 // Methods for handling the chain of uses of this Value. 326 // 327 // Materializing a function can introduce new uses, so these methods come in 328 // two variants: 329 // The methods that start with materialized_ check the uses that are 330 // currently known given which functions are materialized. Be very careful 331 // when using them since you might not get all uses. 332 // The methods that don't start with materialized_ assert that modules is 333 // fully materialized. 334 void assertModuleIsMaterializedImpl() const; 335 // This indirection exists so we can keep assertModuleIsMaterializedImpl() 336 // around in release builds of Value.cpp to be linked with other code built 337 // in debug mode. But this avoids calling it in any of the release built code. 338 void assertModuleIsMaterialized() const { 339 #ifndef NDEBUG 340 assertModuleIsMaterializedImpl(); 341 #endif 342 } 343 344 bool use_empty() const { 345 assertModuleIsMaterialized(); 346 return UseList == nullptr; 347 } 348 349 bool materialized_use_empty() const { 350 return UseList == nullptr; 351 } 352 353 using use_iterator = use_iterator_impl<Use>; 354 using const_use_iterator = use_iterator_impl<const Use>; 355 356 use_iterator materialized_use_begin() { return use_iterator(UseList); } 357 const_use_iterator materialized_use_begin() const { 358 return const_use_iterator(UseList); 359 } 360 use_iterator use_begin() { 361 assertModuleIsMaterialized(); 362 return materialized_use_begin(); 363 } 364 const_use_iterator use_begin() const { 365 assertModuleIsMaterialized(); 366 return materialized_use_begin(); 367 } 368 use_iterator use_end() { return use_iterator(); } 369 const_use_iterator use_end() const { return const_use_iterator(); } 370 iterator_range<use_iterator> materialized_uses() { 371 return make_range(materialized_use_begin(), use_end()); 372 } 373 iterator_range<const_use_iterator> materialized_uses() const { 374 return make_range(materialized_use_begin(), use_end()); 375 } 376 iterator_range<use_iterator> uses() { 377 assertModuleIsMaterialized(); 378 return materialized_uses(); 379 } 380 iterator_range<const_use_iterator> uses() const { 381 assertModuleIsMaterialized(); 382 return materialized_uses(); 383 } 384 385 bool user_empty() const { 386 assertModuleIsMaterialized(); 387 return UseList == nullptr; 388 } 389 390 using user_iterator = user_iterator_impl<User>; 391 using const_user_iterator = user_iterator_impl<const User>; 392 393 user_iterator materialized_user_begin() { return user_iterator(UseList); } 394 const_user_iterator materialized_user_begin() const { 395 return const_user_iterator(UseList); 396 } 397 user_iterator user_begin() { 398 assertModuleIsMaterialized(); 399 return materialized_user_begin(); 400 } 401 const_user_iterator user_begin() const { 402 assertModuleIsMaterialized(); 403 return materialized_user_begin(); 404 } 405 user_iterator user_end() { return user_iterator(); } 406 const_user_iterator user_end() const { return const_user_iterator(); } 407 User *user_back() { 408 assertModuleIsMaterialized(); 409 return *materialized_user_begin(); 410 } 411 const User *user_back() const { 412 assertModuleIsMaterialized(); 413 return *materialized_user_begin(); 414 } 415 iterator_range<user_iterator> materialized_users() { 416 return make_range(materialized_user_begin(), user_end()); 417 } 418 iterator_range<const_user_iterator> materialized_users() const { 419 return make_range(materialized_user_begin(), user_end()); 420 } 421 iterator_range<user_iterator> users() { 422 assertModuleIsMaterialized(); 423 return materialized_users(); 424 } 425 iterator_range<const_user_iterator> users() const { 426 assertModuleIsMaterialized(); 427 return materialized_users(); 428 } 429 430 /// Return true if there is exactly one use of this value. 431 /// 432 /// This is specialized because it is a common request and does not require 433 /// traversing the whole use list. 434 bool hasOneUse() const { return hasSingleElement(uses()); } 435 436 /// Return true if this Value has exactly N uses. 437 bool hasNUses(unsigned N) const; 438 439 /// Return true if this value has N uses or more. 440 /// 441 /// This is logically equivalent to getNumUses() >= N. 442 bool hasNUsesOrMore(unsigned N) const; 443 444 /// Return true if there is exactly one user of this value. 445 /// 446 /// Note that this is not the same as "has one use". If a value has one use, 447 /// then there certainly is a single user. But if value has several uses, 448 /// it is possible that all uses are in a single user, or not. 449 /// 450 /// This check is potentially costly, since it requires traversing, 451 /// in the worst case, the whole use list of a value. 452 bool hasOneUser() const; 453 454 /// Return true if there is exactly one use of this value that cannot be 455 /// dropped. 456 Use *getSingleUndroppableUse(); 457 const Use *getSingleUndroppableUse() const { 458 return const_cast<Value *>(this)->getSingleUndroppableUse(); 459 } 460 461 /// Return true if there is exactly one unique user of this value that cannot be 462 /// dropped (that user can have multiple uses of this value). 463 User *getUniqueUndroppableUser(); 464 const User *getUniqueUndroppableUser() const { 465 return const_cast<Value *>(this)->getUniqueUndroppableUser(); 466 } 467 468 /// Return true if there this value. 469 /// 470 /// This is specialized because it is a common request and does not require 471 /// traversing the whole use list. 472 bool hasNUndroppableUses(unsigned N) const; 473 474 /// Return true if this value has N uses or more. 475 /// 476 /// This is logically equivalent to getNumUses() >= N. 477 bool hasNUndroppableUsesOrMore(unsigned N) const; 478 479 /// Remove every uses that can safely be removed. 480 /// 481 /// This will remove for example uses in llvm.assume. 482 /// This should be used when performing want to perform a tranformation but 483 /// some Droppable uses pervent it. 484 /// This function optionally takes a filter to only remove some droppable 485 /// uses. 486 void dropDroppableUses(llvm::function_ref<bool(const Use *)> ShouldDrop = 487 [](const Use *) { return true; }); 488 489 /// Remove every use of this value in \p User that can safely be removed. 490 void dropDroppableUsesIn(User &Usr); 491 492 /// Remove the droppable use \p U. 493 static void dropDroppableUse(Use &U); 494 495 /// Check if this value is used in the specified basic block. 496 bool isUsedInBasicBlock(const BasicBlock *BB) const; 497 498 /// This method computes the number of uses of this Value. 499 /// 500 /// This is a linear time operation. Use hasOneUse, hasNUses, or 501 /// hasNUsesOrMore to check for specific values. 502 unsigned getNumUses() const; 503 504 /// This method should only be used by the Use class. 505 void addUse(Use &U) { U.addToList(&UseList); } 506 507 /// Concrete subclass of this. 508 /// 509 /// An enumeration for keeping track of the concrete subclass of Value that 510 /// is actually instantiated. Values of this enumeration are kept in the 511 /// Value classes SubclassID field. They are used for concrete type 512 /// identification. 513 enum ValueTy { 514 #define HANDLE_VALUE(Name) Name##Val, 515 #include "llvm/IR/Value.def" 516 517 // Markers: 518 #define HANDLE_CONSTANT_MARKER(Marker, Constant) Marker = Constant##Val, 519 #include "llvm/IR/Value.def" 520 }; 521 522 /// Return an ID for the concrete type of this object. 523 /// 524 /// This is used to implement the classof checks. This should not be used 525 /// for any other purpose, as the values may change as LLVM evolves. Also, 526 /// note that for instructions, the Instruction's opcode is added to 527 /// InstructionVal. So this means three things: 528 /// # there is no value with code InstructionVal (no opcode==0). 529 /// # there are more possible values for the value type than in ValueTy enum. 530 /// # the InstructionVal enumerator must be the highest valued enumerator in 531 /// the ValueTy enum. 532 unsigned getValueID() const { 533 return SubclassID; 534 } 535 536 /// Return the raw optional flags value contained in this value. 537 /// 538 /// This should only be used when testing two Values for equivalence. 539 unsigned getRawSubclassOptionalData() const { 540 return SubclassOptionalData; 541 } 542 543 /// Clear the optional flags contained in this value. 544 void clearSubclassOptionalData() { 545 SubclassOptionalData = 0; 546 } 547 548 /// Check the optional flags for equality. 549 bool hasSameSubclassOptionalData(const Value *V) const { 550 return SubclassOptionalData == V->SubclassOptionalData; 551 } 552 553 /// Return true if there is a value handle associated with this value. 554 bool hasValueHandle() const { return HasValueHandle; } 555 556 /// Return true if there is metadata referencing this value. 557 bool isUsedByMetadata() const { return IsUsedByMD; } 558 559 protected: 560 /// Get the current metadata attachments for the given kind, if any. 561 /// 562 /// These functions require that the value have at most a single attachment 563 /// of the given kind, and return \c nullptr if such an attachment is missing. 564 /// @{ 565 MDNode *getMetadata(unsigned KindID) const; 566 MDNode *getMetadata(StringRef Kind) const; 567 /// @} 568 569 /// Appends all attachments with the given ID to \c MDs in insertion order. 570 /// If the Value has no attachments with the given ID, or if ID is invalid, 571 /// leaves MDs unchanged. 572 /// @{ 573 void getMetadata(unsigned KindID, SmallVectorImpl<MDNode *> &MDs) const; 574 void getMetadata(StringRef Kind, SmallVectorImpl<MDNode *> &MDs) const; 575 /// @} 576 577 /// Appends all metadata attached to this value to \c MDs, sorting by 578 /// KindID. The first element of each pair returned is the KindID, the second 579 /// element is the metadata value. Attachments with the same ID appear in 580 /// insertion order. 581 void 582 getAllMetadata(SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const; 583 584 /// Return true if this value has any metadata attached to it. 585 bool hasMetadata() const { return (bool)HasMetadata; } 586 587 /// Return true if this value has the given type of metadata attached. 588 /// @{ 589 bool hasMetadata(unsigned KindID) const { 590 return getMetadata(KindID) != nullptr; 591 } 592 bool hasMetadata(StringRef Kind) const { 593 return getMetadata(Kind) != nullptr; 594 } 595 /// @} 596 597 /// Set a particular kind of metadata attachment. 598 /// 599 /// Sets the given attachment to \c MD, erasing it if \c MD is \c nullptr or 600 /// replacing it if it already exists. 601 /// @{ 602 void setMetadata(unsigned KindID, MDNode *Node); 603 void setMetadata(StringRef Kind, MDNode *Node); 604 /// @} 605 606 /// Add a metadata attachment. 607 /// @{ 608 void addMetadata(unsigned KindID, MDNode &MD); 609 void addMetadata(StringRef Kind, MDNode &MD); 610 /// @} 611 612 /// Erase all metadata attachments with the given kind. 613 /// 614 /// \returns true if any metadata was removed. 615 bool eraseMetadata(unsigned KindID); 616 617 /// Erase all metadata attached to this Value. 618 void clearMetadata(); 619 620 public: 621 /// Return true if this value is a swifterror value. 622 /// 623 /// swifterror values can be either a function argument or an alloca with a 624 /// swifterror attribute. 625 bool isSwiftError() const; 626 627 /// Strip off pointer casts, all-zero GEPs and address space casts. 628 /// 629 /// Returns the original uncasted value. If this is called on a non-pointer 630 /// value, it returns 'this'. 631 const Value *stripPointerCasts() const; 632 Value *stripPointerCasts() { 633 return const_cast<Value *>( 634 static_cast<const Value *>(this)->stripPointerCasts()); 635 } 636 637 /// Strip off pointer casts, all-zero GEPs, address space casts, and aliases. 638 /// 639 /// Returns the original uncasted value. If this is called on a non-pointer 640 /// value, it returns 'this'. 641 const Value *stripPointerCastsAndAliases() const; 642 Value *stripPointerCastsAndAliases() { 643 return const_cast<Value *>( 644 static_cast<const Value *>(this)->stripPointerCastsAndAliases()); 645 } 646 647 /// Strip off pointer casts, all-zero GEPs and address space casts 648 /// but ensures the representation of the result stays the same. 649 /// 650 /// Returns the original uncasted value with the same representation. If this 651 /// is called on a non-pointer value, it returns 'this'. 652 const Value *stripPointerCastsSameRepresentation() const; 653 Value *stripPointerCastsSameRepresentation() { 654 return const_cast<Value *>(static_cast<const Value *>(this) 655 ->stripPointerCastsSameRepresentation()); 656 } 657 658 /// Strip off pointer casts, all-zero GEPs, single-argument phi nodes and 659 /// invariant group info. 660 /// 661 /// Returns the original uncasted value. If this is called on a non-pointer 662 /// value, it returns 'this'. This function should be used only in 663 /// Alias analysis. 664 const Value *stripPointerCastsForAliasAnalysis() const; 665 Value *stripPointerCastsForAliasAnalysis() { 666 return const_cast<Value *>(static_cast<const Value *>(this) 667 ->stripPointerCastsForAliasAnalysis()); 668 } 669 670 /// Strip off pointer casts and all-constant inbounds GEPs. 671 /// 672 /// Returns the original pointer value. If this is called on a non-pointer 673 /// value, it returns 'this'. 674 const Value *stripInBoundsConstantOffsets() const; 675 Value *stripInBoundsConstantOffsets() { 676 return const_cast<Value *>( 677 static_cast<const Value *>(this)->stripInBoundsConstantOffsets()); 678 } 679 680 /// Accumulate the constant offset this value has compared to a base pointer. 681 /// Only 'getelementptr' instructions (GEPs) are accumulated but other 682 /// instructions, e.g., casts, are stripped away as well. 683 /// The accumulated constant offset is added to \p Offset and the base 684 /// pointer is returned. 685 /// 686 /// The APInt \p Offset has to have a bit-width equal to the IntPtr type for 687 /// the address space of 'this' pointer value, e.g., use 688 /// DataLayout::getIndexTypeSizeInBits(Ty). 689 /// 690 /// If \p AllowNonInbounds is true, offsets in GEPs are stripped and 691 /// accumulated even if the GEP is not "inbounds". 692 /// 693 /// If \p AllowInvariantGroup is true then this method also looks through 694 /// strip.invariant.group and launder.invariant.group intrinsics. 695 /// 696 /// If \p ExternalAnalysis is provided it will be used to calculate a offset 697 /// when a operand of GEP is not constant. 698 /// For example, for a value \p ExternalAnalysis might try to calculate a 699 /// lower bound. If \p ExternalAnalysis is successful, it should return true. 700 /// 701 /// If this is called on a non-pointer value, it returns 'this' and the 702 /// \p Offset is not modified. 703 /// 704 /// Note that this function will never return a nullptr. It will also never 705 /// manipulate the \p Offset in a way that would not match the difference 706 /// between the underlying value and the returned one. Thus, if no constant 707 /// offset was found, the returned value is the underlying one and \p Offset 708 /// is unchanged. 709 const Value *stripAndAccumulateConstantOffsets( 710 const DataLayout &DL, APInt &Offset, bool AllowNonInbounds, 711 bool AllowInvariantGroup = false, 712 function_ref<bool(Value &Value, APInt &Offset)> ExternalAnalysis = 713 nullptr) const; 714 Value *stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset, 715 bool AllowNonInbounds, 716 bool AllowInvariantGroup = false) { 717 return const_cast<Value *>( 718 static_cast<const Value *>(this)->stripAndAccumulateConstantOffsets( 719 DL, Offset, AllowNonInbounds, AllowInvariantGroup)); 720 } 721 722 /// This is a wrapper around stripAndAccumulateConstantOffsets with the 723 /// in-bounds requirement set to false. 724 const Value *stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL, 725 APInt &Offset) const { 726 return stripAndAccumulateConstantOffsets(DL, Offset, 727 /* AllowNonInbounds */ false); 728 } 729 Value *stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL, 730 APInt &Offset) { 731 return stripAndAccumulateConstantOffsets(DL, Offset, 732 /* AllowNonInbounds */ false); 733 } 734 735 /// Strip off pointer casts and inbounds GEPs. 736 /// 737 /// Returns the original pointer value. If this is called on a non-pointer 738 /// value, it returns 'this'. 739 const Value *stripInBoundsOffsets(function_ref<void(const Value *)> Func = 740 [](const Value *) {}) const; 741 inline Value *stripInBoundsOffsets(function_ref<void(const Value *)> Func = 742 [](const Value *) {}) { 743 return const_cast<Value *>( 744 static_cast<const Value *>(this)->stripInBoundsOffsets(Func)); 745 } 746 747 /// Return true if the memory object referred to by V can by freed in the 748 /// scope for which the SSA value defining the allocation is statically 749 /// defined. E.g. deallocation after the static scope of a value does not 750 /// count, but a deallocation before that does. 751 bool canBeFreed() const; 752 753 /// Returns the number of bytes known to be dereferenceable for the 754 /// pointer value. 755 /// 756 /// If CanBeNull is set by this function the pointer can either be null or be 757 /// dereferenceable up to the returned number of bytes. 758 /// 759 /// IF CanBeFreed is true, the pointer is known to be dereferenceable at 760 /// point of definition only. Caller must prove that allocation is not 761 /// deallocated between point of definition and use. 762 uint64_t getPointerDereferenceableBytes(const DataLayout &DL, 763 bool &CanBeNull, 764 bool &CanBeFreed) const; 765 766 /// Returns an alignment of the pointer value. 767 /// 768 /// Returns an alignment which is either specified explicitly, e.g. via 769 /// align attribute of a function argument, or guaranteed by DataLayout. 770 Align getPointerAlignment(const DataLayout &DL) const; 771 772 /// Translate PHI node to its predecessor from the given basic block. 773 /// 774 /// If this value is a PHI node with CurBB as its parent, return the value in 775 /// the PHI node corresponding to PredBB. If not, return ourself. This is 776 /// useful if you want to know the value something has in a predecessor 777 /// block. 778 const Value *DoPHITranslation(const BasicBlock *CurBB, 779 const BasicBlock *PredBB) const; 780 Value *DoPHITranslation(const BasicBlock *CurBB, const BasicBlock *PredBB) { 781 return const_cast<Value *>( 782 static_cast<const Value *>(this)->DoPHITranslation(CurBB, PredBB)); 783 } 784 785 /// The maximum alignment for instructions. 786 /// 787 /// This is the greatest alignment value supported by load, store, and alloca 788 /// instructions, and global values. 789 static constexpr unsigned MaxAlignmentExponent = 32; 790 static constexpr uint64_t MaximumAlignment = 1ULL << MaxAlignmentExponent; 791 792 /// Mutate the type of this Value to be of the specified type. 793 /// 794 /// Note that this is an extremely dangerous operation which can create 795 /// completely invalid IR very easily. It is strongly recommended that you 796 /// recreate IR objects with the right types instead of mutating them in 797 /// place. 798 void mutateType(Type *Ty) { 799 VTy = Ty; 800 } 801 802 /// Sort the use-list. 803 /// 804 /// Sorts the Value's use-list by Cmp using a stable mergesort. Cmp is 805 /// expected to compare two \a Use references. 806 template <class Compare> void sortUseList(Compare Cmp); 807 808 /// Reverse the use-list. 809 void reverseUseList(); 810 811 private: 812 /// Merge two lists together. 813 /// 814 /// Merges \c L and \c R using \c Cmp. To enable stable sorts, always pushes 815 /// "equal" items from L before items from R. 816 /// 817 /// \return the first element in the list. 818 /// 819 /// \note Completely ignores \a Use::Prev (doesn't read, doesn't update). 820 template <class Compare> 821 static Use *mergeUseLists(Use *L, Use *R, Compare Cmp) { 822 Use *Merged; 823 Use **Next = &Merged; 824 825 while (true) { 826 if (!L) { 827 *Next = R; 828 break; 829 } 830 if (!R) { 831 *Next = L; 832 break; 833 } 834 if (Cmp(*R, *L)) { 835 *Next = R; 836 Next = &R->Next; 837 R = R->Next; 838 } else { 839 *Next = L; 840 Next = &L->Next; 841 L = L->Next; 842 } 843 } 844 845 return Merged; 846 } 847 848 protected: 849 unsigned short getSubclassDataFromValue() const { return SubclassData; } 850 void setValueSubclassData(unsigned short D) { SubclassData = D; } 851 }; 852 853 struct ValueDeleter { void operator()(Value *V) { V->deleteValue(); } }; 854 855 /// Use this instead of std::unique_ptr<Value> or std::unique_ptr<Instruction>. 856 /// Those don't work because Value and Instruction's destructors are protected, 857 /// aren't virtual, and won't destroy the complete object. 858 using unique_value = std::unique_ptr<Value, ValueDeleter>; 859 860 inline raw_ostream &operator<<(raw_ostream &OS, const Value &V) { 861 V.print(OS); 862 return OS; 863 } 864 865 void Use::set(Value *V) { 866 if (Val) removeFromList(); 867 Val = V; 868 if (V) V->addUse(*this); 869 } 870 871 Value *Use::operator=(Value *RHS) { 872 set(RHS); 873 return RHS; 874 } 875 876 const Use &Use::operator=(const Use &RHS) { 877 set(RHS.Val); 878 return *this; 879 } 880 881 template <class Compare> void Value::sortUseList(Compare Cmp) { 882 if (!UseList || !UseList->Next) 883 // No need to sort 0 or 1 uses. 884 return; 885 886 // Note: this function completely ignores Prev pointers until the end when 887 // they're fixed en masse. 888 889 // Create a binomial vector of sorted lists, visiting uses one at a time and 890 // merging lists as necessary. 891 const unsigned MaxSlots = 32; 892 Use *Slots[MaxSlots]; 893 894 // Collect the first use, turning it into a single-item list. 895 Use *Next = UseList->Next; 896 UseList->Next = nullptr; 897 unsigned NumSlots = 1; 898 Slots[0] = UseList; 899 900 // Collect all but the last use. 901 while (Next->Next) { 902 Use *Current = Next; 903 Next = Current->Next; 904 905 // Turn Current into a single-item list. 906 Current->Next = nullptr; 907 908 // Save Current in the first available slot, merging on collisions. 909 unsigned I; 910 for (I = 0; I < NumSlots; ++I) { 911 if (!Slots[I]) 912 break; 913 914 // Merge two lists, doubling the size of Current and emptying slot I. 915 // 916 // Since the uses in Slots[I] originally preceded those in Current, send 917 // Slots[I] in as the left parameter to maintain a stable sort. 918 Current = mergeUseLists(Slots[I], Current, Cmp); 919 Slots[I] = nullptr; 920 } 921 // Check if this is a new slot. 922 if (I == NumSlots) { 923 ++NumSlots; 924 assert(NumSlots <= MaxSlots && "Use list bigger than 2^32"); 925 } 926 927 // Found an open slot. 928 Slots[I] = Current; 929 } 930 931 // Merge all the lists together. 932 assert(Next && "Expected one more Use"); 933 assert(!Next->Next && "Expected only one Use"); 934 UseList = Next; 935 for (unsigned I = 0; I < NumSlots; ++I) 936 if (Slots[I]) 937 // Since the uses in Slots[I] originally preceded those in UseList, send 938 // Slots[I] in as the left parameter to maintain a stable sort. 939 UseList = mergeUseLists(Slots[I], UseList, Cmp); 940 941 // Fix the Prev pointers. 942 for (Use *I = UseList, **Prev = &UseList; I; I = I->Next) { 943 I->Prev = Prev; 944 Prev = &I->Next; 945 } 946 } 947 948 // isa - Provide some specializations of isa so that we don't have to include 949 // the subtype header files to test to see if the value is a subclass... 950 // 951 template <> struct isa_impl<Constant, Value> { 952 static inline bool doit(const Value &Val) { 953 static_assert(Value::ConstantFirstVal == 0, "Val.getValueID() >= Value::ConstantFirstVal"); 954 return Val.getValueID() <= Value::ConstantLastVal; 955 } 956 }; 957 958 template <> struct isa_impl<ConstantData, Value> { 959 static inline bool doit(const Value &Val) { 960 return Val.getValueID() >= Value::ConstantDataFirstVal && 961 Val.getValueID() <= Value::ConstantDataLastVal; 962 } 963 }; 964 965 template <> struct isa_impl<ConstantAggregate, Value> { 966 static inline bool doit(const Value &Val) { 967 return Val.getValueID() >= Value::ConstantAggregateFirstVal && 968 Val.getValueID() <= Value::ConstantAggregateLastVal; 969 } 970 }; 971 972 template <> struct isa_impl<Argument, Value> { 973 static inline bool doit (const Value &Val) { 974 return Val.getValueID() == Value::ArgumentVal; 975 } 976 }; 977 978 template <> struct isa_impl<InlineAsm, Value> { 979 static inline bool doit(const Value &Val) { 980 return Val.getValueID() == Value::InlineAsmVal; 981 } 982 }; 983 984 template <> struct isa_impl<Instruction, Value> { 985 static inline bool doit(const Value &Val) { 986 return Val.getValueID() >= Value::InstructionVal; 987 } 988 }; 989 990 template <> struct isa_impl<BasicBlock, Value> { 991 static inline bool doit(const Value &Val) { 992 return Val.getValueID() == Value::BasicBlockVal; 993 } 994 }; 995 996 template <> struct isa_impl<Function, Value> { 997 static inline bool doit(const Value &Val) { 998 return Val.getValueID() == Value::FunctionVal; 999 } 1000 }; 1001 1002 template <> struct isa_impl<GlobalVariable, Value> { 1003 static inline bool doit(const Value &Val) { 1004 return Val.getValueID() == Value::GlobalVariableVal; 1005 } 1006 }; 1007 1008 template <> struct isa_impl<GlobalAlias, Value> { 1009 static inline bool doit(const Value &Val) { 1010 return Val.getValueID() == Value::GlobalAliasVal; 1011 } 1012 }; 1013 1014 template <> struct isa_impl<GlobalIFunc, Value> { 1015 static inline bool doit(const Value &Val) { 1016 return Val.getValueID() == Value::GlobalIFuncVal; 1017 } 1018 }; 1019 1020 template <> struct isa_impl<GlobalValue, Value> { 1021 static inline bool doit(const Value &Val) { 1022 return isa<GlobalObject>(Val) || isa<GlobalAlias>(Val); 1023 } 1024 }; 1025 1026 template <> struct isa_impl<GlobalObject, Value> { 1027 static inline bool doit(const Value &Val) { 1028 return isa<GlobalVariable>(Val) || isa<Function>(Val) || 1029 isa<GlobalIFunc>(Val); 1030 } 1031 }; 1032 1033 // Create wrappers for C Binding types (see CBindingWrapping.h). 1034 DEFINE_ISA_CONVERSION_FUNCTIONS(Value, LLVMValueRef) 1035 1036 // Specialized opaque value conversions. 1037 inline Value **unwrap(LLVMValueRef *Vals) { 1038 return reinterpret_cast<Value**>(Vals); 1039 } 1040 1041 template<typename T> 1042 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) { 1043 #ifndef NDEBUG 1044 for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I) 1045 unwrap<T>(*I); // For side effect of calling assert on invalid usage. 1046 #endif 1047 (void)Length; 1048 return reinterpret_cast<T**>(Vals); 1049 } 1050 1051 inline LLVMValueRef *wrap(const Value **Vals) { 1052 return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals)); 1053 } 1054 1055 } // end namespace llvm 1056 1057 #endif // LLVM_IR_VALUE_H 1058