Home | History | Annotate | Line # | Download | only in Basic 
      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 }
    120