blob: 7be4985e7aecc57770647408fefdaa490b93e360 [file] [log] [blame]
/*===- 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