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