contrib/llvm-project/clang/lib/Basic/Attributes.cpp

   1 #include "clang/Basic/Attributes.h"
   2 #include "clang/Basic/AttrSubjectMatchRules.h"
   3 #include "clang/Basic/AttributeCommonInfo.h"
   4 #include "clang/Basic/IdentifierTable.h"
   5 #include "llvm/ADT/StringSwitch.h"
   6 using namespace clang;
   7
   8 int clang::hasAttribute(AttrSyntax Syntax, const IdentifierInfo *Scope,
   9                         const IdentifierInfo *Attr, const TargetInfo &Target,
  10                         const LangOptions &LangOpts) {
  11   StringRef Name = Attr->getName();
  12   // Normalize the attribute name, __foo__ becomes foo.
  13   if (Name.size() >= 4 && Name.startswith("__") && Name.endswith("__"))
  14     Name = Name.substr(2, Name.size() - 4);
  15
  16   // Normalize the scope name, but only for gnu and clang attributes.
  17   StringRef ScopeName = Scope ? Scope->getName() : "";
  18   if (ScopeName == "__gnu__")
  19     ScopeName = "gnu";
  20   else if (ScopeName == "_Clang")
  21     ScopeName = "clang";
  22
  23 #include "clang/Basic/AttrHasAttributeImpl.inc"
  24
  25   return 0;
  26 }
  27
  28 const char *attr::getSubjectMatchRuleSpelling(attr::SubjectMatchRule Rule) {
  29   switch (Rule) {
  30 #define ATTR_MATCH_RULE(NAME, SPELLING, IsAbstract)                            \
  31   case attr::NAME:                                                             \
  32     return SPELLING;
  33 #include "clang/Basic/AttrSubMatchRulesList.inc"
  34   }
  35   llvm_unreachable("Invalid subject match rule");
  36 }
  37
  38 static StringRef
  39 normalizeAttrScopeName(const IdentifierInfo *Scope,
  40                        AttributeCommonInfo::Syntax SyntaxUsed) {
  41   if (!Scope)
  42     return "";
  43
  44   // Normalize the "__gnu__" scope name to be "gnu" and the "_Clang" scope name
  45   // to be "clang".
  46   StringRef ScopeName = Scope->getName();
  47   if (SyntaxUsed == AttributeCommonInfo::AS_CXX11 ||
  48       SyntaxUsed == AttributeCommonInfo::AS_C2x) {
  49     if (ScopeName == "__gnu__")
  50       ScopeName = "gnu";
  51     else if (ScopeName == "_Clang")
  52       ScopeName = "clang";
  53   }
  54   return ScopeName;
  55 }
  56
  57 static StringRef normalizeAttrName(const IdentifierInfo *Name,
  58                                    StringRef NormalizedScopeName,
  59                                    AttributeCommonInfo::Syntax SyntaxUsed) {
  60   // Normalize the attribute name, __foo__ becomes foo. This is only allowable
  61   // for GNU attributes, and attributes using the double square bracket syntax.
  62   bool ShouldNormalize =
  63       SyntaxUsed == AttributeCommonInfo::AS_GNU ||
  64       ((SyntaxUsed == AttributeCommonInfo::AS_CXX11 ||
  65         SyntaxUsed == AttributeCommonInfo::AS_C2x) &&
  66        (NormalizedScopeName.empty() || NormalizedScopeName == "gnu" ||
  67         NormalizedScopeName == "clang"));
  68   StringRef AttrName = Name->getName();
  69   if (ShouldNormalize && AttrName.size() >= 4 && AttrName.startswith("__") &&
  70       AttrName.endswith("__"))
  71     AttrName = AttrName.slice(2, AttrName.size() - 2);
  72
  73   return AttrName;
  74 }
  75
  76 bool AttributeCommonInfo::isGNUScope() const {
  77   return ScopeName && (ScopeName->isStr("gnu") || ScopeName->isStr("__gnu__"));
  78 }
  79
  80 #include "clang/Sema/AttrParsedAttrKinds.inc"
  81
  82 static SmallString<64> normalizeName(const IdentifierInfo *Name,
  83                                      const IdentifierInfo *Scope,
  84                                      AttributeCommonInfo::Syntax SyntaxUsed) {
  85   StringRef ScopeName = normalizeAttrScopeName(Scope, SyntaxUsed);
  86   StringRef AttrName = normalizeAttrName(Name, ScopeName, SyntaxUsed);
  87
  88   SmallString<64> FullName = ScopeName;
  89   if (!ScopeName.empty()) {
  90     assert(SyntaxUsed == AttributeCommonInfo::AS_CXX11 ||
  91            SyntaxUsed == AttributeCommonInfo::AS_C2x);
  92     FullName += "::";
  93   }
  94   FullName += AttrName;
  95
  96   return FullName;
  97 }
  98
  99 AttributeCommonInfo::Kind
 100 AttributeCommonInfo::getParsedKind(const IdentifierInfo *Name,
 101                                    const IdentifierInfo *ScopeName,
 102                                    Syntax SyntaxUsed) {
 103   return ::getAttrKind(normalizeName(Name, ScopeName, SyntaxUsed), SyntaxUsed);
 104 }
 105
 106 std::string AttributeCommonInfo::getNormalizedFullName() const {
 107   return static_cast<std::string>(
 108       normalizeName(getAttrName(), getScopeName(), getSyntax()));
 109 }
 110
 111 unsigned AttributeCommonInfo::calculateAttributeSpellingListIndex() const {
 112   // Both variables will be used in tablegen generated
 113   // attribute spell list index matching code.
 114   auto Syntax = static_cast<AttributeCommonInfo::Syntax>(getSyntax());
 115   StringRef Scope = normalizeAttrScopeName(getScopeName(), Syntax);
 116   StringRef Name = normalizeAttrName(getAttrName(), Scope, Syntax);
 117
 118 #include "clang/Sema/AttrSpellingListIndex.inc"
 119 }