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