LCOV - code coverage report
Current view: top level - include/llvm/IR - Attributes.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 49 53 92.5 %
Date: 2017-09-14 15:23:50 Functions: 0 0 -
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- llvm/Attributes.h - Container for Attributes -------------*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : ///
      10             : /// \file
      11             : /// \brief This file contains the simple types necessary to represent the
      12             : /// attributes associated with functions and their calls.
      13             : ///
      14             : //===----------------------------------------------------------------------===//
      15             : 
      16             : #ifndef LLVM_IR_ATTRIBUTES_H
      17             : #define LLVM_IR_ATTRIBUTES_H
      18             : 
      19             : #include "llvm-c/Types.h"
      20             : #include "llvm/ADT/ArrayRef.h"
      21             : #include "llvm/ADT/FoldingSet.h"
      22             : #include "llvm/ADT/Optional.h"
      23             : #include "llvm/ADT/StringRef.h"
      24             : #include "llvm/ADT/iterator_range.h"
      25             : #include "llvm/Support/PointerLikeTypeTraits.h"
      26             : #include <bitset>
      27             : #include <cassert>
      28             : #include <cstdint>
      29             : #include <map>
      30             : #include <string>
      31             : #include <utility>
      32             : 
      33             : namespace llvm {
      34             : 
      35             : class AttrBuilder;
      36             : class AttributeImpl;
      37             : class AttributeListImpl;
      38             : class AttributeList;
      39             : class AttributeSetNode;
      40             : template<typename T> struct DenseMapInfo;
      41             : class Function;
      42             : class LLVMContext;
      43             : class Type;
      44             : 
      45             : //===----------------------------------------------------------------------===//
      46             : /// \class
      47             : /// \brief Functions, function parameters, and return types can have attributes
      48             : /// to indicate how they should be treated by optimizations and code
      49             : /// generation. This class represents one of those attributes. It's light-weight
      50             : /// and should be passed around by-value.
      51             : class Attribute {
      52             : public:
      53             :   /// This enumeration lists the attributes that can be associated with
      54             :   /// parameters, function results, or the function itself.
      55             :   ///
      56             :   /// Note: The `uwtable' attribute is about the ABI or the user mandating an
      57             :   /// entry in the unwind table. The `nounwind' attribute is about an exception
      58             :   /// passing by the function.
      59             :   ///
      60             :   /// In a theoretical system that uses tables for profiling and SjLj for
      61             :   /// exceptions, they would be fully independent. In a normal system that uses
      62             :   /// tables for both, the semantics are:
      63             :   ///
      64             :   /// nil                = Needs an entry because an exception might pass by.
      65             :   /// nounwind           = No need for an entry
      66             :   /// uwtable            = Needs an entry because the ABI says so and because
      67             :   ///                      an exception might pass by.
      68             :   /// uwtable + nounwind = Needs an entry because the ABI says so.
      69             : 
      70             :   enum AttrKind {
      71             :     // IR-Level Attributes
      72             :     None,                  ///< No attributes have been set
      73             :     #define GET_ATTR_ENUM
      74             :     #include "llvm/IR/Attributes.gen"
      75             :     EndAttrKinds           ///< Sentinal value useful for loops
      76             :   };
      77             : 
      78             : private:
      79             :   AttributeImpl *pImpl = nullptr;
      80             : 
      81             :   Attribute(AttributeImpl *A) : pImpl(A) {}
      82             : 
      83             : public:
      84             :   Attribute() = default;
      85             : 
      86             :   //===--------------------------------------------------------------------===//
      87             :   // Attribute Construction
      88             :   //===--------------------------------------------------------------------===//
      89             : 
      90             :   /// \brief Return a uniquified Attribute object.
      91             :   static Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val = 0);
      92             :   static Attribute get(LLVMContext &Context, StringRef Kind,
      93             :                        StringRef Val = StringRef());
      94             : 
      95             :   /// \brief Return a uniquified Attribute object that has the specific
      96             :   /// alignment set.
      97             :   static Attribute getWithAlignment(LLVMContext &Context, uint64_t Align);
      98             :   static Attribute getWithStackAlignment(LLVMContext &Context, uint64_t Align);
      99             :   static Attribute getWithDereferenceableBytes(LLVMContext &Context,
     100             :                                               uint64_t Bytes);
     101             :   static Attribute getWithDereferenceableOrNullBytes(LLVMContext &Context,
     102             :                                                      uint64_t Bytes);
     103             :   static Attribute getWithAllocSizeArgs(LLVMContext &Context,
     104             :                                         unsigned ElemSizeArg,
     105             :                                         const Optional<unsigned> &NumElemsArg);
     106             : 
     107             :   //===--------------------------------------------------------------------===//
     108             :   // Attribute Accessors
     109             :   //===--------------------------------------------------------------------===//
     110             : 
     111             :   /// \brief Return true if the attribute is an Attribute::AttrKind type.
     112             :   bool isEnumAttribute() const;
     113             : 
     114             :   /// \brief Return true if the attribute is an integer attribute.
     115             :   bool isIntAttribute() const;
     116             : 
     117             :   /// \brief Return true if the attribute is a string (target-dependent)
     118             :   /// attribute.
     119             :   bool isStringAttribute() const;
     120             : 
     121             :   /// \brief Return true if the attribute is present.
     122             :   bool hasAttribute(AttrKind Val) const;
     123             : 
     124             :   /// \brief Return true if the target-dependent attribute is present.
     125             :   bool hasAttribute(StringRef Val) const;
     126             : 
     127             :   /// \brief Return the attribute's kind as an enum (Attribute::AttrKind). This
     128             :   /// requires the attribute to be an enum or integer attribute.
     129             :   Attribute::AttrKind getKindAsEnum() const;
     130             : 
     131             :   /// \brief Return the attribute's value as an integer. This requires that the
     132             :   /// attribute be an integer attribute.
     133             :   uint64_t getValueAsInt() const;
     134             : 
     135             :   /// \brief Return the attribute's kind as a string. This requires the
     136             :   /// attribute to be a string attribute.
     137             :   StringRef getKindAsString() const;
     138             : 
     139             :   /// \brief Return the attribute's value as a string. This requires the
     140             :   /// attribute to be a string attribute.
     141             :   StringRef getValueAsString() const;
     142             : 
     143             :   /// \brief Returns the alignment field of an attribute as a byte alignment
     144             :   /// value.
     145             :   unsigned getAlignment() const;
     146             : 
     147             :   /// \brief Returns the stack alignment field of an attribute as a byte
     148             :   /// alignment value.
     149             :   unsigned getStackAlignment() const;
     150             : 
     151             :   /// \brief Returns the number of dereferenceable bytes from the
     152             :   /// dereferenceable attribute.
     153             :   uint64_t getDereferenceableBytes() const;
     154             : 
     155             :   /// \brief Returns the number of dereferenceable_or_null bytes from the
     156             :   /// dereferenceable_or_null attribute.
     157             :   uint64_t getDereferenceableOrNullBytes() const;
     158             : 
     159             :   /// Returns the argument numbers for the allocsize attribute (or pair(0, 0)
     160             :   /// if not known).
     161             :   std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
     162             : 
     163             :   /// \brief The Attribute is converted to a string of equivalent mnemonic. This
     164             :   /// is, presumably, for writing out the mnemonics for the assembly writer.
     165             :   std::string getAsString(bool InAttrGrp = false) const;
     166             : 
     167             :   /// \brief Equality and non-equality operators.
     168     1412889 :   bool operator==(Attribute A) const { return pImpl == A.pImpl; }
     169             :   bool operator!=(Attribute A) const { return pImpl != A.pImpl; }
     170             : 
     171             :   /// \brief Less-than operator. Useful for sorting the attributes list.
     172             :   bool operator<(Attribute A) const;
     173             : 
     174             :   void Profile(FoldingSetNodeID &ID) const {
     175    15097837 :     ID.AddPointer(pImpl);
     176             :   }
     177             : 
     178             :   /// \brief Return a raw pointer that uniquely identifies this attribute.
     179             :   void *getRawPointer() const {
     180             :     return pImpl;
     181             :   }
     182             : 
     183             :   /// \brief Get an attribute from a raw pointer created by getRawPointer.
     184             :   static Attribute fromRawPointer(void *RawPtr) {
     185          20 :     return Attribute(reinterpret_cast<AttributeImpl*>(RawPtr));
     186             :   }
     187             : };
     188             : 
     189             : // Specialized opaque value conversions.
     190             : inline LLVMAttributeRef wrap(Attribute Attr) {
     191        3805 :   return reinterpret_cast<LLVMAttributeRef>(Attr.getRawPointer());
     192             : }
     193             : 
     194             : // Specialized opaque value conversions.
     195             : inline Attribute unwrap(LLVMAttributeRef Attr) {
     196          20 :   return Attribute::fromRawPointer(Attr);
     197             : }
     198             : 
     199             : //===----------------------------------------------------------------------===//
     200             : /// \class
     201             : /// This class holds the attributes for a particular argument, parameter,
     202             : /// function, or return value. It is an immutable value type that is cheap to
     203             : /// copy. Adding and removing enum attributes is intended to be fast, but adding
     204             : /// and removing string or integer attributes involves a FoldingSet lookup.
     205             : class AttributeSet {
     206             :   // TODO: Extract AvailableAttrs from AttributeSetNode and store them here.
     207             :   // This will allow an efficient implementation of addAttribute and
     208             :   // removeAttribute for enum attrs.
     209             : 
     210             :   /// Private implementation pointer.
     211             :   AttributeSetNode *SetNode = nullptr;
     212             : 
     213             :   friend AttributeListImpl;
     214             :   template <typename Ty> friend struct DenseMapInfo;
     215             : 
     216             : private:
     217             :   explicit AttributeSet(AttributeSetNode *ASN) : SetNode(ASN) {}
     218             : 
     219             : public:
     220             :   /// AttributeSet is a trivially copyable value type.
     221      141122 :   AttributeSet() = default;
     222             :   AttributeSet(const AttributeSet &) = default;
     223             :   ~AttributeSet() = default;
     224             : 
     225             :   static AttributeSet get(LLVMContext &C, const AttrBuilder &B);
     226             :   static AttributeSet get(LLVMContext &C, ArrayRef<Attribute> Attrs);
     227             : 
     228      418544 :   bool operator==(const AttributeSet &O) { return SetNode == O.SetNode; }
     229             :   bool operator!=(const AttributeSet &O) { return !(*this == O); }
     230             : 
     231             :   /// Add an argument attribute. Returns a new set because attribute sets are
     232             :   /// immutable.
     233             :   AttributeSet addAttribute(LLVMContext &C, Attribute::AttrKind Kind) const;
     234             : 
     235             :   /// Add a target-dependent attribute. Returns a new set because attribute sets
     236             :   /// are immutable.
     237             :   AttributeSet addAttribute(LLVMContext &C, StringRef Kind,
     238             :                             StringRef Value = StringRef()) const;
     239             : 
     240             :   /// Add attributes to the attribute set. Returns a new set because attribute
     241             :   /// sets are immutable.
     242             :   AttributeSet addAttributes(LLVMContext &C, AttributeSet AS) const;
     243             : 
     244             :   /// Remove the specified attribute from this set. Returns a new set because
     245             :   /// attribute sets are immutable.
     246             :   AttributeSet removeAttribute(LLVMContext &C, Attribute::AttrKind Kind) const;
     247             : 
     248             :   /// Remove the specified attribute from this set. Returns a new set because
     249             :   /// attribute sets are immutable.
     250             :   AttributeSet removeAttribute(LLVMContext &C, StringRef Kind) const;
     251             : 
     252             :   /// Remove the specified attributes from this set. Returns a new set because
     253             :   /// attribute sets are immutable.
     254             :   AttributeSet removeAttributes(LLVMContext &C,
     255             :                                 const AttrBuilder &AttrsToRemove) const;
     256             : 
     257             :   /// Return the number of attributes in this set.
     258             :   unsigned getNumAttributes() const;
     259             : 
     260             :   /// Return true if attributes exists in this set.
     261     6266132 :   bool hasAttributes() const { return SetNode != nullptr; }
     262             : 
     263             :   /// Return true if the attribute exists in this set.
     264             :   bool hasAttribute(Attribute::AttrKind Kind) const;
     265             : 
     266             :   /// Return true if the attribute exists in this set.
     267             :   bool hasAttribute(StringRef Kind) const;
     268             : 
     269             :   /// Return the attribute object.
     270             :   Attribute getAttribute(Attribute::AttrKind Kind) const;
     271             : 
     272             :   /// Return the target-dependent attribute object.
     273             :   Attribute getAttribute(StringRef Kind) const;
     274             : 
     275             :   unsigned getAlignment() const;
     276             :   unsigned getStackAlignment() const;
     277             :   uint64_t getDereferenceableBytes() const;
     278             :   uint64_t getDereferenceableOrNullBytes() const;
     279             :   std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
     280             :   std::string getAsString(bool InAttrGrp = false) const;
     281             : 
     282             :   using iterator = const Attribute *;
     283             : 
     284             :   iterator begin() const;
     285             :   iterator end() const;
     286             : #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
     287             :   void dump() const;
     288             : #endif
     289             : };
     290             : 
     291             : //===----------------------------------------------------------------------===//
     292             : /// \class
     293             : /// \brief Provide DenseMapInfo for AttributeSet.
     294             : template <> struct DenseMapInfo<AttributeSet> {
     295             :   static inline AttributeSet getEmptyKey() {
     296      443846 :     uintptr_t Val = static_cast<uintptr_t>(-1);
     297      443846 :     Val <<= PointerLikeTypeTraits<void *>::NumLowBitsAvailable;
     298      443846 :     return AttributeSet(reinterpret_cast<AttributeSetNode *>(Val));
     299             :   }
     300             : 
     301             :   static inline AttributeSet getTombstoneKey() {
     302      398465 :     uintptr_t Val = static_cast<uintptr_t>(-2);
     303      398465 :     Val <<= PointerLikeTypeTraits<void *>::NumLowBitsAvailable;
     304      398465 :     return AttributeSet(reinterpret_cast<AttributeSetNode *>(Val));
     305             :   }
     306             : 
     307             :   static unsigned getHashValue(AttributeSet AS) {
     308      378804 :     return (unsigned((uintptr_t)AS.SetNode) >> 4) ^
     309      378804 :            (unsigned((uintptr_t)AS.SetNode) >> 9);
     310             :   }
     311             : 
     312     1017200 :   static bool isEqual(AttributeSet LHS, AttributeSet RHS) { return LHS == RHS; }
     313             : };
     314             : 
     315             : //===----------------------------------------------------------------------===//
     316             : /// \class
     317             : /// \brief This class holds the attributes for a function, its return value, and
     318             : /// its parameters. You access the attributes for each of them via an index into
     319             : /// the AttributeList object. The function attributes are at index
     320             : /// `AttributeList::FunctionIndex', the return value is at index
     321             : /// `AttributeList::ReturnIndex', and the attributes for the parameters start at
     322             : /// index `AttributeList::FirstArgIndex'.
     323             : class AttributeList {
     324             : public:
     325             :   enum AttrIndex : unsigned {
     326             :     ReturnIndex = 0U,
     327             :     FunctionIndex = ~0U,
     328             :     FirstArgIndex = 1,
     329             :   };
     330             : 
     331             : private:
     332             :   friend class AttrBuilder;
     333             :   friend class AttributeListImpl;
     334             :   friend class AttributeSet;
     335             :   friend class AttributeSetNode;
     336             : 
     337             :   template <typename Ty> friend struct DenseMapInfo;
     338             : 
     339             :   /// \brief The attributes that we are managing. This can be null to represent
     340             :   /// the empty attributes list.
     341             :   AttributeListImpl *pImpl = nullptr;
     342             : 
     343             : public:
     344             :   /// \brief Create an AttributeList with the specified parameters in it.
     345             :   static AttributeList get(LLVMContext &C,
     346             :                            ArrayRef<std::pair<unsigned, Attribute>> Attrs);
     347             :   static AttributeList get(LLVMContext &C,
     348             :                            ArrayRef<std::pair<unsigned, AttributeSet>> Attrs);
     349             : 
     350             :   /// \brief Create an AttributeList from attribute sets for a function, its
     351             :   /// return value, and all of its arguments.
     352             :   static AttributeList get(LLVMContext &C, AttributeSet FnAttrs,
     353             :                            AttributeSet RetAttrs,
     354             :                            ArrayRef<AttributeSet> ArgAttrs);
     355             : 
     356             : private:
     357             :   explicit AttributeList(AttributeListImpl *LI) : pImpl(LI) {}
     358             : 
     359             :   static AttributeList getImpl(LLVMContext &C, ArrayRef<AttributeSet> AttrSets);
     360             : 
     361             : public:
     362     1044964 :   AttributeList() = default;
     363             : 
     364             :   //===--------------------------------------------------------------------===//
     365             :   // AttributeList Construction and Mutation
     366             :   //===--------------------------------------------------------------------===//
     367             : 
     368             :   /// \brief Return an AttributeList with the specified parameters in it.
     369             :   static AttributeList get(LLVMContext &C, ArrayRef<AttributeList> Attrs);
     370             :   static AttributeList get(LLVMContext &C, unsigned Index,
     371             :                            ArrayRef<Attribute::AttrKind> Kinds);
     372             :   static AttributeList get(LLVMContext &C, unsigned Index,
     373             :                            ArrayRef<StringRef> Kind);
     374             :   static AttributeList get(LLVMContext &C, unsigned Index,
     375             :                            const AttrBuilder &B);
     376             : 
     377             :   /// \brief Add an attribute to the attribute set at the given index.
     378             :   /// Returns a new list because attribute lists are immutable.
     379             :   AttributeList addAttribute(LLVMContext &C, unsigned Index,
     380             :                              Attribute::AttrKind Kind) const;
     381             : 
     382             :   /// \brief Add an attribute to the attribute set at the given index.
     383             :   /// Returns a new list because attribute lists are immutable.
     384             :   AttributeList addAttribute(LLVMContext &C, unsigned Index, StringRef Kind,
     385             :                              StringRef Value = StringRef()) const;
     386             : 
     387             :   /// Add an attribute to the attribute set at the given index.
     388             :   /// Returns a new list because attribute lists are immutable.
     389             :   AttributeList addAttribute(LLVMContext &C, unsigned Index, Attribute A) const;
     390             : 
     391             :   /// \brief Add attributes to the attribute set at the given index.
     392             :   /// Returns a new list because attribute lists are immutable.
     393             :   AttributeList addAttributes(LLVMContext &C, unsigned Index,
     394             :                               const AttrBuilder &B) const;
     395             : 
     396             :   /// Add an argument attribute to the list. Returns a new list because
     397             :   /// attribute lists are immutable.
     398             :   AttributeList addParamAttribute(LLVMContext &C, unsigned ArgNo,
     399             :                                   Attribute::AttrKind Kind) const {
     400       15175 :     return addAttribute(C, ArgNo + FirstArgIndex, Kind);
     401             :   }
     402             : 
     403             :   /// Add an argument attribute to the list. Returns a new list because
     404             :   /// attribute lists are immutable.
     405             :   AttributeList addParamAttribute(LLVMContext &C, unsigned ArgNo,
     406             :                                   StringRef Kind,
     407             :                                   StringRef Value = StringRef()) const {
     408             :     return addAttribute(C, ArgNo + FirstArgIndex, Kind, Value);
     409             :   }
     410             : 
     411             :   /// Add an attribute to the attribute list at the given arg indices. Returns a
     412             :   /// new list because attribute lists are immutable.
     413             :   AttributeList addParamAttribute(LLVMContext &C, ArrayRef<unsigned> ArgNos,
     414             :                                   Attribute A) const;
     415             : 
     416             :   /// Add an argument attribute to the list. Returns a new list because
     417             :   /// attribute lists are immutable.
     418             :   AttributeList addParamAttributes(LLVMContext &C, unsigned ArgNo,
     419             :                                    const AttrBuilder &B) const {
     420           7 :     return addAttributes(C, ArgNo + FirstArgIndex, B);
     421             :   }
     422             : 
     423             :   /// \brief Remove the specified attribute at the specified index from this
     424             :   /// attribute list. Returns a new list because attribute lists are immutable.
     425             :   AttributeList removeAttribute(LLVMContext &C, unsigned Index,
     426             :                                 Attribute::AttrKind Kind) const;
     427             : 
     428             :   /// \brief Remove the specified attribute at the specified index from this
     429             :   /// attribute list. Returns a new list because attribute lists are immutable.
     430             :   AttributeList removeAttribute(LLVMContext &C, unsigned Index,
     431             :                                 StringRef Kind) const;
     432             : 
     433             :   /// \brief Remove the specified attributes at the specified index from this
     434             :   /// attribute list. Returns a new list because attribute lists are immutable.
     435             :   AttributeList removeAttributes(LLVMContext &C, unsigned Index,
     436             :                                  const AttrBuilder &AttrsToRemove) const;
     437             : 
     438             :   /// \brief Remove all attributes at the specified index from this
     439             :   /// attribute list. Returns a new list because attribute lists are immutable.
     440             :   AttributeList removeAttributes(LLVMContext &C, unsigned Index) const;
     441             : 
     442             :   /// \brief Remove the specified attribute at the specified arg index from this
     443             :   /// attribute list. Returns a new list because attribute lists are immutable.
     444             :   AttributeList removeParamAttribute(LLVMContext &C, unsigned ArgNo,
     445             :                                      Attribute::AttrKind Kind) const {
     446          26 :     return removeAttribute(C, ArgNo + FirstArgIndex, Kind);
     447             :   }
     448             : 
     449             :   /// \brief Remove the specified attribute at the specified arg index from this
     450             :   /// attribute list. Returns a new list because attribute lists are immutable.
     451             :   AttributeList removeParamAttribute(LLVMContext &C, unsigned ArgNo,
     452             :                                      StringRef Kind) const {
     453           0 :     return removeAttribute(C, ArgNo + FirstArgIndex, Kind);
     454             :   }
     455             : 
     456             :   /// \brief Remove the specified attribute at the specified arg index from this
     457             :   /// attribute list. Returns a new list because attribute lists are immutable.
     458             :   AttributeList removeParamAttributes(LLVMContext &C, unsigned ArgNo,
     459             :                                       const AttrBuilder &AttrsToRemove) const {
     460           0 :     return removeAttributes(C, ArgNo + FirstArgIndex, AttrsToRemove);
     461             :   }
     462             : 
     463             :   /// \brief Remove all attributes at the specified arg index from this
     464             :   /// attribute list. Returns a new list because attribute lists are immutable.
     465             :   AttributeList removeParamAttributes(LLVMContext &C, unsigned ArgNo) const {
     466             :     return removeAttributes(C, ArgNo + FirstArgIndex);
     467             :   }
     468             : 
     469             :   /// \Brief Add the dereferenceable attribute to the attribute set at the given
     470             :   /// index. Returns a new list because attribute lists are immutable.
     471             :   AttributeList addDereferenceableAttr(LLVMContext &C, unsigned Index,
     472             :                                        uint64_t Bytes) const;
     473             : 
     474             :   /// \Brief Add the dereferenceable attribute to the attribute set at the given
     475             :   /// arg index. Returns a new list because attribute lists are immutable.
     476             :   AttributeList addDereferenceableParamAttr(LLVMContext &C, unsigned ArgNo,
     477             :                                             uint64_t Bytes) const {
     478           0 :     return addDereferenceableAttr(C, ArgNo + FirstArgIndex, Bytes);
     479             :   }
     480             : 
     481             :   /// \brief Add the dereferenceable_or_null attribute to the attribute set at
     482             :   /// the given index. Returns a new list because attribute lists are immutable.
     483             :   AttributeList addDereferenceableOrNullAttr(LLVMContext &C, unsigned Index,
     484             :                                              uint64_t Bytes) const;
     485             : 
     486             :   /// \brief Add the dereferenceable_or_null attribute to the attribute set at
     487             :   /// the given arg index. Returns a new list because attribute lists are
     488             :   /// immutable.
     489             :   AttributeList addDereferenceableOrNullParamAttr(LLVMContext &C,
     490             :                                                   unsigned ArgNo,
     491             :                                                   uint64_t Bytes) const {
     492           0 :     return addDereferenceableOrNullAttr(C, ArgNo + FirstArgIndex, Bytes);
     493             :   }
     494             : 
     495             :   /// Add the allocsize attribute to the attribute set at the given index.
     496             :   /// Returns a new list because attribute lists are immutable.
     497             :   AttributeList addAllocSizeAttr(LLVMContext &C, unsigned Index,
     498             :                                  unsigned ElemSizeArg,
     499             :                                  const Optional<unsigned> &NumElemsArg);
     500             : 
     501             :   /// Add the allocsize attribute to the attribute set at the given arg index.
     502             :   /// Returns a new list because attribute lists are immutable.
     503             :   AttributeList addAllocSizeParamAttr(LLVMContext &C, unsigned ArgNo,
     504             :                                       unsigned ElemSizeArg,
     505             :                                       const Optional<unsigned> &NumElemsArg) {
     506             :     return addAllocSizeAttr(C, ArgNo + FirstArgIndex, ElemSizeArg, NumElemsArg);
     507             :   }
     508             : 
     509             :   //===--------------------------------------------------------------------===//
     510             :   // AttributeList Accessors
     511             :   //===--------------------------------------------------------------------===//
     512             : 
     513             :   /// \brief Retrieve the LLVM context.
     514             :   LLVMContext &getContext() const;
     515             : 
     516             :   /// \brief The attributes for the specified index are returned.
     517             :   AttributeSet getAttributes(unsigned Index) const;
     518             : 
     519             :   /// \brief The attributes for the argument or parameter at the given index are
     520             :   /// returned.
     521             :   AttributeSet getParamAttributes(unsigned ArgNo) const;
     522             : 
     523             :   /// \brief The attributes for the ret value are returned.
     524             :   AttributeSet getRetAttributes() const;
     525             : 
     526             :   /// \brief The function attributes are returned.
     527             :   AttributeSet getFnAttributes() const;
     528             : 
     529             :   /// \brief Return true if the attribute exists at the given index.
     530             :   bool hasAttribute(unsigned Index, Attribute::AttrKind Kind) const;
     531             : 
     532             :   /// \brief Return true if the attribute exists at the given index.
     533             :   bool hasAttribute(unsigned Index, StringRef Kind) const;
     534             : 
     535             :   /// \brief Return true if attribute exists at the given index.
     536             :   bool hasAttributes(unsigned Index) const;
     537             : 
     538             :   /// \brief Return true if the attribute exists for the given argument
     539             :   bool hasParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const {
     540             :     return hasAttribute(ArgNo + FirstArgIndex, Kind);
     541             :   }
     542             : 
     543             :   /// \brief Return true if the attribute exists for the given argument
     544             :   bool hasParamAttr(unsigned ArgNo, StringRef Kind) const {
     545             :     return hasAttribute(ArgNo + FirstArgIndex, Kind);
     546             :   }
     547             : 
     548             :   /// \brief Return true if attributes exists for the given argument
     549             :   bool hasParamAttrs(unsigned ArgNo) const {
     550             :     return hasAttributes(ArgNo + FirstArgIndex);
     551             :   }
     552             : 
     553             :   /// \brief Equivalent to hasAttribute(AttributeList::FunctionIndex, Kind) but
     554             :   /// may be faster.
     555             :   bool hasFnAttribute(Attribute::AttrKind Kind) const;
     556             : 
     557             :   /// \brief Equivalent to hasAttribute(AttributeList::FunctionIndex, Kind) but
     558             :   /// may be faster.
     559             :   bool hasFnAttribute(StringRef Kind) const;
     560             : 
     561             :   /// \brief Equivalent to hasAttribute(ArgNo + FirstArgIndex, Kind).
     562             :   bool hasParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const;
     563             : 
     564             :   /// \brief Return true if the specified attribute is set for at least one
     565             :   /// parameter or for the return value. If Index is not nullptr, the index
     566             :   /// of a parameter with the specified attribute is provided.
     567             :   bool hasAttrSomewhere(Attribute::AttrKind Kind,
     568             :                         unsigned *Index = nullptr) const;
     569             : 
     570             :   /// \brief Return the attribute object that exists at the given index.
     571             :   Attribute getAttribute(unsigned Index, Attribute::AttrKind Kind) const;
     572             : 
     573             :   /// \brief Return the attribute object that exists at the given index.
     574             :   Attribute getAttribute(unsigned Index, StringRef Kind) const;
     575             : 
     576             :   /// \brief Return the attribute object that exists at the arg index.
     577             :   Attribute getParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const {
     578             :     return getAttribute(ArgNo + FirstArgIndex, Kind);
     579             :   }
     580             : 
     581             :   /// \brief Return the attribute object that exists at the given index.
     582             :   Attribute getParamAttr(unsigned ArgNo, StringRef Kind) const {
     583             :     return getAttribute(ArgNo + FirstArgIndex, Kind);
     584             :   }
     585             : 
     586             :   /// \brief Return the alignment of the return value.
     587             :   unsigned getRetAlignment() const;
     588             : 
     589             :   /// \brief Return the alignment for the specified function parameter.
     590             :   unsigned getParamAlignment(unsigned ArgNo) const;
     591             : 
     592             :   /// \brief Get the stack alignment.
     593             :   unsigned getStackAlignment(unsigned Index) const;
     594             : 
     595             :   /// \brief Get the number of dereferenceable bytes (or zero if unknown).
     596             :   uint64_t getDereferenceableBytes(unsigned Index) const;
     597             : 
     598             :   /// \brief Get the number of dereferenceable bytes (or zero if unknown) of an
     599             :   /// arg.
     600             :   uint64_t getParamDereferenceableBytes(unsigned ArgNo) const {
     601     1231425 :     return getDereferenceableBytes(ArgNo + FirstArgIndex);
     602             :   }
     603             : 
     604             :   /// \brief Get the number of dereferenceable_or_null bytes (or zero if
     605             :   /// unknown).
     606             :   uint64_t getDereferenceableOrNullBytes(unsigned Index) const;
     607             : 
     608             :   /// \brief Get the number of dereferenceable_or_null bytes (or zero if
     609             :   /// unknown) of an arg.
     610             :   uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const {
     611       46055 :     return getDereferenceableOrNullBytes(ArgNo + FirstArgIndex);
     612             :   }
     613             : 
     614             :   /// Get the allocsize argument numbers (or pair(0, 0) if unknown).
     615             :   std::pair<unsigned, Optional<unsigned>>
     616             :   getAllocSizeArgs(unsigned Index) const;
     617             : 
     618             :   /// \brief Return the attributes at the index as a string.
     619             :   std::string getAsString(unsigned Index, bool InAttrGrp = false) const;
     620             : 
     621             :   //===--------------------------------------------------------------------===//
     622             :   // AttributeList Introspection
     623             :   //===--------------------------------------------------------------------===//
     624             : 
     625             :   using iterator = const AttributeSet *;
     626             : 
     627             :   iterator begin() const;
     628             :   iterator end() const;
     629             : 
     630             :   unsigned getNumAttrSets() const;
     631             : 
     632             :   /// Use these to iterate over the valid attribute indices.
     633             :   unsigned index_begin() const { return AttributeList::FunctionIndex; }
     634     2674684 :   unsigned index_end() const { return getNumAttrSets() - 1; }
     635             : 
     636             :   /// operator==/!= - Provide equality predicates.
     637       15827 :   bool operator==(const AttributeList &RHS) const { return pImpl == RHS.pImpl; }
     638           1 :   bool operator!=(const AttributeList &RHS) const { return pImpl != RHS.pImpl; }
     639             : 
     640             :   /// \brief Return a raw pointer that uniquely identifies this attribute list.
     641             :   void *getRawPointer() const {
     642             :     return pImpl;
     643             :   }
     644             : 
     645             :   /// \brief Return true if there are no attributes.
     646     1238280 :   bool isEmpty() const { return pImpl == nullptr; }
     647             : 
     648             :   void dump() const;
     649             : };
     650             : 
     651             : //===----------------------------------------------------------------------===//
     652             : /// \class
     653             : /// \brief Provide DenseMapInfo for AttributeList.
     654             : template <> struct DenseMapInfo<AttributeList> {
     655             :   static inline AttributeList getEmptyKey() {
     656       14487 :     uintptr_t Val = static_cast<uintptr_t>(-1);
     657       14487 :     Val <<= PointerLikeTypeTraits<void*>::NumLowBitsAvailable;
     658       14487 :     return AttributeList(reinterpret_cast<AttributeListImpl *>(Val));
     659             :   }
     660             : 
     661             :   static inline AttributeList getTombstoneKey() {
     662       11431 :     uintptr_t Val = static_cast<uintptr_t>(-2);
     663       11431 :     Val <<= PointerLikeTypeTraits<void*>::NumLowBitsAvailable;
     664       11431 :     return AttributeList(reinterpret_cast<AttributeListImpl *>(Val));
     665             :   }
     666             : 
     667             :   static unsigned getHashValue(AttributeList AS) {
     668       11431 :     return (unsigned((uintptr_t)AS.pImpl) >> 4) ^
     669       11431 :            (unsigned((uintptr_t)AS.pImpl) >> 9);
     670             :   }
     671             : 
     672             :   static bool isEqual(AttributeList LHS, AttributeList RHS) {
     673       19706 :     return LHS == RHS;
     674             :   }
     675             : };
     676             : 
     677             : //===----------------------------------------------------------------------===//
     678             : /// \class
     679             : /// \brief This class is used in conjunction with the Attribute::get method to
     680             : /// create an Attribute object. The object itself is uniquified. The Builder's
     681             : /// value, however, is not. So this can be used as a quick way to test for
     682             : /// equality, presence of attributes, etc.
     683     9984676 : class AttrBuilder {
     684             :   std::bitset<Attribute::EndAttrKinds> Attrs;
     685             :   std::map<std::string, std::string> TargetDepAttrs;
     686             :   uint64_t Alignment = 0;
     687             :   uint64_t StackAlignment = 0;
     688             :   uint64_t DerefBytes = 0;
     689             :   uint64_t DerefOrNullBytes = 0;
     690             :   uint64_t AllocSizeArgs = 0;
     691             : 
     692             : public:
     693    10290951 :   AttrBuilder() = default;
     694           6 :   AttrBuilder(const Attribute &A) {
     695           2 :     addAttribute(A);
     696             :   }
     697             :   AttrBuilder(AttributeList AS, unsigned Idx);
     698             :   AttrBuilder(AttributeSet AS);
     699             : 
     700             :   void clear();
     701             : 
     702             :   /// \brief Add an attribute to the builder.
     703             :   AttrBuilder &addAttribute(Attribute::AttrKind Val);
     704             : 
     705             :   /// \brief Add the Attribute object to the builder.
     706             :   AttrBuilder &addAttribute(Attribute A);
     707             : 
     708             :   /// \brief Add the target-dependent attribute to the builder.
     709             :   AttrBuilder &addAttribute(StringRef A, StringRef V = StringRef());
     710             : 
     711             :   /// \brief Remove an attribute from the builder.
     712             :   AttrBuilder &removeAttribute(Attribute::AttrKind Val);
     713             : 
     714             :   /// \brief Remove the attributes from the builder.
     715             :   AttrBuilder &removeAttributes(AttributeList A, uint64_t WithoutIndex);
     716             : 
     717             :   /// \brief Remove the target-dependent attribute to the builder.
     718             :   AttrBuilder &removeAttribute(StringRef A);
     719             : 
     720             :   /// \brief Add the attributes from the builder.
     721             :   AttrBuilder &merge(const AttrBuilder &B);
     722             : 
     723             :   /// \brief Remove the attributes from the builder.
     724             :   AttrBuilder &remove(const AttrBuilder &B);
     725             : 
     726             :   /// \brief Return true if the builder has any attribute that's in the
     727             :   /// specified builder.
     728             :   bool overlaps(const AttrBuilder &B) const;
     729             : 
     730             :   /// \brief Return true if the builder has the specified attribute.
     731             :   bool contains(Attribute::AttrKind A) const {
     732             :     assert((unsigned)A < Attribute::EndAttrKinds && "Attribute out of range!");
     733   350125072 :     return Attrs[A];
     734             :   }
     735             : 
     736             :   /// \brief Return true if the builder has the specified target-dependent
     737             :   /// attribute.
     738             :   bool contains(StringRef A) const;
     739             : 
     740             :   /// \brief Return true if the builder has IR-level attributes.
     741             :   bool hasAttributes() const;
     742             : 
     743             :   /// \brief Return true if the builder has any attribute that's in the
     744             :   /// specified attribute.
     745             :   bool hasAttributes(AttributeList A, uint64_t Index) const;
     746             : 
     747             :   /// \brief Return true if the builder has an alignment attribute.
     748             :   bool hasAlignmentAttr() const;
     749             : 
     750             :   /// \brief Retrieve the alignment attribute, if it exists.
     751             :   uint64_t getAlignment() const { return Alignment; }
     752             : 
     753             :   /// \brief Retrieve the stack alignment attribute, if it exists.
     754             :   uint64_t getStackAlignment() const { return StackAlignment; }
     755             : 
     756             :   /// \brief Retrieve the number of dereferenceable bytes, if the
     757             :   /// dereferenceable attribute exists (zero is returned otherwise).
     758             :   uint64_t getDereferenceableBytes() const { return DerefBytes; }
     759             : 
     760             :   /// \brief Retrieve the number of dereferenceable_or_null bytes, if the
     761             :   /// dereferenceable_or_null attribute exists (zero is returned otherwise).
     762             :   uint64_t getDereferenceableOrNullBytes() const { return DerefOrNullBytes; }
     763             : 
     764             :   /// Retrieve the allocsize args, if the allocsize attribute exists.  If it
     765             :   /// doesn't exist, pair(0, 0) is returned.
     766             :   std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
     767             : 
     768             :   /// \brief This turns an int alignment (which must be a power of 2) into the
     769             :   /// form used internally in Attribute.
     770             :   AttrBuilder &addAlignmentAttr(unsigned Align);
     771             : 
     772             :   /// \brief This turns an int stack alignment (which must be a power of 2) into
     773             :   /// the form used internally in Attribute.
     774             :   AttrBuilder &addStackAlignmentAttr(unsigned Align);
     775             : 
     776             :   /// \brief This turns the number of dereferenceable bytes into the form used
     777             :   /// internally in Attribute.
     778             :   AttrBuilder &addDereferenceableAttr(uint64_t Bytes);
     779             : 
     780             :   /// \brief This turns the number of dereferenceable_or_null bytes into the
     781             :   /// form used internally in Attribute.
     782             :   AttrBuilder &addDereferenceableOrNullAttr(uint64_t Bytes);
     783             : 
     784             :   /// This turns one (or two) ints into the form used internally in Attribute.
     785             :   AttrBuilder &addAllocSizeAttr(unsigned ElemSizeArg,
     786             :                                 const Optional<unsigned> &NumElemsArg);
     787             : 
     788             :   /// Add an allocsize attribute, using the representation returned by
     789             :   /// Attribute.getIntValue().
     790             :   AttrBuilder &addAllocSizeAttrFromRawRepr(uint64_t RawAllocSizeRepr);
     791             : 
     792             :   /// \brief Return true if the builder contains no target-independent
     793             :   /// attributes.
     794        1792 :   bool empty() const { return Attrs.none(); }
     795             : 
     796             :   // Iterators for target-dependent attributes.
     797             :   using td_type = std::pair<std::string, std::string>;
     798             :   using td_iterator = std::map<std::string, std::string>::iterator;
     799             :   using td_const_iterator = std::map<std::string, std::string>::const_iterator;
     800             :   using td_range = iterator_range<td_iterator>;
     801             :   using td_const_range = iterator_range<td_const_iterator>;
     802             : 
     803         168 :   td_iterator td_begin()             { return TargetDepAttrs.begin(); }
     804         168 :   td_iterator td_end()               { return TargetDepAttrs.end(); }
     805             : 
     806     8482346 :   td_const_iterator td_begin() const { return TargetDepAttrs.begin(); }
     807     8482346 :   td_const_iterator td_end() const   { return TargetDepAttrs.end(); }
     808             : 
     809         252 :   td_range td_attrs() { return td_range(td_begin(), td_end()); }
     810             :   td_const_range td_attrs() const {
     811    12723519 :     return td_const_range(td_begin(), td_end());
     812             :   }
     813             : 
     814             :   bool td_empty() const              { return TargetDepAttrs.empty(); }
     815             : 
     816             :   bool operator==(const AttrBuilder &B);
     817             :   bool operator!=(const AttrBuilder &B) {
     818         382 :     return !(*this == B);
     819             :   }
     820             : };
     821             : 
     822             : namespace AttributeFuncs {
     823             : 
     824             : /// \brief Which attributes cannot be applied to a type.
     825             : AttrBuilder typeIncompatible(Type *Ty);
     826             : 
     827             : /// \returns Return true if the two functions have compatible target-independent
     828             : /// attributes for inlining purposes.
     829             : bool areInlineCompatible(const Function &Caller, const Function &Callee);
     830             : 
     831             : /// \brief Merge caller's and callee's attributes.
     832             : void mergeAttributesForInlining(Function &Caller, const Function &Callee);
     833             : 
     834             : } // end namespace AttributeFuncs
     835             : 
     836             : } // end namespace llvm
     837             : 
     838             : #endif // LLVM_IR_ATTRIBUTES_H

Generated by: LCOV version 1.13