| /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\ |
| |* *| |
| |* Attribute classes' definitions *| |
| |* *| |
| |* Automatically generated file, do not edit! *| |
| |* *| |
| \*===----------------------------------------------------------------------===*/ |
| |
| #ifndef LLVM_CLANG_ATTR_CLASSES_INC |
| #define LLVM_CLANG_ATTR_CLASSES_INC |
| |
| static inline void DelimitAttributeArgument(raw_ostream& OS, bool& IsFirst) { |
| if (IsFirst) { |
| IsFirst = false; |
| OS << "("; |
| } else |
| OS << ", "; |
| } |
| class AArch64VectorPcsAttr : public InheritableAttr { |
| public: |
| enum Spelling { |
| GNU_aarch64_vector_pcs = 0, |
| CXX11_clang_aarch64_vector_pcs = 1, |
| C2x_clang_aarch64_vector_pcs = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AArch64VectorPcsAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AArch64VectorPcsAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static AArch64VectorPcsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AArch64VectorPcsAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AArch64VectorPcsAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| AArch64VectorPcsAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AArch64VectorPcs; } |
| }; |
| |
| class AMDGPUFlatWorkGroupSizeAttr : public InheritableAttr { |
| Expr * min; |
| |
| Expr * max; |
| |
| public: |
| enum Spelling { |
| GNU_amdgpu_flat_work_group_size = 0, |
| CXX11_clang_amdgpu_flat_work_group_size = 1, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AMDGPUFlatWorkGroupSizeAttr *CreateImplicit(ASTContext &Ctx, Expr * Min, Expr * Max, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AMDGPUFlatWorkGroupSizeAttr *Create(ASTContext &Ctx, Expr * Min, Expr * Max, const AttributeCommonInfo &CommonInfo); |
| static AMDGPUFlatWorkGroupSizeAttr *CreateImplicit(ASTContext &Ctx, Expr * Min, Expr * Max, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AMDGPUFlatWorkGroupSizeAttr *Create(ASTContext &Ctx, Expr * Min, Expr * Max, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AMDGPUFlatWorkGroupSizeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , Expr * Min |
| , Expr * Max |
| ); |
| |
| AMDGPUFlatWorkGroupSizeAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| Expr * getMin() const { |
| return min; |
| } |
| |
| Expr * getMax() const { |
| return max; |
| } |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUFlatWorkGroupSize; } |
| }; |
| |
| class AMDGPUNumSGPRAttr : public InheritableAttr { |
| unsigned numSGPR; |
| |
| public: |
| enum Spelling { |
| GNU_amdgpu_num_sgpr = 0, |
| CXX11_clang_amdgpu_num_sgpr = 1, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AMDGPUNumSGPRAttr *CreateImplicit(ASTContext &Ctx, unsigned NumSGPR, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AMDGPUNumSGPRAttr *Create(ASTContext &Ctx, unsigned NumSGPR, const AttributeCommonInfo &CommonInfo); |
| static AMDGPUNumSGPRAttr *CreateImplicit(ASTContext &Ctx, unsigned NumSGPR, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AMDGPUNumSGPRAttr *Create(ASTContext &Ctx, unsigned NumSGPR, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AMDGPUNumSGPRAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , unsigned NumSGPR |
| ); |
| |
| AMDGPUNumSGPRAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| unsigned getNumSGPR() const { |
| return numSGPR; |
| } |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUNumSGPR; } |
| }; |
| |
| class AMDGPUNumVGPRAttr : public InheritableAttr { |
| unsigned numVGPR; |
| |
| public: |
| enum Spelling { |
| GNU_amdgpu_num_vgpr = 0, |
| CXX11_clang_amdgpu_num_vgpr = 1, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AMDGPUNumVGPRAttr *CreateImplicit(ASTContext &Ctx, unsigned NumVGPR, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AMDGPUNumVGPRAttr *Create(ASTContext &Ctx, unsigned NumVGPR, const AttributeCommonInfo &CommonInfo); |
| static AMDGPUNumVGPRAttr *CreateImplicit(ASTContext &Ctx, unsigned NumVGPR, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AMDGPUNumVGPRAttr *Create(ASTContext &Ctx, unsigned NumVGPR, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AMDGPUNumVGPRAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , unsigned NumVGPR |
| ); |
| |
| AMDGPUNumVGPRAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| unsigned getNumVGPR() const { |
| return numVGPR; |
| } |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUNumVGPR; } |
| }; |
| |
| class AMDGPUWavesPerEUAttr : public InheritableAttr { |
| Expr * min; |
| |
| Expr * max; |
| |
| public: |
| enum Spelling { |
| GNU_amdgpu_waves_per_eu = 0, |
| CXX11_clang_amdgpu_waves_per_eu = 1, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AMDGPUWavesPerEUAttr *CreateImplicit(ASTContext &Ctx, Expr * Min, Expr * Max, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AMDGPUWavesPerEUAttr *Create(ASTContext &Ctx, Expr * Min, Expr * Max, const AttributeCommonInfo &CommonInfo); |
| static AMDGPUWavesPerEUAttr *CreateImplicit(ASTContext &Ctx, Expr * Min, Expr * Max, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AMDGPUWavesPerEUAttr *Create(ASTContext &Ctx, Expr * Min, Expr * Max, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AMDGPUWavesPerEUAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , Expr * Min |
| , Expr * Max |
| ); |
| AMDGPUWavesPerEUAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , Expr * Min |
| ); |
| |
| AMDGPUWavesPerEUAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| Expr * getMin() const { |
| return min; |
| } |
| |
| Expr * getMax() const { |
| return max; |
| } |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUWavesPerEU; } |
| }; |
| |
| class ARMInterruptAttr : public InheritableAttr { |
| public: |
| enum InterruptType { |
| IRQ, |
| FIQ, |
| SWI, |
| ABORT, |
| UNDEF, |
| Generic |
| }; |
| private: |
| InterruptType interrupt; |
| |
| public: |
| enum Spelling { |
| GNU_interrupt = 0, |
| CXX11_gnu_interrupt = 1, |
| C2x_gnu_interrupt = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static ARMInterruptAttr *CreateImplicit(ASTContext &Ctx, InterruptType Interrupt, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static ARMInterruptAttr *Create(ASTContext &Ctx, InterruptType Interrupt, const AttributeCommonInfo &CommonInfo); |
| static ARMInterruptAttr *CreateImplicit(ASTContext &Ctx, InterruptType Interrupt, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static ARMInterruptAttr *Create(ASTContext &Ctx, InterruptType Interrupt, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| ARMInterruptAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , InterruptType Interrupt |
| ); |
| ARMInterruptAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| ARMInterruptAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| InterruptType getInterrupt() const { |
| return interrupt; |
| } |
| |
| static bool ConvertStrToInterruptType(StringRef Val, InterruptType &Out); |
| static const char *ConvertInterruptTypeToStr(InterruptType Val); |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::ARMInterrupt; } |
| }; |
| |
| class AVRInterruptAttr : public InheritableAttr { |
| public: |
| enum Spelling { |
| GNU_interrupt = 0, |
| CXX11_gnu_interrupt = 1, |
| C2x_gnu_interrupt = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AVRInterruptAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AVRInterruptAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static AVRInterruptAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AVRInterruptAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AVRInterruptAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| AVRInterruptAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AVRInterrupt; } |
| }; |
| |
| class AVRSignalAttr : public InheritableAttr { |
| public: |
| enum Spelling { |
| GNU_signal = 0, |
| CXX11_gnu_signal = 1, |
| C2x_gnu_signal = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AVRSignalAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AVRSignalAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static AVRSignalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AVRSignalAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AVRSignalAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| AVRSignalAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AVRSignal; } |
| }; |
| |
| class AbiTagAttr : public Attr { |
| unsigned tags_Size; |
| StringRef *tags_; |
| |
| public: |
| enum Spelling { |
| GNU_abi_tag = 0, |
| CXX11_gnu_abi_tag = 1, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AbiTagAttr *CreateImplicit(ASTContext &Ctx, StringRef *Tags, unsigned TagsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AbiTagAttr *Create(ASTContext &Ctx, StringRef *Tags, unsigned TagsSize, const AttributeCommonInfo &CommonInfo); |
| static AbiTagAttr *CreateImplicit(ASTContext &Ctx, StringRef *Tags, unsigned TagsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AbiTagAttr *Create(ASTContext &Ctx, StringRef *Tags, unsigned TagsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AbiTagAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , StringRef *Tags, unsigned TagsSize |
| ); |
| AbiTagAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| AbiTagAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| typedef StringRef* tags_iterator; |
| tags_iterator tags_begin() const { return tags_; } |
| tags_iterator tags_end() const { return tags_ + tags_Size; } |
| unsigned tags_size() const { return tags_Size; } |
| llvm::iterator_range<tags_iterator> tags() const { return llvm::make_range(tags_begin(), tags_end()); } |
| |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AbiTag; } |
| }; |
| |
| class AcquireCapabilityAttr : public InheritableAttr { |
| unsigned args_Size; |
| Expr * *args_; |
| |
| public: |
| enum Spelling { |
| GNU_acquire_capability = 0, |
| CXX11_clang_acquire_capability = 1, |
| GNU_acquire_shared_capability = 2, |
| CXX11_clang_acquire_shared_capability = 3, |
| GNU_exclusive_lock_function = 4, |
| GNU_shared_lock_function = 5, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AcquireCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AcquireCapabilityAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo); |
| static AcquireCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax, AcquireCapabilityAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)); |
| static AcquireCapabilityAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax, AcquireCapabilityAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)); |
| |
| // Constructors |
| AcquireCapabilityAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , Expr * *Args, unsigned ArgsSize |
| ); |
| AcquireCapabilityAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| AcquireCapabilityAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| Spelling getSemanticSpelling() const; |
| bool isShared() const { return getAttributeSpellingListIndex() == 2 || |
| getAttributeSpellingListIndex() == 3 || |
| getAttributeSpellingListIndex() == 5; } |
| typedef Expr ** args_iterator; |
| args_iterator args_begin() const { return args_; } |
| args_iterator args_end() const { return args_ + args_Size; } |
| unsigned args_size() const { return args_Size; } |
| llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } |
| |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AcquireCapability; } |
| }; |
| |
| class AcquireHandleAttr : public InheritableAttr { |
| unsigned handleTypeLength; |
| char *handleType; |
| |
| public: |
| enum Spelling { |
| GNU_acquire_handle = 0, |
| CXX11_clang_acquire_handle = 1, |
| C2x_clang_acquire_handle = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AcquireHandleAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef HandleType, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AcquireHandleAttr *Create(ASTContext &Ctx, llvm::StringRef HandleType, const AttributeCommonInfo &CommonInfo); |
| static AcquireHandleAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef HandleType, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AcquireHandleAttr *Create(ASTContext &Ctx, llvm::StringRef HandleType, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AcquireHandleAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , llvm::StringRef HandleType |
| ); |
| |
| AcquireHandleAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| llvm::StringRef getHandleType() const { |
| return llvm::StringRef(handleType, handleTypeLength); |
| } |
| unsigned getHandleTypeLength() const { |
| return handleTypeLength; |
| } |
| void setHandleType(ASTContext &C, llvm::StringRef S) { |
| handleTypeLength = S.size(); |
| this->handleType = new (C, 1) char [handleTypeLength]; |
| if (!S.empty()) |
| std::memcpy(this->handleType, S.data(), handleTypeLength); |
| } |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AcquireHandle; } |
| }; |
| |
| class AcquiredAfterAttr : public InheritableAttr { |
| unsigned args_Size; |
| Expr * *args_; |
| |
| public: |
| // Factory methods |
| static AcquiredAfterAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AcquiredAfterAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo); |
| static AcquiredAfterAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AcquiredAfterAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AcquiredAfterAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , Expr * *Args, unsigned ArgsSize |
| ); |
| AcquiredAfterAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| AcquiredAfterAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| typedef Expr ** args_iterator; |
| args_iterator args_begin() const { return args_; } |
| args_iterator args_end() const { return args_ + args_Size; } |
| unsigned args_size() const { return args_Size; } |
| llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } |
| |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AcquiredAfter; } |
| }; |
| |
| class AcquiredBeforeAttr : public InheritableAttr { |
| unsigned args_Size; |
| Expr * *args_; |
| |
| public: |
| // Factory methods |
| static AcquiredBeforeAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AcquiredBeforeAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo); |
| static AcquiredBeforeAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AcquiredBeforeAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AcquiredBeforeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , Expr * *Args, unsigned ArgsSize |
| ); |
| AcquiredBeforeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| AcquiredBeforeAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| typedef Expr ** args_iterator; |
| args_iterator args_begin() const { return args_; } |
| args_iterator args_end() const { return args_ + args_Size; } |
| unsigned args_size() const { return args_Size; } |
| llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } |
| |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AcquiredBefore; } |
| }; |
| |
| class AddressSpaceAttr : public TypeAttr { |
| int addressSpace; |
| |
| public: |
| enum Spelling { |
| GNU_address_space = 0, |
| CXX11_clang_address_space = 1, |
| C2x_clang_address_space = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AddressSpaceAttr *CreateImplicit(ASTContext &Ctx, int AddressSpace, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AddressSpaceAttr *Create(ASTContext &Ctx, int AddressSpace, const AttributeCommonInfo &CommonInfo); |
| static AddressSpaceAttr *CreateImplicit(ASTContext &Ctx, int AddressSpace, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AddressSpaceAttr *Create(ASTContext &Ctx, int AddressSpace, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AddressSpaceAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , int AddressSpace |
| ); |
| |
| AddressSpaceAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| int getAddressSpace() const { |
| return addressSpace; |
| } |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AddressSpace; } |
| }; |
| |
| class AliasAttr : public Attr { |
| unsigned aliaseeLength; |
| char *aliasee; |
| |
| public: |
| enum Spelling { |
| GNU_alias = 0, |
| CXX11_gnu_alias = 1, |
| C2x_gnu_alias = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AliasAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Aliasee, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AliasAttr *Create(ASTContext &Ctx, llvm::StringRef Aliasee, const AttributeCommonInfo &CommonInfo); |
| static AliasAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Aliasee, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AliasAttr *Create(ASTContext &Ctx, llvm::StringRef Aliasee, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AliasAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , llvm::StringRef Aliasee |
| ); |
| |
| AliasAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| llvm::StringRef getAliasee() const { |
| return llvm::StringRef(aliasee, aliaseeLength); |
| } |
| unsigned getAliaseeLength() const { |
| return aliaseeLength; |
| } |
| void setAliasee(ASTContext &C, llvm::StringRef S) { |
| aliaseeLength = S.size(); |
| this->aliasee = new (C, 1) char [aliaseeLength]; |
| if (!S.empty()) |
| std::memcpy(this->aliasee, S.data(), aliaseeLength); |
| } |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::Alias; } |
| }; |
| |
| class AlignMac68kAttr : public InheritableAttr { |
| public: |
| // Factory methods |
| static AlignMac68kAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AlignMac68kAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static AlignMac68kAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AlignMac68kAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AlignMac68kAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| AlignMac68kAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AlignMac68k; } |
| }; |
| |
| class AlignNaturalAttr : public InheritableAttr { |
| public: |
| // Factory methods |
| static AlignNaturalAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AlignNaturalAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static AlignNaturalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AlignNaturalAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AlignNaturalAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| AlignNaturalAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AlignNatural; } |
| }; |
| |
| class AlignValueAttr : public Attr { |
| Expr * alignment; |
| |
| public: |
| // Factory methods |
| static AlignValueAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AlignValueAttr *Create(ASTContext &Ctx, Expr * Alignment, const AttributeCommonInfo &CommonInfo); |
| static AlignValueAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AlignValueAttr *Create(ASTContext &Ctx, Expr * Alignment, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AlignValueAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , Expr * Alignment |
| ); |
| |
| AlignValueAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| Expr * getAlignment() const { |
| return alignment; |
| } |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AlignValue; } |
| }; |
| |
| class AlignedAttr : public InheritableAttr { |
| bool isalignmentExpr; |
| union { |
| Expr *alignmentExpr; |
| TypeSourceInfo *alignmentType; |
| }; |
| |
| public: |
| enum Spelling { |
| GNU_aligned = 0, |
| CXX11_gnu_aligned = 1, |
| C2x_gnu_aligned = 2, |
| Declspec_align = 3, |
| Keyword_alignas = 4, |
| Keyword_Alignas = 5, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AlignedAttr *CreateImplicit(ASTContext &Ctx, bool IsAlignmentExpr, void *Alignment, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AlignedAttr *Create(ASTContext &Ctx, bool IsAlignmentExpr, void *Alignment, const AttributeCommonInfo &CommonInfo); |
| static AlignedAttr *CreateImplicit(ASTContext &Ctx, bool IsAlignmentExpr, void *Alignment, SourceRange Range, AttributeCommonInfo::Syntax Syntax, AlignedAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)); |
| static AlignedAttr *Create(ASTContext &Ctx, bool IsAlignmentExpr, void *Alignment, SourceRange Range, AttributeCommonInfo::Syntax Syntax, AlignedAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)); |
| |
| // Constructors |
| AlignedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , bool IsAlignmentExpr, void *Alignment |
| ); |
| AlignedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| AlignedAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| Spelling getSemanticSpelling() const; |
| bool isGNU() const { return getAttributeSpellingListIndex() == 0 || |
| getAttributeSpellingListIndex() == 1 || |
| getAttributeSpellingListIndex() == 2; } |
| bool isC11() const { return getAttributeSpellingListIndex() == 5; } |
| bool isAlignas() const { return getAttributeSpellingListIndex() == 4 || |
| getAttributeSpellingListIndex() == 5; } |
| bool isDeclspec() const { return getAttributeSpellingListIndex() == 3; } |
| bool isAlignmentDependent() const; |
| bool isAlignmentErrorDependent() const; |
| unsigned getAlignment(ASTContext &Ctx) const; |
| bool isAlignmentExpr() const { |
| return isalignmentExpr; |
| } |
| Expr *getAlignmentExpr() const { |
| assert(isalignmentExpr); |
| return alignmentExpr; |
| } |
| TypeSourceInfo *getAlignmentType() const { |
| assert(!isalignmentExpr); |
| return alignmentType; |
| } |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::Aligned; } |
| }; |
| |
| class AllocAlignAttr : public InheritableAttr { |
| ParamIdx paramIndex; |
| |
| public: |
| enum Spelling { |
| GNU_alloc_align = 0, |
| CXX11_gnu_alloc_align = 1, |
| C2x_gnu_alloc_align = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AllocAlignAttr *CreateImplicit(ASTContext &Ctx, ParamIdx ParamIndex, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AllocAlignAttr *Create(ASTContext &Ctx, ParamIdx ParamIndex, const AttributeCommonInfo &CommonInfo); |
| static AllocAlignAttr *CreateImplicit(ASTContext &Ctx, ParamIdx ParamIndex, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AllocAlignAttr *Create(ASTContext &Ctx, ParamIdx ParamIndex, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AllocAlignAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , ParamIdx ParamIndex |
| ); |
| |
| AllocAlignAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| ParamIdx getParamIndex() const { |
| return paramIndex; |
| } |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AllocAlign; } |
| }; |
| |
| class AllocSizeAttr : public InheritableAttr { |
| ParamIdx elemSizeParam; |
| |
| ParamIdx numElemsParam; |
| |
| public: |
| enum Spelling { |
| GNU_alloc_size = 0, |
| CXX11_gnu_alloc_size = 1, |
| C2x_gnu_alloc_size = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AllocSizeAttr *CreateImplicit(ASTContext &Ctx, ParamIdx ElemSizeParam, ParamIdx NumElemsParam, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AllocSizeAttr *Create(ASTContext &Ctx, ParamIdx ElemSizeParam, ParamIdx NumElemsParam, const AttributeCommonInfo &CommonInfo); |
| static AllocSizeAttr *CreateImplicit(ASTContext &Ctx, ParamIdx ElemSizeParam, ParamIdx NumElemsParam, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AllocSizeAttr *Create(ASTContext &Ctx, ParamIdx ElemSizeParam, ParamIdx NumElemsParam, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AllocSizeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , ParamIdx ElemSizeParam |
| , ParamIdx NumElemsParam |
| ); |
| AllocSizeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , ParamIdx ElemSizeParam |
| ); |
| |
| AllocSizeAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| ParamIdx getElemSizeParam() const { |
| return elemSizeParam; |
| } |
| |
| ParamIdx getNumElemsParam() const { |
| return numElemsParam; |
| } |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AllocSize; } |
| }; |
| |
| class AlwaysDestroyAttr : public InheritableAttr { |
| public: |
| enum Spelling { |
| GNU_always_destroy = 0, |
| CXX11_clang_always_destroy = 1, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AlwaysDestroyAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AlwaysDestroyAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static AlwaysDestroyAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AlwaysDestroyAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AlwaysDestroyAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| AlwaysDestroyAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AlwaysDestroy; } |
| }; |
| |
| class AlwaysInlineAttr : public InheritableAttr { |
| public: |
| enum Spelling { |
| GNU_always_inline = 0, |
| CXX11_gnu_always_inline = 1, |
| C2x_gnu_always_inline = 2, |
| Keyword_forceinline = 3, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AlwaysInlineAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AlwaysInlineAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static AlwaysInlineAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax, AlwaysInlineAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)); |
| static AlwaysInlineAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax, AlwaysInlineAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)); |
| |
| // Constructors |
| AlwaysInlineAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| AlwaysInlineAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| Spelling getSemanticSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AlwaysInline; } |
| }; |
| |
| class AnalyzerNoReturnAttr : public InheritableAttr { |
| public: |
| // Factory methods |
| static AnalyzerNoReturnAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AnalyzerNoReturnAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static AnalyzerNoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AnalyzerNoReturnAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AnalyzerNoReturnAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| AnalyzerNoReturnAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AnalyzerNoReturn; } |
| }; |
| |
| class AnnotateAttr : public InheritableParamAttr { |
| unsigned annotationLength; |
| char *annotation; |
| |
| unsigned args_Size; |
| Expr * *args_; |
| |
| public: |
| enum Spelling { |
| GNU_annotate = 0, |
| CXX11_clang_annotate = 1, |
| C2x_clang_annotate = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AnnotateAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Annotation, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AnnotateAttr *Create(ASTContext &Ctx, llvm::StringRef Annotation, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo); |
| static AnnotateAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Annotation, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AnnotateAttr *Create(ASTContext &Ctx, llvm::StringRef Annotation, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AnnotateAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , llvm::StringRef Annotation |
| , Expr * *Args, unsigned ArgsSize |
| ); |
| AnnotateAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , llvm::StringRef Annotation |
| ); |
| |
| AnnotateAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| llvm::StringRef getAnnotation() const { |
| return llvm::StringRef(annotation, annotationLength); |
| } |
| unsigned getAnnotationLength() const { |
| return annotationLength; |
| } |
| void setAnnotation(ASTContext &C, llvm::StringRef S) { |
| annotationLength = S.size(); |
| this->annotation = new (C, 1) char [annotationLength]; |
| if (!S.empty()) |
| std::memcpy(this->annotation, S.data(), annotationLength); |
| } |
| |
| typedef Expr ** args_iterator; |
| args_iterator args_begin() const { return args_; } |
| args_iterator args_end() const { return args_ + args_Size; } |
| unsigned args_size() const { return args_Size; } |
| llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } |
| |
| |
| |
| static AnnotateAttr *Create(ASTContext &Ctx, llvm::StringRef Annotation, \ |
| const AttributeCommonInfo &CommonInfo) { |
| return AnnotateAttr::Create(Ctx, Annotation, nullptr, 0, CommonInfo); |
| } |
| static AnnotateAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Annotation, \ |
| const AttributeCommonInfo &CommonInfo = {SourceRange{}}) { |
| return AnnotateAttr::CreateImplicit(Ctx, Annotation, nullptr, 0, CommonInfo); |
| } |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::Annotate; } |
| }; |
| |
| class AnyX86InterruptAttr : public InheritableAttr { |
| public: |
| enum Spelling { |
| GNU_interrupt = 0, |
| CXX11_gnu_interrupt = 1, |
| C2x_gnu_interrupt = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AnyX86InterruptAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AnyX86InterruptAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static AnyX86InterruptAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AnyX86InterruptAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AnyX86InterruptAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| AnyX86InterruptAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AnyX86Interrupt; } |
| }; |
| |
| class AnyX86NoCallerSavedRegistersAttr : public InheritableAttr { |
| public: |
| enum Spelling { |
| GNU_no_caller_saved_registers = 0, |
| CXX11_gnu_no_caller_saved_registers = 1, |
| C2x_gnu_no_caller_saved_registers = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AnyX86NoCallerSavedRegistersAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AnyX86NoCallerSavedRegistersAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static AnyX86NoCallerSavedRegistersAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AnyX86NoCallerSavedRegistersAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AnyX86NoCallerSavedRegistersAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| AnyX86NoCallerSavedRegistersAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AnyX86NoCallerSavedRegisters; } |
| }; |
| |
| class AnyX86NoCfCheckAttr : public InheritableAttr { |
| public: |
| enum Spelling { |
| GNU_nocf_check = 0, |
| CXX11_gnu_nocf_check = 1, |
| C2x_gnu_nocf_check = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AnyX86NoCfCheckAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AnyX86NoCfCheckAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static AnyX86NoCfCheckAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AnyX86NoCfCheckAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AnyX86NoCfCheckAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| AnyX86NoCfCheckAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AnyX86NoCfCheck; } |
| }; |
| |
| class ArcWeakrefUnavailableAttr : public InheritableAttr { |
| public: |
| enum Spelling { |
| GNU_objc_arc_weak_reference_unavailable = 0, |
| CXX11_clang_objc_arc_weak_reference_unavailable = 1, |
| C2x_clang_objc_arc_weak_reference_unavailable = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static ArcWeakrefUnavailableAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static ArcWeakrefUnavailableAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static ArcWeakrefUnavailableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static ArcWeakrefUnavailableAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| ArcWeakrefUnavailableAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| ArcWeakrefUnavailableAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::ArcWeakrefUnavailable; } |
| }; |
| |
| class ArgumentWithTypeTagAttr : public InheritableAttr { |
| IdentifierInfo * argumentKind; |
| |
| ParamIdx argumentIdx; |
| |
| ParamIdx typeTagIdx; |
| |
| bool isPointer; |
| |
| public: |
| enum Spelling { |
| GNU_argument_with_type_tag = 0, |
| CXX11_clang_argument_with_type_tag = 1, |
| C2x_clang_argument_with_type_tag = 2, |
| GNU_pointer_with_type_tag = 3, |
| CXX11_clang_pointer_with_type_tag = 4, |
| C2x_clang_pointer_with_type_tag = 5, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static ArgumentWithTypeTagAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * ArgumentKind, ParamIdx ArgumentIdx, ParamIdx TypeTagIdx, bool IsPointer, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static ArgumentWithTypeTagAttr *Create(ASTContext &Ctx, IdentifierInfo * ArgumentKind, ParamIdx ArgumentIdx, ParamIdx TypeTagIdx, bool IsPointer, const AttributeCommonInfo &CommonInfo); |
| static ArgumentWithTypeTagAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * ArgumentKind, ParamIdx ArgumentIdx, ParamIdx TypeTagIdx, bool IsPointer, SourceRange Range, AttributeCommonInfo::Syntax Syntax, ArgumentWithTypeTagAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)); |
| static ArgumentWithTypeTagAttr *Create(ASTContext &Ctx, IdentifierInfo * ArgumentKind, ParamIdx ArgumentIdx, ParamIdx TypeTagIdx, bool IsPointer, SourceRange Range, AttributeCommonInfo::Syntax Syntax, ArgumentWithTypeTagAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)); |
| static ArgumentWithTypeTagAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * ArgumentKind, ParamIdx ArgumentIdx, ParamIdx TypeTagIdx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static ArgumentWithTypeTagAttr *Create(ASTContext &Ctx, IdentifierInfo * ArgumentKind, ParamIdx ArgumentIdx, ParamIdx TypeTagIdx, const AttributeCommonInfo &CommonInfo); |
| static ArgumentWithTypeTagAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * ArgumentKind, ParamIdx ArgumentIdx, ParamIdx TypeTagIdx, SourceRange Range, AttributeCommonInfo::Syntax Syntax, ArgumentWithTypeTagAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)); |
| static ArgumentWithTypeTagAttr *Create(ASTContext &Ctx, IdentifierInfo * ArgumentKind, ParamIdx ArgumentIdx, ParamIdx TypeTagIdx, SourceRange Range, AttributeCommonInfo::Syntax Syntax, ArgumentWithTypeTagAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)); |
| |
| // Constructors |
| ArgumentWithTypeTagAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , IdentifierInfo * ArgumentKind |
| , ParamIdx ArgumentIdx |
| , ParamIdx TypeTagIdx |
| , bool IsPointer |
| ); |
| ArgumentWithTypeTagAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , IdentifierInfo * ArgumentKind |
| , ParamIdx ArgumentIdx |
| , ParamIdx TypeTagIdx |
| ); |
| |
| ArgumentWithTypeTagAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| Spelling getSemanticSpelling() const; |
| IdentifierInfo * getArgumentKind() const { |
| return argumentKind; |
| } |
| |
| ParamIdx getArgumentIdx() const { |
| return argumentIdx; |
| } |
| |
| ParamIdx getTypeTagIdx() const { |
| return typeTagIdx; |
| } |
| |
| bool getIsPointer() const { |
| return isPointer; |
| } |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::ArgumentWithTypeTag; } |
| }; |
| |
| class ArmBuiltinAliasAttr : public InheritableAttr { |
| IdentifierInfo * builtinName; |
| |
| public: |
| enum Spelling { |
| GNU_clang_arm_builtin_alias = 0, |
| CXX11_clang_clang_arm_builtin_alias = 1, |
| C2x_clang_clang_arm_builtin_alias = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static ArmBuiltinAliasAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * BuiltinName, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static ArmBuiltinAliasAttr *Create(ASTContext &Ctx, IdentifierInfo * BuiltinName, const AttributeCommonInfo &CommonInfo); |
| static ArmBuiltinAliasAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * BuiltinName, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static ArmBuiltinAliasAttr *Create(ASTContext &Ctx, IdentifierInfo * BuiltinName, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| ArmBuiltinAliasAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , IdentifierInfo * BuiltinName |
| ); |
| |
| ArmBuiltinAliasAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| IdentifierInfo * getBuiltinName() const { |
| return builtinName; |
| } |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::ArmBuiltinAlias; } |
| }; |
| |
| class ArmMveStrictPolymorphismAttr : public TypeAttr { |
| public: |
| enum Spelling { |
| GNU_clang_arm_mve_strict_polymorphism = 0, |
| CXX11_clang_clang_arm_mve_strict_polymorphism = 1, |
| C2x_clang_clang_arm_mve_strict_polymorphism = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static ArmMveStrictPolymorphismAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static ArmMveStrictPolymorphismAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static ArmMveStrictPolymorphismAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static ArmMveStrictPolymorphismAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| ArmMveStrictPolymorphismAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| ArmMveStrictPolymorphismAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::ArmMveStrictPolymorphism; } |
| }; |
| |
| class ArtificialAttr : public InheritableAttr { |
| public: |
| enum Spelling { |
| GNU_artificial = 0, |
| CXX11_gnu_artificial = 1, |
| C2x_gnu_artificial = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static ArtificialAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static ArtificialAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static ArtificialAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static ArtificialAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| ArtificialAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| ArtificialAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::Artificial; } |
| }; |
| |
| class AsmLabelAttr : public InheritableAttr { |
| unsigned labelLength; |
| char *label; |
| |
| bool isLiteralLabel; |
| |
| public: |
| enum Spelling { |
| Keyword_asm = 0, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AsmLabelAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Label, bool IsLiteralLabel, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AsmLabelAttr *Create(ASTContext &Ctx, llvm::StringRef Label, bool IsLiteralLabel, const AttributeCommonInfo &CommonInfo); |
| static AsmLabelAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Label, bool IsLiteralLabel, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AsmLabelAttr *Create(ASTContext &Ctx, llvm::StringRef Label, bool IsLiteralLabel, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AsmLabelAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Label, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AsmLabelAttr *Create(ASTContext &Ctx, llvm::StringRef Label, const AttributeCommonInfo &CommonInfo); |
| static AsmLabelAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Label, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AsmLabelAttr *Create(ASTContext &Ctx, llvm::StringRef Label, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AsmLabelAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , llvm::StringRef Label |
| , bool IsLiteralLabel |
| ); |
| AsmLabelAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , llvm::StringRef Label |
| ); |
| |
| AsmLabelAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| llvm::StringRef getLabel() const { |
| return llvm::StringRef(label, labelLength); |
| } |
| unsigned getLabelLength() const { |
| return labelLength; |
| } |
| void setLabel(ASTContext &C, llvm::StringRef S) { |
| labelLength = S.size(); |
| this->label = new (C, 1) char [labelLength]; |
| if (!S.empty()) |
| std::memcpy(this->label, S.data(), labelLength); |
| } |
| |
| bool getIsLiteralLabel() const { |
| return isLiteralLabel; |
| } |
| |
| |
| bool isEquivalent(AsmLabelAttr *Other) const { |
| return getLabel() == Other->getLabel() && getIsLiteralLabel() == Other->getIsLiteralLabel(); |
| } |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AsmLabel; } |
| }; |
| |
| class AssertCapabilityAttr : public InheritableAttr { |
| unsigned args_Size; |
| Expr * *args_; |
| |
| public: |
| enum Spelling { |
| GNU_assert_capability = 0, |
| CXX11_clang_assert_capability = 1, |
| GNU_assert_shared_capability = 2, |
| CXX11_clang_assert_shared_capability = 3, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AssertCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AssertCapabilityAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo); |
| static AssertCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax, AssertCapabilityAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)); |
| static AssertCapabilityAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax, AssertCapabilityAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)); |
| |
| // Constructors |
| AssertCapabilityAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , Expr * *Args, unsigned ArgsSize |
| ); |
| AssertCapabilityAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| AssertCapabilityAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| Spelling getSemanticSpelling() const; |
| bool isShared() const { return getAttributeSpellingListIndex() == 2 || |
| getAttributeSpellingListIndex() == 3; } |
| typedef Expr ** args_iterator; |
| args_iterator args_begin() const { return args_; } |
| args_iterator args_end() const { return args_ + args_Size; } |
| unsigned args_size() const { return args_Size; } |
| llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } |
| |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AssertCapability; } |
| }; |
| |
| class AssertExclusiveLockAttr : public InheritableAttr { |
| unsigned args_Size; |
| Expr * *args_; |
| |
| public: |
| // Factory methods |
| static AssertExclusiveLockAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AssertExclusiveLockAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo); |
| static AssertExclusiveLockAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AssertExclusiveLockAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AssertExclusiveLockAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , Expr * *Args, unsigned ArgsSize |
| ); |
| AssertExclusiveLockAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| AssertExclusiveLockAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| typedef Expr ** args_iterator; |
| args_iterator args_begin() const { return args_; } |
| args_iterator args_end() const { return args_ + args_Size; } |
| unsigned args_size() const { return args_Size; } |
| llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } |
| |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AssertExclusiveLock; } |
| }; |
| |
| class AssertSharedLockAttr : public InheritableAttr { |
| unsigned args_Size; |
| Expr * *args_; |
| |
| public: |
| // Factory methods |
| static AssertSharedLockAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AssertSharedLockAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo); |
| static AssertSharedLockAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AssertSharedLockAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AssertSharedLockAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , Expr * *Args, unsigned ArgsSize |
| ); |
| AssertSharedLockAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| AssertSharedLockAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| typedef Expr ** args_iterator; |
| args_iterator args_begin() const { return args_; } |
| args_iterator args_end() const { return args_ + args_Size; } |
| unsigned args_size() const { return args_Size; } |
| llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } |
| |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AssertSharedLock; } |
| }; |
| |
| class AssumeAlignedAttr : public InheritableAttr { |
| Expr * alignment; |
| |
| Expr * offset; |
| |
| public: |
| enum Spelling { |
| GNU_assume_aligned = 0, |
| CXX11_gnu_assume_aligned = 1, |
| C2x_gnu_assume_aligned = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AssumeAlignedAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, Expr * Offset, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AssumeAlignedAttr *Create(ASTContext &Ctx, Expr * Alignment, Expr * Offset, const AttributeCommonInfo &CommonInfo); |
| static AssumeAlignedAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, Expr * Offset, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AssumeAlignedAttr *Create(ASTContext &Ctx, Expr * Alignment, Expr * Offset, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AssumeAlignedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , Expr * Alignment |
| , Expr * Offset |
| ); |
| AssumeAlignedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , Expr * Alignment |
| ); |
| |
| AssumeAlignedAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| Expr * getAlignment() const { |
| return alignment; |
| } |
| |
| Expr * getOffset() const { |
| return offset; |
| } |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::AssumeAligned; } |
| }; |
| |
| class AssumptionAttr : public InheritableAttr { |
| unsigned assumptionLength; |
| char *assumption; |
| |
| public: |
| enum Spelling { |
| GNU_assume = 0, |
| CXX11_clang_assume = 1, |
| C2x_clang_assume = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AssumptionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Assumption, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AssumptionAttr *Create(ASTContext &Ctx, llvm::StringRef Assumption, const AttributeCommonInfo &CommonInfo); |
| static AssumptionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Assumption, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AssumptionAttr *Create(ASTContext &Ctx, llvm::StringRef Assumption, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AssumptionAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , llvm::StringRef Assumption |
| ); |
| |
| AssumptionAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| llvm::StringRef getAssumption() const { |
| return llvm::StringRef(assumption, assumptionLength); |
| } |
| unsigned getAssumptionLength() const { |
| return assumptionLength; |
| } |
| void setAssumption(ASTContext &C, llvm::StringRef S) { |
| assumptionLength = S.size(); |
| this->assumption = new (C, 1) char [assumptionLength]; |
| if (!S.empty()) |
| std::memcpy(this->assumption, S.data(), assumptionLength); |
| } |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::Assumption; } |
| }; |
| |
| class AvailabilityAttr : public InheritableAttr { |
| IdentifierInfo * platform; |
| |
| VersionTuple introduced; |
| |
| |
| VersionTuple deprecated; |
| |
| |
| VersionTuple obsoleted; |
| |
| |
| bool unavailable; |
| |
| unsigned messageLength; |
| char *message; |
| |
| bool strict; |
| |
| unsigned replacementLength; |
| char *replacement; |
| |
| int priority; |
| |
| public: |
| enum Spelling { |
| GNU_availability = 0, |
| CXX11_clang_availability = 1, |
| C2x_clang_availability = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static AvailabilityAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Platform, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool Unavailable, llvm::StringRef Message, bool Strict, llvm::StringRef Replacement, int Priority, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static AvailabilityAttr *Create(ASTContext &Ctx, IdentifierInfo * Platform, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool Unavailable, llvm::StringRef Message, bool Strict, llvm::StringRef Replacement, int Priority, const AttributeCommonInfo &CommonInfo); |
| static AvailabilityAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Platform, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool Unavailable, llvm::StringRef Message, bool Strict, llvm::StringRef Replacement, int Priority, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static AvailabilityAttr *Create(ASTContext &Ctx, IdentifierInfo * Platform, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool Unavailable, llvm::StringRef Message, bool Strict, llvm::StringRef Replacement, int Priority, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| AvailabilityAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , IdentifierInfo * Platform |
| , VersionTuple Introduced |
| , VersionTuple Deprecated |
| , VersionTuple Obsoleted |
| , bool Unavailable |
| , llvm::StringRef Message |
| , bool Strict |
| , llvm::StringRef Replacement |
| , int Priority |
| ); |
| |
| AvailabilityAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| IdentifierInfo * getPlatform() const { |
| return platform; |
| } |
| |
| VersionTuple getIntroduced() const { |
| return introduced; |
| } |
| void setIntroduced(ASTContext &C, VersionTuple V) { |
| introduced = V; |
| } |
| |
| VersionTuple getDeprecated() const { |
| return deprecated; |
| } |
| void setDeprecated(ASTContext &C, VersionTuple V) { |
| deprecated = V; |
| } |
| |
| VersionTuple getObsoleted() const { |
| return obsoleted; |
| } |
| void setObsoleted(ASTContext &C, VersionTuple V) { |
| obsoleted = V; |
| } |
| |
| bool getUnavailable() const { |
| return unavailable; |
| } |
| |
| llvm::StringRef getMessage() const { |
| return llvm::StringRef(message, messageLength); |
| } |
| unsigned getMessageLength() const { |
| return messageLength; |
| } |
| void setMessage(ASTContext &C, llvm::StringRef S) { |
| messageLength = S.size(); |
| this->message = new (C, 1) char [messageLength]; |
| if (!S.empty()) |
| std::memcpy(this->message, S.data(), messageLength); |
| } |
| |
| bool getStrict() const { |
| return strict; |
| } |
| |
| llvm::StringRef getReplacement() const { |
| return llvm::StringRef(replacement, replacementLength); |
| } |
| unsigned getReplacementLength() const { |
| return replacementLength; |
| } |
| void setReplacement(ASTContext &C, llvm::StringRef S) { |
| replacementLength = S.size(); |
| this->replacement = new (C, 1) char [replacementLength]; |
| if (!S.empty()) |
| std::memcpy(this->replacement, S.data(), replacementLength); |
| } |
| |
| int getPriority() const { |
| return priority; |
| } |
| |
| static llvm::StringRef getPrettyPlatformName(llvm::StringRef Platform) { |
| return llvm::StringSwitch<llvm::StringRef>(Platform) |
| .Case("android", "Android") |
| .Case("fuchsia", "Fuchsia") |
| .Case("ios", "iOS") |
| .Case("macos", "macOS") |
| .Case("tvos", "tvOS") |
| .Case("watchos", "watchOS") |
| .Case("ios_app_extension", "iOS (App Extension)") |
| .Case("macos_app_extension", "macOS (App Extension)") |
| .Case("tvos_app_extension", "tvOS (App Extension)") |
| .Case("watchos_app_extension", "watchOS (App Extension)") |
| .Case("maccatalyst", "macCatalyst") |
| .Case("maccatalyst_app_extension", "macCatalyst (App Extension)") |
| .Case("swift", "Swift") |
| .Default(llvm::StringRef()); |
| } |
| static llvm::StringRef getPlatformNameSourceSpelling(llvm::StringRef Platform) { |
| return llvm::StringSwitch<llvm::StringRef>(Platform) |
| .Case("ios", "iOS") |
| .Case("macos", "macOS") |
| .Case("tvos", "tvOS") |
| .Case("watchos", "watchOS") |
| .Case("ios_app_extension", "iOSApplicationExtension") |
| .Case("macos_app_extension", "macOSApplicationExtension") |
| .Case("tvos_app_extension", "tvOSApplicationExtension") |
| .Case("watchos_app_extension", "watchOSApplicationExtension") |
| .Case("maccatalyst", "macCatalyst") |
| .Case("maccatalyst_app_extension", "macCatalystApplicationExtension") |
| .Case("zos", "z/OS") |
| .Default(Platform); |
| } |
| static llvm::StringRef canonicalizePlatformName(llvm::StringRef Platform) { |
| return llvm::StringSwitch<llvm::StringRef>(Platform) |
| .Case("iOS", "ios") |
| .Case("macOS", "macos") |
| .Case("tvOS", "tvos") |
| .Case("watchOS", "watchos") |
| .Case("iOSApplicationExtension", "ios_app_extension") |
| .Case("macOSApplicationExtension", "macos_app_extension") |
| .Case("tvOSApplicationExtension", "tvos_app_extension") |
| .Case("watchOSApplicationExtension", "watchos_app_extension") |
| .Case("macCatalyst", "maccatalyst") |
| .Case("macCatalystApplicationExtension", "maccatalyst_app_extension") |
| .Default(Platform); |
| } |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::Availability; } |
| }; |
| |
| class BPFPreserveAccessIndexAttr : public InheritableAttr { |
| public: |
| enum Spelling { |
| GNU_preserve_access_index = 0, |
| CXX11_clang_preserve_access_index = 1, |
| C2x_clang_preserve_access_index = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static BPFPreserveAccessIndexAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static BPFPreserveAccessIndexAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static BPFPreserveAccessIndexAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static BPFPreserveAccessIndexAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| BPFPreserveAccessIndexAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| BPFPreserveAccessIndexAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::BPFPreserveAccessIndex; } |
| }; |
| |
| class BTFDeclTagAttr : public InheritableAttr { |
| unsigned bTFDeclTagLength; |
| char *bTFDeclTag; |
| |
| public: |
| enum Spelling { |
| GNU_btf_decl_tag = 0, |
| CXX11_clang_btf_decl_tag = 1, |
| C2x_clang_btf_decl_tag = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static BTFDeclTagAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef BTFDeclTag, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static BTFDeclTagAttr *Create(ASTContext &Ctx, llvm::StringRef BTFDeclTag, const AttributeCommonInfo &CommonInfo); |
| static BTFDeclTagAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef BTFDeclTag, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static BTFDeclTagAttr *Create(ASTContext &Ctx, llvm::StringRef BTFDeclTag, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| BTFDeclTagAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , llvm::StringRef BTFDeclTag |
| ); |
| |
| BTFDeclTagAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| llvm::StringRef getBTFDeclTag() const { |
| return llvm::StringRef(bTFDeclTag, bTFDeclTagLength); |
| } |
| unsigned getBTFDeclTagLength() const { |
| return bTFDeclTagLength; |
| } |
| void setBTFDeclTag(ASTContext &C, llvm::StringRef S) { |
| bTFDeclTagLength = S.size(); |
| this->bTFDeclTag = new (C, 1) char [bTFDeclTagLength]; |
| if (!S.empty()) |
| std::memcpy(this->bTFDeclTag, S.data(), bTFDeclTagLength); |
| } |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::BTFDeclTag; } |
| }; |
| |
| class BTFTypeTagAttr : public TypeAttr { |
| unsigned bTFTypeTagLength; |
| char *bTFTypeTag; |
| |
| public: |
| enum Spelling { |
| GNU_btf_type_tag = 0, |
| CXX11_clang_btf_type_tag = 1, |
| C2x_clang_btf_type_tag = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static BTFTypeTagAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef BTFTypeTag, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static BTFTypeTagAttr *Create(ASTContext &Ctx, llvm::StringRef BTFTypeTag, const AttributeCommonInfo &CommonInfo); |
| static BTFTypeTagAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef BTFTypeTag, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static BTFTypeTagAttr *Create(ASTContext &Ctx, llvm::StringRef BTFTypeTag, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| BTFTypeTagAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , llvm::StringRef BTFTypeTag |
| ); |
| |
| BTFTypeTagAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| llvm::StringRef getBTFTypeTag() const { |
| return llvm::StringRef(bTFTypeTag, bTFTypeTagLength); |
| } |
| unsigned getBTFTypeTagLength() const { |
| return bTFTypeTagLength; |
| } |
| void setBTFTypeTag(ASTContext &C, llvm::StringRef S) { |
| bTFTypeTagLength = S.size(); |
| this->bTFTypeTag = new (C, 1) char [bTFTypeTagLength]; |
| if (!S.empty()) |
| std::memcpy(this->bTFTypeTag, S.data(), bTFTypeTagLength); |
| } |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::BTFTypeTag; } |
| }; |
| |
| class BlocksAttr : public InheritableAttr { |
| public: |
| enum BlockType { |
| ByRef |
| }; |
| private: |
| BlockType type; |
| |
| public: |
| enum Spelling { |
| GNU_blocks = 0, |
| CXX11_clang_blocks = 1, |
| C2x_clang_blocks = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static BlocksAttr *CreateImplicit(ASTContext &Ctx, BlockType Type, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static BlocksAttr *Create(ASTContext &Ctx, BlockType Type, const AttributeCommonInfo &CommonInfo); |
| static BlocksAttr *CreateImplicit(ASTContext &Ctx, BlockType Type, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static BlocksAttr *Create(ASTContext &Ctx, BlockType Type, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| BlocksAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , BlockType Type |
| ); |
| |
| BlocksAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| BlockType getType() const { |
| return type; |
| } |
| |
| static bool ConvertStrToBlockType(StringRef Val, BlockType &Out); |
| static const char *ConvertBlockTypeToStr(BlockType Val); |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::Blocks; } |
| }; |
| |
| class BuiltinAttr : public InheritableAttr { |
| unsigned iD; |
| |
| public: |
| // Factory methods |
| static BuiltinAttr *CreateImplicit(ASTContext &Ctx, unsigned ID, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static BuiltinAttr *Create(ASTContext &Ctx, unsigned ID, const AttributeCommonInfo &CommonInfo); |
| static BuiltinAttr *CreateImplicit(ASTContext &Ctx, unsigned ID, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static BuiltinAttr *Create(ASTContext &Ctx, unsigned ID, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| BuiltinAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , unsigned ID |
| ); |
| |
| BuiltinAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| unsigned getID() const { |
| return iD; |
| } |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::Builtin; } |
| }; |
| |
| class BuiltinAliasAttr : public Attr { |
| IdentifierInfo * builtinName; |
| |
| public: |
| enum Spelling { |
| CXX11_clang_builtin_alias = 0, |
| C2x_clang_builtin_alias = 1, |
| GNU_clang_builtin_alias = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static BuiltinAliasAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * BuiltinName, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static BuiltinAliasAttr *Create(ASTContext &Ctx, IdentifierInfo * BuiltinName, const AttributeCommonInfo &CommonInfo); |
| static BuiltinAliasAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * BuiltinName, SourceRange Range, AttributeCommonInfo::Syntax Syntax, BuiltinAliasAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)); |
| static BuiltinAliasAttr *Create(ASTContext &Ctx, IdentifierInfo * BuiltinName, SourceRange Range, AttributeCommonInfo::Syntax Syntax, BuiltinAliasAttr::Spelling S = static_cast<Spelling>(SpellingNotCalculated)); |
| |
| // Constructors |
| BuiltinAliasAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , IdentifierInfo * BuiltinName |
| ); |
| |
| BuiltinAliasAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| Spelling getSemanticSpelling() const; |
| IdentifierInfo * getBuiltinName() const { |
| return builtinName; |
| } |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::BuiltinAlias; } |
| }; |
| |
| class C11NoReturnAttr : public InheritableAttr { |
| public: |
| // Factory methods |
| static C11NoReturnAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static C11NoReturnAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static C11NoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static C11NoReturnAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| C11NoReturnAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| C11NoReturnAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::C11NoReturn; } |
| }; |
| |
| class CDeclAttr : public InheritableAttr { |
| public: |
| enum Spelling { |
| GNU_cdecl = 0, |
| CXX11_gnu_cdecl = 1, |
| C2x_gnu_cdecl = 2, |
| Keyword_cdecl = 3, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static CDeclAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static CDeclAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static CDeclAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static CDeclAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| CDeclAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| CDeclAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::CDecl; } |
| }; |
| |
| class CFAuditedTransferAttr : public InheritableAttr { |
| public: |
| enum Spelling { |
| GNU_cf_audited_transfer = 0, |
| CXX11_clang_cf_audited_transfer = 1, |
| C2x_clang_cf_audited_transfer = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static CFAuditedTransferAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static CFAuditedTransferAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static CFAuditedTransferAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static CFAuditedTransferAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| CFAuditedTransferAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| CFAuditedTransferAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::CFAuditedTransfer; } |
| }; |
| |
| class CFConsumedAttr : public InheritableParamAttr { |
| public: |
| enum Spelling { |
| GNU_cf_consumed = 0, |
| CXX11_clang_cf_consumed = 1, |
| C2x_clang_cf_consumed = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static CFConsumedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static CFConsumedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static CFConsumedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static CFConsumedAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| CFConsumedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| CFConsumedAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::CFConsumed; } |
| }; |
| |
| class CFGuardAttr : public InheritableAttr { |
| public: |
| enum GuardArg { |
| nocf |
| }; |
| private: |
| GuardArg guard; |
| |
| public: |
| // Factory methods |
| static CFGuardAttr *CreateImplicit(ASTContext &Ctx, GuardArg Guard, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static CFGuardAttr *Create(ASTContext &Ctx, GuardArg Guard, const AttributeCommonInfo &CommonInfo); |
| static CFGuardAttr *CreateImplicit(ASTContext &Ctx, GuardArg Guard, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static CFGuardAttr *Create(ASTContext &Ctx, GuardArg Guard, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| CFGuardAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , GuardArg Guard |
| ); |
| |
| CFGuardAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| GuardArg getGuard() const { |
| return guard; |
| } |
| |
| static bool ConvertStrToGuardArg(StringRef Val, GuardArg &Out); |
| static const char *ConvertGuardArgToStr(GuardArg Val); |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::CFGuard; } |
| }; |
| |
| class CFICanonicalJumpTableAttr : public InheritableAttr { |
| public: |
| enum Spelling { |
| GNU_cfi_canonical_jump_table = 0, |
| CXX11_clang_cfi_canonical_jump_table = 1, |
| C2x_clang_cfi_canonical_jump_table = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static CFICanonicalJumpTableAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static CFICanonicalJumpTableAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static CFICanonicalJumpTableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static CFICanonicalJumpTableAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| CFICanonicalJumpTableAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| CFICanonicalJumpTableAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::CFICanonicalJumpTable; } |
| }; |
| |
| class CFReturnsNotRetainedAttr : public InheritableAttr { |
| public: |
| enum Spelling { |
| GNU_cf_returns_not_retained = 0, |
| CXX11_clang_cf_returns_not_retained = 1, |
| C2x_clang_cf_returns_not_retained = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static CFReturnsNotRetainedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static CFReturnsNotRetainedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static CFReturnsNotRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static CFReturnsNotRetainedAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| CFReturnsNotRetainedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| CFReturnsNotRetainedAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::CFReturnsNotRetained; } |
| }; |
| |
| class CFReturnsRetainedAttr : public InheritableAttr { |
| public: |
| enum Spelling { |
| GNU_cf_returns_retained = 0, |
| CXX11_clang_cf_returns_retained = 1, |
| C2x_clang_cf_returns_retained = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static CFReturnsRetainedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static CFReturnsRetainedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static CFReturnsRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static CFReturnsRetainedAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| CFReturnsRetainedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| CFReturnsRetainedAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::CFReturnsRetained; } |
| }; |
| |
| class CFUnknownTransferAttr : public InheritableAttr { |
| public: |
| enum Spelling { |
| GNU_cf_unknown_transfer = 0, |
| CXX11_clang_cf_unknown_transfer = 1, |
| C2x_clang_cf_unknown_transfer = 2, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static CFUnknownTransferAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static CFUnknownTransferAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static CFUnknownTransferAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static CFUnknownTransferAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| CFUnknownTransferAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| CFUnknownTransferAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::CFUnknownTransfer; } |
| }; |
| |
| class CPUDispatchAttr : public InheritableAttr { |
| unsigned cpus_Size; |
| IdentifierInfo * *cpus_; |
| |
| public: |
| enum Spelling { |
| GNU_cpu_dispatch = 0, |
| CXX11_clang_cpu_dispatch = 1, |
| C2x_clang_cpu_dispatch = 2, |
| Declspec_cpu_dispatch = 3, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static CPUDispatchAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * *Cpus, unsigned CpusSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static CPUDispatchAttr *Create(ASTContext &Ctx, IdentifierInfo * *Cpus, unsigned CpusSize, const AttributeCommonInfo &CommonInfo); |
| static CPUDispatchAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * *Cpus, unsigned CpusSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static CPUDispatchAttr *Create(ASTContext &Ctx, IdentifierInfo * *Cpus, unsigned CpusSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| CPUDispatchAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , IdentifierInfo * *Cpus, unsigned CpusSize |
| ); |
| CPUDispatchAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| CPUDispatchAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| typedef IdentifierInfo ** cpus_iterator; |
| cpus_iterator cpus_begin() const { return cpus_; } |
| cpus_iterator cpus_end() const { return cpus_ + cpus_Size; } |
| unsigned cpus_size() const { return cpus_Size; } |
| llvm::iterator_range<cpus_iterator> cpus() const { return llvm::make_range(cpus_begin(), cpus_end()); } |
| |
| |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::CPUDispatch; } |
| }; |
| |
| class CPUSpecificAttr : public InheritableAttr { |
| unsigned cpus_Size; |
| IdentifierInfo * *cpus_; |
| |
| public: |
| enum Spelling { |
| GNU_cpu_specific = 0, |
| CXX11_clang_cpu_specific = 1, |
| C2x_clang_cpu_specific = 2, |
| Declspec_cpu_specific = 3, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static CPUSpecificAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * *Cpus, unsigned CpusSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static CPUSpecificAttr *Create(ASTContext &Ctx, IdentifierInfo * *Cpus, unsigned CpusSize, const AttributeCommonInfo &CommonInfo); |
| static CPUSpecificAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * *Cpus, unsigned CpusSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static CPUSpecificAttr *Create(ASTContext &Ctx, IdentifierInfo * *Cpus, unsigned CpusSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| CPUSpecificAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| , IdentifierInfo * *Cpus, unsigned CpusSize |
| ); |
| CPUSpecificAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| CPUSpecificAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| typedef IdentifierInfo ** cpus_iterator; |
| cpus_iterator cpus_begin() const { return cpus_; } |
| cpus_iterator cpus_end() const { return cpus_ + cpus_Size; } |
| unsigned cpus_size() const { return cpus_Size; } |
| llvm::iterator_range<cpus_iterator> cpus() const { return llvm::make_range(cpus_begin(), cpus_end()); } |
| |
| |
| |
| IdentifierInfo *getCPUName(unsigned Index) const { |
| return *(cpus_begin() + Index); |
| } |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::CPUSpecific; } |
| }; |
| |
| class CUDAConstantAttr : public InheritableAttr { |
| public: |
| enum Spelling { |
| GNU_constant = 0, |
| Declspec_constant = 1, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static CUDAConstantAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static CUDAConstantAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static CUDAConstantAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static CUDAConstantAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| CUDAConstantAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| CUDAConstantAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::CUDAConstant; } |
| }; |
| |
| class CUDADeviceAttr : public InheritableAttr { |
| public: |
| enum Spelling { |
| GNU_device = 0, |
| Declspec_device = 1, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static CUDADeviceAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static CUDADeviceAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static CUDADeviceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static CUDADeviceAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| CUDADeviceAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| CUDADeviceAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::CUDADevice; } |
| }; |
| |
| class CUDADeviceBuiltinSurfaceTypeAttr : public InheritableAttr { |
| public: |
| enum Spelling { |
| GNU_device_builtin_surface_type = 0, |
| Declspec_device_builtin_surface_type = 1, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static CUDADeviceBuiltinSurfaceTypeAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static CUDADeviceBuiltinSurfaceTypeAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static CUDADeviceBuiltinSurfaceTypeAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static CUDADeviceBuiltinSurfaceTypeAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| CUDADeviceBuiltinSurfaceTypeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| CUDADeviceBuiltinSurfaceTypeAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::CUDADeviceBuiltinSurfaceType; } |
| }; |
| |
| class CUDADeviceBuiltinTextureTypeAttr : public InheritableAttr { |
| public: |
| enum Spelling { |
| GNU_device_builtin_texture_type = 0, |
| Declspec_device_builtin_texture_type = 1, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
| static CUDADeviceBuiltinTextureTypeAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo = {SourceRange{}}); |
| static CUDADeviceBuiltinTextureTypeAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo); |
| static CUDADeviceBuiltinTextureTypeAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| static CUDADeviceBuiltinTextureTypeAttr *Create(ASTContext &Ctx, SourceRange Range, AttributeCommonInfo::Syntax Syntax); |
| |
| // Constructors |
| CUDADeviceBuiltinTextureTypeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo |
| ); |
| |
| CUDADeviceBuiltinTextureTypeAttr *clone(ASTContext &C) const; |
| void printPretty(raw_ostream &OS, |
| const PrintingPolicy &Policy) const; |
| const char *getSpelling() const; |
| |
| |
| static bool classof(const Attr *A) { return A->getKind() == attr::CUDADeviceBuiltinTextureType; } |
| }; |
| |
| class CUDAGlobalAttr : public InheritableAttr { |
| public: |
| enum Spelling { |
| GNU_global = 0, |
| Declspec_global = 1, |
| SpellingNotCalculated = 15 |
| |
| }; |
| |
| // Factory methods |
|