Viewing file:  ParsedAttrInfo.h (6.83 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
//===- ParsedAttrInfo.h - Info needed to parse an attribute -----*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file defines the ParsedAttrInfo class, which dictates how to
// parse an attribute. This class is the one that plugins derive to
// define a new attribute.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_BASIC_PARSEDATTRINFO_H
#define LLVM_CLANG_BASIC_PARSEDATTRINFO_H
#include "clang/Basic/AttrSubjectMatchRules.h"
#include "clang/Basic/AttributeCommonInfo.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/Support/Registry.h"
#include <climits>
#include <list>
namespace clang {
class Decl;
class LangOptions;
class ParsedAttr;
class Sema;
class Stmt;
class TargetInfo;
struct ParsedAttrInfo {
/// Corresponds to the Kind enum.
LLVM_PREFERRED_TYPE(AttributeCommonInfo::Kind)
unsigned AttrKind : 16;
/// The number of required arguments of this attribute.
unsigned NumArgs : 4;
/// The number of optional arguments of this attributes.
unsigned OptArgs : 4;
/// The number of non-fake arguments specified in the attribute definition.
unsigned NumArgMembers : 4;
/// True if the parsing does not match the semantic content.
LLVM_PREFERRED_TYPE(bool)
unsigned HasCustomParsing : 1;
// True if this attribute accepts expression parameter pack expansions.
LLVM_PREFERRED_TYPE(bool)
unsigned AcceptsExprPack : 1;
/// True if this attribute is only available for certain targets.
LLVM_PREFERRED_TYPE(bool)
unsigned IsTargetSpecific : 1;
/// True if this attribute applies to types.
LLVM_PREFERRED_TYPE(bool)
unsigned IsType : 1;
/// True if this attribute applies to statements.
LLVM_PREFERRED_TYPE(bool)
unsigned IsStmt : 1;
/// True if this attribute has any spellings that are known to gcc.
LLVM_PREFERRED_TYPE(bool)
unsigned IsKnownToGCC : 1;
/// True if this attribute is supported by #pragma clang attribute.
LLVM_PREFERRED_TYPE(bool)
unsigned IsSupportedByPragmaAttribute : 1;
/// The syntaxes supported by this attribute and how they're spelled.
struct Spelling {
AttributeCommonInfo::Syntax Syntax;
const char *NormalizedFullName;
};
ArrayRef<Spelling> Spellings;
// The names of the known arguments of this attribute.
ArrayRef<const char *> ArgNames;
protected:
constexpr ParsedAttrInfo(AttributeCommonInfo::Kind AttrKind =
AttributeCommonInfo::NoSemaHandlerAttribute)
: AttrKind(AttrKind), NumArgs(0), OptArgs(0), NumArgMembers(0),
HasCustomParsing(0), AcceptsExprPack(0), IsTargetSpecific(0), IsType(0),
IsStmt(0), IsKnownToGCC(0), IsSupportedByPragmaAttribute(0) {}
constexpr ParsedAttrInfo(AttributeCommonInfo::Kind AttrKind, unsigned NumArgs,
unsigned OptArgs, unsigned NumArgMembers,
unsigned HasCustomParsing, unsigned AcceptsExprPack,
unsigned IsTargetSpecific, unsigned IsType,
unsigned IsStmt, unsigned IsKnownToGCC,
unsigned IsSupportedByPragmaAttribute,
ArrayRef<Spelling> Spellings,
ArrayRef<const char *> ArgNames)
: AttrKind(AttrKind), NumArgs(NumArgs), OptArgs(OptArgs),
NumArgMembers(NumArgMembers), HasCustomParsing(HasCustomParsing),
AcceptsExprPack(AcceptsExprPack), IsTargetSpecific(IsTargetSpecific),
IsType(IsType), IsStmt(IsStmt), IsKnownToGCC(IsKnownToGCC),
IsSupportedByPragmaAttribute(IsSupportedByPragmaAttribute),
Spellings(Spellings), ArgNames(ArgNames) {}
public:
virtual ~ParsedAttrInfo() = default;
/// Check if this attribute has specified spelling.
bool hasSpelling(AttributeCommonInfo::Syntax Syntax, StringRef Name) const {
return llvm::any_of(Spellings, [&](const Spelling &S) {
return (S.Syntax == Syntax && S.NormalizedFullName == Name);
});
}
/// Check if this attribute appertains to D, and issue a diagnostic if not.
virtual bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr,
const Decl *D) const {
return true;
}
/// Check if this attribute appertains to St, and issue a diagnostic if not.
virtual bool diagAppertainsToStmt(Sema &S, const ParsedAttr &Attr,
const Stmt *St) const {
return true;
}
/// Check if the given attribute is mutually exclusive with other attributes
/// already applied to the given declaration.
virtual bool diagMutualExclusion(Sema &S, const ParsedAttr &A,
const Decl *D) const {
return true;
}
/// Check if this attribute is allowed by the language we are compiling.
virtual bool acceptsLangOpts(const LangOptions &LO) const { return true; }
/// Check if this attribute is allowed when compiling for the given target.
virtual bool existsInTarget(const TargetInfo &Target) const { return true; }
/// Check if this attribute's spelling is allowed when compiling for the given
/// target.
virtual bool spellingExistsInTarget(const TargetInfo &Target,
const unsigned SpellingListIndex) const {
return true;
}
/// Convert the spelling index of Attr to a semantic spelling enum value.
virtual unsigned
spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const {
return UINT_MAX;
}
/// Returns true if the specified parameter index for this attribute in
/// Attr.td is an ExprArgument or VariadicExprArgument, or a subclass thereof;
/// returns false otherwise.
virtual bool isParamExpr(size_t N) const { return false; }
/// Populate Rules with the match rules of this attribute.
virtual void getPragmaAttributeMatchRules(
llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &Rules,
const LangOptions &LangOpts) const {}
enum AttrHandling { NotHandled, AttributeApplied, AttributeNotApplied };
/// If this ParsedAttrInfo knows how to handle this ParsedAttr applied to this
/// Decl then do so and return either AttributeApplied if it was applied or
/// AttributeNotApplied if it wasn't. Otherwise return NotHandled.
virtual AttrHandling handleDeclAttribute(Sema &S, Decl *D,
const ParsedAttr &Attr) const {
return NotHandled;
}
static const ParsedAttrInfo &get(const AttributeCommonInfo &A);
static ArrayRef<const ParsedAttrInfo *> getAllBuiltin();
};
typedef llvm::Registry<ParsedAttrInfo> ParsedAttrInfoRegistry;
const std::list<std::unique_ptr<ParsedAttrInfo>> &getAttributePluginInstances();
} // namespace clang
#endif // LLVM_CLANG_BASIC_PARSEDATTRINFO_H
|