| //===- llvm/Value.h - Definition of the Value class -------------*- C++ -*-===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file declares the Value class. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLVM_IR_VALUE_H |
| #define LLVM_IR_VALUE_H |
| |
| #include "llvm-c/Types.h" |
| #include "llvm/ADT/STLExtras.h" |
| #include "llvm/ADT/StringRef.h" |
| #include "llvm/ADT/iterator_range.h" |
| #include "llvm/IR/Use.h" |
| #include "llvm/Support/Alignment.h" |
| #include "llvm/Support/CBindingWrapping.h" |
| #include "llvm/Support/Casting.h" |
| #include <cassert> |
| #include <iterator> |
| #include <memory> |
| |
| namespace llvm { |
| |
| class APInt; |
| class Argument; |
| class BasicBlock; |
| class Constant; |
| class ConstantData; |
| class ConstantAggregate; |
| class DataLayout; |
| class Function; |
| class GlobalAlias; |
| class GlobalIFunc; |
| class GlobalObject; |
| class GlobalValue; |
| class GlobalVariable; |
| class InlineAsm; |
| class Instruction; |
| class LLVMContext; |
| class MDNode; |
| class Module; |
| class ModuleSlotTracker; |
| class raw_ostream; |
| template<typename ValueTy> class StringMapEntry; |
| class Twine; |
| class Type; |
| class User; |
| |
| using ValueName = StringMapEntry<Value *>; |
| |
| //===----------------------------------------------------------------------===// |
| // Value Class |
| //===----------------------------------------------------------------------===// |
| |
| /// LLVM Value Representation |
| /// |
| /// This is a very important LLVM class. It is the base class of all values |
| /// computed by a program that may be used as operands to other values. Value is |
| /// the super class of other important classes such as Instruction and Function. |
| /// All Values have a Type. Type is not a subclass of Value. Some values can |
| /// have a name and they belong to some Module. Setting the name on the Value |
| /// automatically updates the module's symbol table. |
| /// |
| /// Every value has a "use list" that keeps track of which other Values are |
| /// using this Value. A Value can also have an arbitrary number of ValueHandle |
| /// objects that watch it and listen to RAUW and Destroy events. See |
| /// llvm/IR/ValueHandle.h for details. |
| class Value { |
| Type *VTy; |
| Use *UseList; |
| |
| friend class ValueAsMetadata; // Allow access to IsUsedByMD. |
| friend class ValueHandleBase; |
| |
| const unsigned char SubclassID; // Subclass identifier (for isa/dyn_cast) |
| unsigned char HasValueHandle : 1; // Has a ValueHandle pointing to this? |
| |
| protected: |
| /// Hold subclass data that can be dropped. |
| /// |
| /// This member is similar to SubclassData, however it is for holding |
| /// information which may be used to aid optimization, but which may be |
| /// cleared to zero without affecting conservative interpretation. |
| unsigned char SubclassOptionalData : 7; |
| |
| private: |
| /// Hold arbitrary subclass data. |
| /// |
| /// This member is defined by this class, but is not used for anything. |
| /// Subclasses can use it to hold whatever state they find useful. This |
| /// field is initialized to zero by the ctor. |
| unsigned short SubclassData; |
| |
| protected: |
| /// The number of operands in the subclass. |
| /// |
| /// This member is defined by this class, but not used for anything. |
| /// Subclasses can use it to store their number of operands, if they have |
| /// any. |
| /// |
| /// This is stored here to save space in User on 64-bit hosts. Since most |
| /// instances of Value have operands, 32-bit hosts aren't significantly |
| /// affected. |
| /// |
| /// Note, this should *NOT* be used directly by any class other than User. |
| /// User uses this value to find the Use list. |
| enum : unsigned { NumUserOperandsBits = 27 }; |
| unsigned NumUserOperands : NumUserOperandsBits; |
| |
| // Use the same type as the bitfield above so that MSVC will pack them. |
| unsigned IsUsedByMD : 1; |
| unsigned HasName : 1; |
| unsigned HasMetadata : 1; // Has metadata attached to this? |
| unsigned HasHungOffUses : 1; |
| unsigned HasDescriptor : 1; |
| |
| private: |
| template <typename UseT> // UseT == 'Use' or 'const Use' |
| class use_iterator_impl { |
| friend class Value; |
| |
| UseT *U; |
| |
| explicit use_iterator_impl(UseT *u) : U(u) {} |
| |
| public: |
| using iterator_category = std::forward_iterator_tag; |
| using value_type = UseT *; |
| using difference_type = std::ptrdiff_t; |
| using pointer = value_type *; |
| using reference = value_type &; |
| |
| use_iterator_impl() : U() {} |
| |
| bool operator==(const use_iterator_impl &x) const { return U == x.U; } |
| bool operator!=(const use_iterator_impl &x) const { return !operator==(x); } |
| |
| use_iterator_impl &operator++() { // Preincrement |
| assert(U && "Cannot increment end iterator!"); |
| U = U->getNext(); |
| return *this; |
| } |
| |
| use_iterator_impl operator++(int) { // Postincrement |
| auto tmp = *this; |
| ++*this; |
| return tmp; |
| } |
| |
| UseT &operator*() const { |
| assert(U && "Cannot dereference end iterator!"); |
| return *U; |
| } |
| |
| UseT *operator->() const { return &operator*(); } |
| |
| operator use_iterator_impl<const UseT>() const { |
| return use_iterator_impl<const UseT>(U); |
| } |
| }; |
| |
| template <typename UserTy> // UserTy == 'User' or 'const User' |
| class user_iterator_impl { |
| use_iterator_impl<Use> UI; |
| explicit user_iterator_impl(Use *U) : UI(U) {} |
| friend class Value; |
| |
| public: |
| using iterator_category = std::forward_iterator_tag; |
| using value_type = UserTy *; |
| using difference_type = std::ptrdiff_t; |
| using pointer = value_type *; |
| using reference = value_type &; |
| |
| user_iterator_impl() = default; |
| |
| bool operator==(const user_iterator_impl &x) const { return UI == x.UI; } |
| bool operator!=(const user_iterator_impl &x) const { return !operator==(x); } |
| |
| /// Returns true if this iterator is equal to user_end() on the value. |
| bool atEnd() const { return *this == user_iterator_impl(); } |
| |
| user_iterator_impl &operator++() { // Preincrement |
| ++UI; |
| return *this; |
| } |
| |
| user_iterator_impl operator++(int) { // Postincrement |
| auto tmp = *this; |
| ++*this; |
| return tmp; |
| } |
| |
| // Retrieve a pointer to the current User. |
| UserTy *operator*() const { |
| return UI->getUser(); |
| } |
| |
| UserTy *operator->() const { return operator*(); } |
| |
| operator user_iterator_impl<const UserTy>() const { |
| return user_iterator_impl<const UserTy>(*UI); |
| } |
| |
| Use &getUse() const { return *UI; } |
| }; |
| |
| protected: |
| Value(Type *Ty, unsigned scid); |
| |
| /// Value's destructor should be virtual by design, but that would require |
| /// that Value and all of its subclasses have a vtable that effectively |
| /// duplicates the information in the value ID. As a size optimization, the |
| /// destructor has been protected, and the caller should manually call |
| /// deleteValue. |
| ~Value(); // Use deleteValue() to delete a generic Value. |
| |
| public: |
| Value(const Value &) = delete; |
| Value &operator=(const Value &) = delete; |
| |
| /// Delete a pointer to a generic Value. |
| void deleteValue(); |
| |
| /// Support for debugging, callable in GDB: V->dump() |
| void dump() const; |
| |
| /// Implement operator<< on Value. |
| /// @{ |
| void print(raw_ostream &O, bool IsForDebug = false) const; |
| void print(raw_ostream &O, ModuleSlotTracker &MST, |
| bool IsForDebug = false) const; |
| /// @} |
| |
| /// Print the name of this Value out to the specified raw_ostream. |
| /// |
| /// This is useful when you just want to print 'int %reg126', not the |
| /// instruction that generated it. If you specify a Module for context, then |
| /// even constanst get pretty-printed; for example, the type of a null |
| /// pointer is printed symbolically. |
| /// @{ |
| void printAsOperand(raw_ostream &O, bool PrintType = true, |
| const Module *M = nullptr) const; |
| void printAsOperand(raw_ostream &O, bool PrintType, |
| ModuleSlotTracker &MST) const; |
| /// @} |
| |
| /// All values are typed, get the type of this value. |
| Type *getType() const { return VTy; } |
| |
| /// All values hold a context through their type. |
| LLVMContext &getContext() const; |
| |
| // All values can potentially be named. |
| bool hasName() const { return HasName; } |
| ValueName *getValueName() const; |
| void setValueName(ValueName *VN); |
| |
| private: |
| void destroyValueName(); |
| enum class ReplaceMetadataUses { No, Yes }; |
| void doRAUW(Value *New, ReplaceMetadataUses); |
| void setNameImpl(const Twine &Name); |
| |
| public: |
| /// Return a constant reference to the value's name. |
| /// |
| /// This guaranteed to return the same reference as long as the value is not |
| /// modified. If the value has a name, this does a hashtable lookup, so it's |
| /// not free. |
| StringRef getName() const; |
| |
| /// Change the name of the value. |
| /// |
| /// Choose a new unique name if the provided name is taken. |
| /// |
| /// \param Name The new name; or "" if the value's name should be removed. |
| void setName(const Twine &Name); |
| |
| /// Transfer the name from V to this value. |
| /// |
| /// After taking V's name, sets V's name to empty. |
| /// |
| /// \note It is an error to call V->takeName(V). |
| void takeName(Value *V); |
| |
| #ifndef NDEBUG |
| std::string getNameOrAsOperand() const; |
| #endif |
| |
| /// Change all uses of this to point to a new Value. |
| /// |
| /// Go through the uses list for this definition and make each use point to |
| /// "V" instead of "this". After this completes, 'this's use list is |
| /// guaranteed to be empty. |
| void replaceAllUsesWith(Value *V); |
| |
| /// Change non-metadata uses of this to point to a new Value. |
| /// |
| /// Go through the uses list for this definition and make each use point to |
| /// "V" instead of "this". This function skips metadata entries in the list. |
| void replaceNonMetadataUsesWith(Value *V); |
| |
| /// Go through the uses list for this definition and make each use point |
| /// to "V" if the callback ShouldReplace returns true for the given Use. |
| /// Unlike replaceAllUsesWith() this function does not support basic block |
| /// values. |
| void replaceUsesWithIf(Value *New, |
| llvm::function_ref<bool(Use &U)> ShouldReplace); |
| |
| /// replaceUsesOutsideBlock - Go through the uses list for this definition and |
| /// make each use point to "V" instead of "this" when the use is outside the |
| /// block. 'This's use list is expected to have at least one element. |
| /// Unlike replaceAllUsesWith() this function does not support basic block |
| /// values. |
| void replaceUsesOutsideBlock(Value *V, BasicBlock *BB); |
| |
| //---------------------------------------------------------------------- |
| // Methods for handling the chain of uses of this Value. |
| // |
| // Materializing a function can introduce new uses, so these methods come in |
| // two variants: |
| // The methods that start with materialized_ check the uses that are |
| // currently known given which functions are materialized. Be very careful |
| // when using them since you might not get all uses. |
| // The methods that don't start with materialized_ assert that modules is |
| // fully materialized. |
| void assertModuleIsMaterializedImpl() const; |
| // This indirection exists so we can keep assertModuleIsMaterializedImpl() |
| // around in release builds of Value.cpp to be linked with other code built |
| // in debug mode. But this avoids calling it in any of the release built code. |
| void assertModuleIsMaterialized() const { |
| #ifndef NDEBUG |
| assertModuleIsMaterializedImpl(); |
| #endif |
| } |
| |
| bool use_empty() const { |
| assertModuleIsMaterialized(); |
| return UseList == nullptr; |
| } |
| |
| bool materialized_use_empty() const { |
| return UseList == nullptr; |
| } |
| |
| using use_iterator = use_iterator_impl<Use>; |
| using const_use_iterator = use_iterator_impl<const Use>; |
| |
| use_iterator materialized_use_begin() { return use_iterator(UseList); } |
| const_use_iterator materialized_use_begin() const { |
| return const_use_iterator(UseList); |
| } |
| use_iterator use_begin() { |
| assertModuleIsMaterialized(); |
| return materialized_use_begin(); |
| } |
| const_use_iterator use_begin() const { |
| assertModuleIsMaterialized(); |
| return materialized_use_begin(); |
| } |
| use_iterator use_end() { return use_iterator(); } |
| const_use_iterator use_end() const { return const_use_iterator(); } |
| iterator_range<use_iterator> materialized_uses() { |
| return make_range(materialized_use_begin(), use_end()); |
| } |
| iterator_range<const_use_iterator> materialized_uses() const { |
| return make_range(materialized_use_begin(), use_end()); |
| } |
| iterator_range<use_iterator> uses() { |
| assertModuleIsMaterialized(); |
| return materialized_uses(); |
| } |
| iterator_range<const_use_iterator> uses() const { |
| assertModuleIsMaterialized(); |
| return materialized_uses(); |
| } |
| |
| bool user_empty() const { |
| assertModuleIsMaterialized(); |
| return UseList == nullptr; |
| } |
| |
| using user_iterator = user_iterator_impl<User>; |
| using const_user_iterator = user_iterator_impl<const User>; |
| |
| user_iterator materialized_user_begin() { return user_iterator(UseList); } |
| const_user_iterator materialized_user_begin() const { |
| return const_user_iterator(UseList); |
| } |
| user_iterator user_begin() { |
| assertModuleIsMaterialized(); |
| return materialized_user_begin(); |
| } |
| const_user_iterator user_begin() const { |
| assertModuleIsMaterialized(); |
| return materialized_user_begin(); |
| } |
| user_iterator user_end() { return user_iterator(); } |
| const_user_iterator user_end() const { return const_user_iterator(); } |
| User *user_back() { |
| assertModuleIsMaterialized(); |
| return *materialized_user_begin(); |
| } |
| const User *user_back() const { |
| assertModuleIsMaterialized(); |
| return *materialized_user_begin(); |
| } |
| iterator_range<user_iterator> materialized_users() { |
| return make_range(materialized_user_begin(), user_end()); |
| } |
| iterator_range<const_user_iterator> materialized_users() const { |
| return make_range(materialized_user_begin(), user_end()); |
| } |
| iterator_range<user_iterator> users() { |
| assertModuleIsMaterialized(); |
| return materialized_users(); |
| } |
| iterator_range<const_user_iterator> users() const { |
| assertModuleIsMaterialized(); |
| return materialized_users(); |
| } |
| |
| /// Return true if there is exactly one use of this value. |
| /// |
| /// This is specialized because it is a common request and does not require |
| /// traversing the whole use list. |
| bool hasOneUse() const { return hasSingleElement(uses()); } |
| |
| /// Return true if this Value has exactly N uses. |
| bool hasNUses(unsigned N) const; |
| |
| /// Return true if this value has N uses or more. |
| /// |
| /// This is logically equivalent to getNumUses() >= N. |
| bool hasNUsesOrMore(unsigned N) const; |
| |
| /// Return true if there is exactly one user of this value. |
| /// |
| /// Note that this is not the same as "has one use". If a value has one use, |
| /// then there certainly is a single user. But if value has several uses, |
| /// it is possible that all uses are in a single user, or not. |
| /// |
| /// This check is potentially costly, since it requires traversing, |
| /// in the worst case, the whole use list of a value. |
| bool hasOneUser() const; |
| |
| /// Return true if there is exactly one use of this value that cannot be |
| /// dropped. |
| Use *getSingleUndroppableUse(); |
| const Use *getSingleUndroppableUse() const { |
| return const_cast<Value *>(this)->getSingleUndroppableUse(); |
| } |
| |
| /// Return true if there is exactly one unique user of this value that cannot be |
| /// dropped (that user can have multiple uses of this value). |
| User *getUniqueUndroppableUser(); |
| const User *getUniqueUndroppableUser() const { |
| return const_cast<Value *>(this)->getUniqueUndroppableUser(); |
| } |
| |
| /// Return true if there this value. |
| /// |
| /// This is specialized because it is a common request and does not require |
| /// traversing the whole use list. |
| bool hasNUndroppableUses(unsigned N) const; |
| |
| /// Return true if this value has N uses or more. |
| /// |
| /// This is logically equivalent to getNumUses() >= N. |
| bool hasNUndroppableUsesOrMore(unsigned N) const; |
| |
| /// Remove every uses that can safely be removed. |
| /// |
| /// This will remove for example uses in llvm.assume. |
| /// This should be used when performing want to perform a tranformation but |
| /// some Droppable uses pervent it. |
| /// This function optionally takes a filter to only remove some droppable |
| /// uses. |
| void dropDroppableUses(llvm::function_ref<bool(const Use *)> ShouldDrop = |
| [](const Use *) { return true; }); |
| |
| /// Remove every use of this value in \p User that can safely be removed. |
| void dropDroppableUsesIn(User &Usr); |
| |
| /// Remove the droppable use \p U. |
| static void dropDroppableUse(Use &U); |
| |
| /// Check if this value is used in the specified basic block. |
| bool isUsedInBasicBlock(const BasicBlock *BB) const; |
| |
| /// This method computes the number of uses of this Value. |
| /// |
| /// This is a linear time operation. Use hasOneUse, hasNUses, or |
| /// hasNUsesOrMore to check for specific values. |
| unsigned getNumUses() const; |
| |
| /// This method should only be used by the Use class. |
| void addUse(Use &U) { U.addToList(&UseList); } |
| |
| /// Concrete subclass of this. |
| /// |
| /// An enumeration for keeping track of the concrete subclass of Value that |
| /// is actually instantiated. Values of this enumeration are kept in the |
| /// Value classes SubclassID field. They are used for concrete type |
| /// identification. |
| enum ValueTy { |
| #define HANDLE_VALUE(Name) Name##Val, |
| #include "llvm/IR/Value.def" |
| |
| // Markers: |
| #define HANDLE_CONSTANT_MARKER(Marker, Constant) Marker = Constant##Val, |
| #include "llvm/IR/Value.def" |
| }; |
| |
| /// Return an ID for the concrete type of this object. |
| /// |
| /// This is used to implement the classof checks. This should not be used |
| /// for any other purpose, as the values may change as LLVM evolves. Also, |
| /// note that for instructions, the Instruction's opcode is added to |
| /// InstructionVal. So this means three things: |
| /// # there is no value with code InstructionVal (no opcode==0). |
| /// # there are more possible values for the value type than in ValueTy enum. |
| /// # the InstructionVal enumerator must be the highest valued enumerator in |
| /// the ValueTy enum. |
| unsigned getValueID() const { |
| return SubclassID; |
| } |
| |
| /// Return the raw optional flags value contained in this value. |
| /// |
| /// This should only be used when testing two Values for equivalence. |
| unsigned getRawSubclassOptionalData() const { |
| return SubclassOptionalData; |
| } |
| |
| /// Clear the optional flags contained in this value. |
| void clearSubclassOptionalData() { |
| SubclassOptionalData = 0; |
| } |
| |
| /// Check the optional flags for equality. |
| bool hasSameSubclassOptionalData(const Value *V) const { |
| return SubclassOptionalData == V->SubclassOptionalData; |
| } |
| |
| /// Return true if there is a value handle associated with this value. |
| bool hasValueHandle() const { return HasValueHandle; } |
| |
| /// Return true if there is metadata referencing this value. |
| bool isUsedByMetadata() const { return IsUsedByMD; } |
| |
| // Return true if this value is only transitively referenced by metadata. |
| bool isTransitiveUsedByMetadataOnly() const; |
| |
| protected: |
| /// Get the current metadata attachments for the given kind, if any. |
| /// |
| /// These functions require that the value have at most a single attachment |
| /// of the given kind, and return \c nullptr if such an attachment is missing. |
| /// @{ |
| MDNode *getMetadata(unsigned KindID) const; |
| MDNode *getMetadata(StringRef Kind) const; |
| /// @} |
| |
| /// Appends all attachments with the given ID to \c MDs in insertion order. |
| /// If the Value has no attachments with the given ID, or if ID is invalid, |
| /// leaves MDs unchanged. |
| /// @{ |
| void getMetadata(unsigned KindID, SmallVectorImpl<MDNode *> &MDs) const; |
| void getMetadata(StringRef Kind, SmallVectorImpl<MDNode *> &MDs) const; |
| /// @} |
| |
| /// Appends all metadata attached to this value to \c MDs, sorting by |
| /// KindID. The first element of each pair returned is the KindID, the second |
| /// element is the metadata value. Attachments with the same ID appear in |
| /// insertion order. |
| void |
| getAllMetadata(SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const; |
| |
| /// Return true if this value has any metadata attached to it. |
| bool hasMetadata() const { return (bool)HasMetadata; } |
| |
| /// Return true if this value has the given type of metadata attached. |
| /// @{ |
| bool hasMetadata(unsigned KindID) const { |
| return getMetadata(KindID) != nullptr; |
| } |
| bool hasMetadata(StringRef Kind) const { |
| return getMetadata(Kind) != nullptr; |
| } |
| /// @} |
| |
| /// Set a particular kind of metadata attachment. |
| /// |
| /// Sets the given attachment to \c MD, erasing it if \c MD is \c nullptr or |
| /// replacing it if it already exists. |
| /// @{ |
| void setMetadata(unsigned KindID, MDNode *Node); |
| void setMetadata(StringRef Kind, MDNode *Node); |
| /// @} |
| |
| /// Add a metadata attachment. |
| /// @{ |
| void addMetadata(unsigned KindID, MDNode &MD); |
| void addMetadata(StringRef Kind, MDNode &MD); |
| /// @} |
| |
| /// Erase all metadata attachments with the given kind. |
| /// |
| /// \returns true if any metadata was removed. |
| bool eraseMetadata(unsigned KindID); |
| |
| /// Erase all metadata attached to this Value. |
| void clearMetadata(); |
| |
| public: |
| /// Return true if this value is a swifterror value. |
| /// |
| /// swifterror values can be either a function argument or an alloca with a |
| /// swifterror attribute. |
| bool isSwiftError() const; |
| |
| /// Strip off pointer casts, all-zero GEPs and address space casts. |
| /// |
| /// Returns the original uncasted value. If this is called on a non-pointer |
| /// value, it returns 'this'. |
| const Value *stripPointerCasts() const; |
| Value *stripPointerCasts() { |
| return const_cast<Value *>( |
| static_cast<const Value *>(this)->stripPointerCasts()); |
| } |
| |
| /// Strip off pointer casts, all-zero GEPs, address space casts, and aliases. |
| /// |
| /// Returns the original uncasted value. If this is called on a non-pointer |
| /// value, it returns 'this'. |
| const Value *stripPointerCastsAndAliases() const; |
| Value *stripPointerCastsAndAliases() { |
| return const_cast<Value *>( |
| static_cast<const Value *>(this)->stripPointerCastsAndAliases()); |
| } |
| |
| /// Strip off pointer casts, all-zero GEPs and address space casts |
| /// but ensures the representation of the result stays the same. |
| /// |
| /// Returns the original uncasted value with the same representation. If this |
| /// is called on a non-pointer value, it returns 'this'. |
| const Value *stripPointerCastsSameRepresentation() const; |
| Value *stripPointerCastsSameRepresentation() { |
| return const_cast<Value *>(static_cast<const Value *>(this) |
| ->stripPointerCastsSameRepresentation()); |
| } |
| |
| /// Strip off pointer casts, all-zero GEPs, single-argument phi nodes and |
| /// invariant group info. |
| /// |
| /// Returns the original uncasted value. If this is called on a non-pointer |
| /// value, it returns 'this'. This function should be used only in |
| /// Alias analysis. |
| const Value *stripPointerCastsForAliasAnalysis() const; |
| Value *stripPointerCastsForAliasAnalysis() { |
| return const_cast<Value *>(static_cast<const Value *>(this) |
| ->stripPointerCastsForAliasAnalysis()); |
| } |
| |
| /// Strip off pointer casts and all-constant inbounds GEPs. |
| /// |
| /// Returns the original pointer value. If this is called on a non-pointer |
| /// value, it returns 'this'. |
| const Value *stripInBoundsConstantOffsets() const; |
| Value *stripInBoundsConstantOffsets() { |
| return const_cast<Value *>( |
| static_cast<const Value *>(this)->stripInBoundsConstantOffsets()); |
| } |
| |
| /// Accumulate the constant offset this value has compared to a base pointer. |
| /// Only 'getelementptr' instructions (GEPs) are accumulated but other |
| /// instructions, e.g., casts, are stripped away as well. |
| /// The accumulated constant offset is added to \p Offset and the base |
| /// pointer is returned. |
| /// |
| /// The APInt \p Offset has to have a bit-width equal to the IntPtr type for |
| /// the address space of 'this' pointer value, e.g., use |
| /// DataLayout::getIndexTypeSizeInBits(Ty). |
| /// |
| /// If \p AllowNonInbounds is true, offsets in GEPs are stripped and |
| /// accumulated even if the GEP is not "inbounds". |
| /// |
| /// If \p AllowInvariantGroup is true then this method also looks through |
| /// strip.invariant.group and launder.invariant.group intrinsics. |
| /// |
| /// If \p ExternalAnalysis is provided it will be used to calculate a offset |
| /// when a operand of GEP is not constant. |
| /// For example, for a value \p ExternalAnalysis might try to calculate a |
| /// lower bound. If \p ExternalAnalysis is successful, it should return true. |
| /// |
| /// If this is called on a non-pointer value, it returns 'this' and the |
| /// \p Offset is not modified. |
| /// |
| /// Note that this function will never return a nullptr. It will also never |
| /// manipulate the \p Offset in a way that would not match the difference |
| /// between the underlying value and the returned one. Thus, if no constant |
| /// offset was found, the returned value is the underlying one and \p Offset |
| /// is unchanged. |
| const Value *stripAndAccumulateConstantOffsets( |
| const DataLayout &DL, APInt &Offset, bool AllowNonInbounds, |
| bool AllowInvariantGroup = false, |
| function_ref<bool(Value &Value, APInt &Offset)> ExternalAnalysis = |
| nullptr) const; |
| Value *stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset, |
| bool AllowNonInbounds, |
| bool AllowInvariantGroup = false) { |
| return const_cast<Value *>( |
| static_cast<const Value *>(this)->stripAndAccumulateConstantOffsets( |
| DL, Offset, AllowNonInbounds, AllowInvariantGroup)); |
| } |
| |
| /// This is a wrapper around stripAndAccumulateConstantOffsets with the |
| /// in-bounds requirement set to false. |
| const Value *stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL, |
| APInt &Offset) const { |
| return stripAndAccumulateConstantOffsets(DL, Offset, |
| /* AllowNonInbounds */ false); |
| } |
| Value *stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL, |
| APInt &Offset) { |
| return stripAndAccumulateConstantOffsets(DL, Offset, |
| /* AllowNonInbounds */ false); |
| } |
| |
| /// Strip off pointer casts and inbounds GEPs. |
| /// |
| /// Returns the original pointer value. If this is called on a non-pointer |
| /// value, it returns 'this'. |
| const Value *stripInBoundsOffsets(function_ref<void(const Value *)> Func = |
| [](const Value *) {}) const; |
| inline Value *stripInBoundsOffsets(function_ref<void(const Value *)> Func = |
| [](const Value *) {}) { |
| return const_cast<Value *>( |
| static_cast<const Value *>(this)->stripInBoundsOffsets(Func)); |
| } |
| |
| /// Return true if the memory object referred to by V can by freed in the |
| /// scope for which the SSA value defining the allocation is statically |
| /// defined. E.g. deallocation after the static scope of a value does not |
| /// count, but a deallocation before that does. |
| bool canBeFreed() const; |
| |
| /// Returns the number of bytes known to be dereferenceable for the |
| /// pointer value. |
| /// |
| /// If CanBeNull is set by this function the pointer can either be null or be |
| /// dereferenceable up to the returned number of bytes. |
| /// |
| /// IF CanBeFreed is true, the pointer is known to be dereferenceable at |
| /// point of definition only. Caller must prove that allocation is not |
| /// deallocated between point of definition and use. |
| uint64_t getPointerDereferenceableBytes(const DataLayout &DL, |
| bool &CanBeNull, |
| bool &CanBeFreed) const; |
| |
| /// Returns an alignment of the pointer value. |
| /// |
| /// Returns an alignment which is either specified explicitly, e.g. via |
| /// align attribute of a function argument, or guaranteed by DataLayout. |
| Align getPointerAlignment(const DataLayout &DL) const; |
| |
| /// Translate PHI node to its predecessor from the given basic block. |
| /// |
| /// If this value is a PHI node with CurBB as its parent, return the value in |
| /// the PHI node corresponding to PredBB. If not, return ourself. This is |
| /// useful if you want to know the value something has in a predecessor |
| /// block. |
| const Value *DoPHITranslation(const BasicBlock *CurBB, |
| const BasicBlock *PredBB) const; |
| Value *DoPHITranslation(const BasicBlock *CurBB, const BasicBlock *PredBB) { |
| return const_cast<Value *>( |
| static_cast<const Value *>(this)->DoPHITranslation(CurBB, PredBB)); |
| } |
| |
| /// The maximum alignment for instructions. |
| /// |
| /// This is the greatest alignment value supported by load, store, and alloca |
| /// instructions, and global values. |
| static constexpr unsigned MaxAlignmentExponent = 32; |
| static constexpr uint64_t MaximumAlignment = 1ULL << MaxAlignmentExponent; |
| |
| /// Mutate the type of this Value to be of the specified type. |
| /// |
| /// Note that this is an extremely dangerous operation which can create |
| /// completely invalid IR very easily. It is strongly recommended that you |
| /// recreate IR objects with the right types instead of mutating them in |
| /// place. |
| void mutateType(Type *Ty) { |
| VTy = Ty; |
| } |
| |
| /// Sort the use-list. |
| /// |
| /// Sorts the Value's use-list by Cmp using a stable mergesort. Cmp is |
| /// expected to compare two \a Use references. |
| template <class Compare> void sortUseList(Compare Cmp); |
| |
| /// Reverse the use-list. |
| void reverseUseList(); |
| |
| private: |
| /// Merge two lists together. |
| /// |
| /// Merges \c L and \c R using \c Cmp. To enable stable sorts, always pushes |
| /// "equal" items from L before items from R. |
| /// |
| /// \return the first element in the list. |
| /// |
| /// \note Completely ignores \a Use::Prev (doesn't read, doesn't update). |
| template <class Compare> |
| static Use *mergeUseLists(Use *L, Use *R, Compare Cmp) { |
| Use *Merged; |
| Use **Next = &Merged; |
| |
| while (true) { |
| if (!L) { |
| *Next = R; |
| break; |
| } |
| if (!R) { |
| *Next = L; |
| break; |
| } |
| if (Cmp(*R, *L)) { |
| *Next = R; |
| Next = &R->Next; |
| R = R->Next; |
| } else { |
| *Next = L; |
| Next = &L->Next; |
| L = L->Next; |
| } |
| } |
| |
| return Merged; |
| } |
| |
| protected: |
| unsigned short getSubclassDataFromValue() const { return SubclassData; } |
| void setValueSubclassData(unsigned short D) { SubclassData = D; } |
| }; |
| |
| struct ValueDeleter { void operator()(Value *V) { V->deleteValue(); } }; |
| |
| /// Use this instead of std::unique_ptr<Value> or std::unique_ptr<Instruction>. |
| /// Those don't work because Value and Instruction's destructors are protected, |
| /// aren't virtual, and won't destroy the complete object. |
| using unique_value = std::unique_ptr<Value, ValueDeleter>; |
| |
| inline raw_ostream &operator<<(raw_ostream &OS, const Value &V) { |
| V.print(OS); |
| return OS; |
| } |
| |
| void Use::set(Value *V) { |
| if (Val) removeFromList(); |
| Val = V; |
| if (V) V->addUse(*this); |
| } |
| |
| Value *Use::operator=(Value *RHS) { |
| set(RHS); |
| return RHS; |
| } |
| |
| const Use &Use::operator=(const Use &RHS) { |
| set(RHS.Val); |
| return *this; |
| } |
| |
| template <class Compare> void Value::sortUseList(Compare Cmp) { |
| if (!UseList || !UseList->Next) |
| // No need to sort 0 or 1 uses. |
| return; |
| |
| // Note: this function completely ignores Prev pointers until the end when |
| // they're fixed en masse. |
| |
| // Create a binomial vector of sorted lists, visiting uses one at a time and |
| // merging lists as necessary. |
| const unsigned MaxSlots = 32; |
| Use *Slots[MaxSlots]; |
| |
| // Collect the first use, turning it into a single-item list. |
| Use *Next = UseList->Next; |
| UseList->Next = nullptr; |
| unsigned NumSlots = 1; |
| Slots[0] = UseList; |
| |
| // Collect all but the last use. |
| while (Next->Next) { |
| Use *Current = Next; |
| Next = Current->Next; |
| |
| // Turn Current into a single-item list. |
| Current->Next = nullptr; |
| |
| // Save Current in the first available slot, merging on collisions. |
| unsigned I; |
| for (I = 0; I < NumSlots; ++I) { |
| if (!Slots[I]) |
| break; |
| |
| // Merge two lists, doubling the size of Current and emptying slot I. |
| // |
| // Since the uses in Slots[I] originally preceded those in Current, send |
| // Slots[I] in as the left parameter to maintain a stable sort. |
| Current = mergeUseLists(Slots[I], Current, Cmp); |
| Slots[I] = nullptr; |
| } |
| // Check if this is a new slot. |
| if (I == NumSlots) { |
| ++NumSlots; |
| assert(NumSlots <= MaxSlots && "Use list bigger than 2^32"); |
| } |
| |
| // Found an open slot. |
| Slots[I] = Current; |
| } |
| |
| // Merge all the lists together. |
| assert(Next && "Expected one more Use"); |
| assert(!Next->Next && "Expected only one Use"); |
| UseList = Next; |
| for (unsigned I = 0; I < NumSlots; ++I) |
| if (Slots[I]) |
| // Since the uses in Slots[I] originally preceded those in UseList, send |
| // Slots[I] in as the left parameter to maintain a stable sort. |
| UseList = mergeUseLists(Slots[I], UseList, Cmp); |
| |
| // Fix the Prev pointers. |
| for (Use *I = UseList, **Prev = &UseList; I; I = I->Next) { |
| I->Prev = Prev; |
| Prev = &I->Next; |
| } |
| } |
| |
| // isa - Provide some specializations of isa so that we don't have to include |
| // the subtype header files to test to see if the value is a subclass... |
| // |
| template <> struct isa_impl<Constant, Value> { |
| static inline bool doit(const Value &Val) { |
| static_assert(Value::ConstantFirstVal == 0, "Val.getValueID() >= Value::ConstantFirstVal"); |
| return Val.getValueID() <= Value::ConstantLastVal; |
| } |
| }; |
| |
| template <> struct isa_impl<ConstantData, Value> { |
| static inline bool doit(const Value &Val) { |
| return Val.getValueID() >= Value::ConstantDataFirstVal && |
| Val.getValueID() <= Value::ConstantDataLastVal; |
| } |
| }; |
| |
| template <> struct isa_impl<ConstantAggregate, Value> { |
| static inline bool doit(const Value &Val) { |
| return Val.getValueID() >= Value::ConstantAggregateFirstVal && |
| Val.getValueID() <= Value::ConstantAggregateLastVal; |
| } |
| }; |
| |
| template <> struct isa_impl<Argument, Value> { |
| static inline bool doit (const Value &Val) { |
| return Val.getValueID() == Value::ArgumentVal; |
| } |
| }; |
| |
| template <> struct isa_impl<InlineAsm, Value> { |
| static inline bool doit(const Value &Val) { |
| return Val.getValueID() == Value::InlineAsmVal; |
| } |
| }; |
| |
| template <> struct isa_impl<Instruction, Value> { |
| static inline bool doit(const Value &Val) { |
| return Val.getValueID() >= Value::InstructionVal; |
| } |
| }; |
| |
| template <> struct isa_impl<BasicBlock, Value> { |
| static inline bool doit(const Value &Val) { |
| return Val.getValueID() == Value::BasicBlockVal; |
| } |
| }; |
| |
| template <> struct isa_impl<Function, Value> { |
| static inline bool doit(const Value &Val) { |
| return Val.getValueID() == Value::FunctionVal; |
| } |
| }; |
| |
| template <> struct isa_impl<GlobalVariable, Value> { |
| static inline bool doit(const Value &Val) { |
| return Val.getValueID() == Value::GlobalVariableVal; |
| } |
| }; |
| |
| template <> struct isa_impl<GlobalAlias, Value> { |
| static inline bool doit(const Value &Val) { |
| return Val.getValueID() == Value::GlobalAliasVal; |
| } |
| }; |
| |
| template <> struct isa_impl<GlobalIFunc, Value> { |
| static inline bool doit(const Value &Val) { |
| return Val.getValueID() == Value::GlobalIFuncVal; |
| } |
| }; |
| |
| template <> struct isa_impl<GlobalValue, Value> { |
| static inline bool doit(const Value &Val) { |
| return isa<GlobalObject>(Val) || isa<GlobalAlias>(Val); |
| } |
| }; |
| |
| template <> struct isa_impl<GlobalObject, Value> { |
| static inline bool doit(const Value &Val) { |
| return isa<GlobalVariable>(Val) || isa<Function>(Val) || |
| isa<GlobalIFunc>(Val); |
| } |
| }; |
| |
| // Create wrappers for C Binding types (see CBindingWrapping.h). |
| DEFINE_ISA_CONVERSION_FUNCTIONS(Value, LLVMValueRef) |
| |
| // Specialized opaque value conversions. |
| inline Value **unwrap(LLVMValueRef *Vals) { |
| return reinterpret_cast<Value**>(Vals); |
| } |
| |
| template<typename T> |
| inline T **unwrap(LLVMValueRef *Vals, unsigned Length) { |
| #ifndef NDEBUG |
| for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I) |
| unwrap<T>(*I); // For side effect of calling assert on invalid usage. |
| #endif |
| (void)Length; |
| return reinterpret_cast<T**>(Vals); |
| } |
| |
| inline LLVMValueRef *wrap(const Value **Vals) { |
| return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals)); |
| } |
| |
| } // end namespace llvm |
| |
| #endif // LLVM_IR_VALUE_H |