head 1.1; branch 1.1.1; access; symbols netbsd-9-5-RELEASE:1.1.1.9 netbsd-11-0-RELEASE:1.1.1.10 netbsd-11-0-RC7:1.1.1.10 netbsd-11-0-RC6:1.1.1.10 netbsd-11-0-RC5:1.1.1.10 netbsd-11-0-RC4:1.1.1.10 netbsd-11-0-RC3:1.1.1.10 netbsd-11-0-RC2:1.1.1.10 netbsd-11-0-RC1:1.1.1.10 perseant-exfatfs-base-20250801:1.1.1.10 netbsd-11:1.1.1.10.0.10 netbsd-11-base:1.1.1.10 netbsd-10-1-RELEASE:1.1.1.10 perseant-exfatfs-base-20240630:1.1.1.10 perseant-exfatfs:1.1.1.10.0.8 perseant-exfatfs-base:1.1.1.10 netbsd-8-3-RELEASE:1.1.1.7 netbsd-9-4-RELEASE:1.1.1.9 netbsd-10-0-RELEASE:1.1.1.10 netbsd-10-0-RC6:1.1.1.10 netbsd-10-0-RC5:1.1.1.10 netbsd-10-0-RC4:1.1.1.10 netbsd-10-0-RC3:1.1.1.10 netbsd-10-0-RC2:1.1.1.10 netbsd-10-0-RC1:1.1.1.10 netbsd-10:1.1.1.10.0.6 netbsd-10-base:1.1.1.10 netbsd-9-3-RELEASE:1.1.1.9 cjep_sun2x:1.1.1.10.0.4 cjep_sun2x-base:1.1.1.10 cjep_staticlib_x-base1:1.1.1.10 netbsd-9-2-RELEASE:1.1.1.9 cjep_staticlib_x:1.1.1.10.0.2 cjep_staticlib_x-base:1.1.1.10 netbsd-9-1-RELEASE:1.1.1.9 phil-wifi-20200421:1.1.1.10 phil-wifi-20200411:1.1.1.10 phil-wifi-20200406:1.1.1.10 netbsd-8-2-RELEASE:1.1.1.7 netbsd-9-0-RELEASE:1.1.1.9 netbsd-9-0-RC2:1.1.1.9 netbsd-9-0-RC1:1.1.1.9 netbsd-9:1.1.1.9.0.2 netbsd-9-base:1.1.1.9 phil-wifi-20190609:1.1.1.9 netbsd-8-1-RELEASE:1.1.1.7 netbsd-8-1-RC1:1.1.1.7 pgoyette-compat-merge-20190127:1.1.1.8.2.1 pgoyette-compat-20190127:1.1.1.9 pgoyette-compat-20190118:1.1.1.9 pgoyette-compat-1226:1.1.1.9 pgoyette-compat-1126:1.1.1.9 pgoyette-compat-1020:1.1.1.9 pgoyette-compat-0930:1.1.1.9 pgoyette-compat-0906:1.1.1.9 netbsd-7-2-RELEASE:1.1.1.4.2.1 pgoyette-compat-0728:1.1.1.9 clang-337282:1.1.1.9 netbsd-8-0-RELEASE:1.1.1.7 phil-wifi:1.1.1.8.0.4 phil-wifi-base:1.1.1.8 pgoyette-compat-0625:1.1.1.8 netbsd-8-0-RC2:1.1.1.7 pgoyette-compat-0521:1.1.1.8 pgoyette-compat-0502:1.1.1.8 pgoyette-compat-0422:1.1.1.8 netbsd-8-0-RC1:1.1.1.7 pgoyette-compat-0415:1.1.1.8 pgoyette-compat-0407:1.1.1.8 pgoyette-compat-0330:1.1.1.8 pgoyette-compat-0322:1.1.1.8 pgoyette-compat-0315:1.1.1.8 netbsd-7-1-2-RELEASE:1.1.1.4.2.1 pgoyette-compat:1.1.1.8.0.2 pgoyette-compat-base:1.1.1.8 netbsd-7-1-1-RELEASE:1.1.1.4.2.1 clang-319952:1.1.1.8 matt-nb8-mediatek:1.1.1.7.0.10 matt-nb8-mediatek-base:1.1.1.7 clang-309604:1.1.1.8 perseant-stdc-iso10646:1.1.1.7.0.8 perseant-stdc-iso10646-base:1.1.1.7 netbsd-8:1.1.1.7.0.6 netbsd-8-base:1.1.1.7 prg-localcount2-base3:1.1.1.7 prg-localcount2-base2:1.1.1.7 prg-localcount2-base1:1.1.1.7 prg-localcount2:1.1.1.7.0.4 prg-localcount2-base:1.1.1.7 pgoyette-localcount-20170426:1.1.1.7 bouyer-socketcan-base1:1.1.1.7 pgoyette-localcount-20170320:1.1.1.7 netbsd-7-1:1.1.1.4.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.4.2.1 netbsd-7-1-RC2:1.1.1.4.2.1 clang-294123:1.1.1.7 netbsd-7-nhusb-base-20170116:1.1.1.4.2.1 bouyer-socketcan:1.1.1.7.0.2 bouyer-socketcan-base:1.1.1.7 clang-291444:1.1.1.7 pgoyette-localcount-20170107:1.1.1.6 netbsd-7-1-RC1:1.1.1.4.2.1 pgoyette-localcount-20161104:1.1.1.6 netbsd-7-0-2-RELEASE:1.1.1.4.2.1 localcount-20160914:1.1.1.6 netbsd-7-nhusb:1.1.1.4.2.1.0.4 netbsd-7-nhusb-base:1.1.1.4.2.1 clang-280599:1.1.1.6 pgoyette-localcount-20160806:1.1.1.6 pgoyette-localcount-20160726:1.1.1.6 pgoyette-localcount:1.1.1.6.0.2 pgoyette-localcount-base:1.1.1.6 netbsd-7-0-1-RELEASE:1.1.1.4.2.1 clang-261930:1.1.1.6 netbsd-7-0:1.1.1.4.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.4.2.1 netbsd-7-0-RC3:1.1.1.4.2.1 netbsd-7-0-RC2:1.1.1.4.2.1 netbsd-7-0-RC1:1.1.1.4.2.1 clang-237755:1.1.1.5 clang-232565:1.1.1.5 clang-227398:1.1.1.5 tls-maxphys-base:1.1.1.4 tls-maxphys:1.1.1.4.0.4 netbsd-7:1.1.1.4.0.2 netbsd-7-base:1.1.1.4 clang-215315:1.1.1.4 clang-209886:1.1.1.4 yamt-pagecache:1.1.1.3.0.4 yamt-pagecache-base9:1.1.1.3 tls-earlyentropy:1.1.1.3.0.2 tls-earlyentropy-base:1.1.1.4 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.3 riastradh-drm2-base3:1.1.1.3 clang-202566:1.1.1.3 clang-201163:1.1.1.3 clang-199312:1.1.1.3 clang-198450:1.1.1.2 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.49; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.49; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.05.15.38.37; author joerg; state Exp; branches; next 1.1.1.3; commitid wh3aCSIWykURqWjx; 1.1.1.3 date 2014.01.15.21.26.20; author joerg; state Exp; branches 1.1.1.3.2.1 1.1.1.3.4.1; next 1.1.1.4; commitid NQXlzzA0SPkc5glx; 1.1.1.4 date 2014.05.30.18.14.40; author joerg; state Exp; branches 1.1.1.4.2.1 1.1.1.4.4.1; next 1.1.1.5; commitid 8q0kdlBlCn09GACx; 1.1.1.5 date 2015.01.29.19.57.32; author joerg; state Exp; branches; next 1.1.1.6; commitid mlISSizlPKvepX7y; 1.1.1.6 date 2016.02.27.22.11.54; author joerg; state Exp; branches 1.1.1.6.2.1; next 1.1.1.7; commitid tIimz3oDlh1NpBWy; 1.1.1.7 date 2017.01.11.10.34.54; author joerg; state Exp; branches; next 1.1.1.8; commitid CNnUNfII1jgNmxBz; 1.1.1.8 date 2017.08.01.19.34.55; author joerg; state Exp; branches 1.1.1.8.2.1 1.1.1.8.4.1; next 1.1.1.9; commitid pMuDy65V0VicSx1A; 1.1.1.9 date 2018.07.17.18.31.24; author joerg; state Exp; branches; next 1.1.1.10; commitid wDzL46ALjrCZgwKA; 1.1.1.10 date 2019.11.13.22.19.20; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.3.2.1 date 2014.08.10.07.08.07; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.3.4.1 date 2014.01.15.21.26.20; author yamt; state dead; branches; next 1.1.1.3.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.3.4.2 date 2014.05.22.16.18.26; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.4.2.1 date 2015.06.04.20.04.27; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.4.4.1 date 2014.05.30.18.14.40; author tls; state dead; branches; next 1.1.1.4.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.4.4.2 date 2014.08.19.23.47.26; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.6.2.1 date 2017.03.20.06.52.36; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.8.2.1 date 2018.07.28.04.33.16; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.8.4.1 date 2019.06.10.21.45.20; author christos; state Exp; branches; next 1.1.1.8.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.8.4.2 date 2020.04.13.07.46.31; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- IdentifierTable.cpp - Hash table for identifier lookup -----------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file implements the IdentifierInfo, IdentifierVisitor, and // IdentifierTable interfaces. // //===----------------------------------------------------------------------===// #include "clang/Basic/IdentifierTable.h" #include "clang/Basic/LangOptions.h" #include "clang/Basic/CharInfo.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/FoldingSet.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/raw_ostream.h" #include using namespace clang; //===----------------------------------------------------------------------===// // IdentifierInfo Implementation //===----------------------------------------------------------------------===// IdentifierInfo::IdentifierInfo() { TokenID = tok::identifier; ObjCOrBuiltinID = 0; HasMacro = false; HadMacro = false; IsExtension = false; IsCXX11CompatKeyword = false; IsPoisoned = false; IsCPPOperatorKeyword = false; NeedsHandleIdentifier = false; IsFromAST = false; ChangedAfterLoad = false; RevertedTokenID = false; OutOfDate = false; IsModulesImport = false; FETokenInfo = 0; Entry = 0; } //===----------------------------------------------------------------------===// // IdentifierTable Implementation //===----------------------------------------------------------------------===// IdentifierIterator::~IdentifierIterator() { } IdentifierInfoLookup::~IdentifierInfoLookup() {} namespace { /// \brief A simple identifier lookup iterator that represents an /// empty sequence of identifiers. class EmptyLookupIterator : public IdentifierIterator { public: virtual StringRef Next() { return StringRef(); } }; } IdentifierIterator *IdentifierInfoLookup::getIdentifiers() { return new EmptyLookupIterator(); } ExternalIdentifierLookup::~ExternalIdentifierLookup() {} IdentifierTable::IdentifierTable(const LangOptions &LangOpts, IdentifierInfoLookup* externalLookup) : HashTable(8192), // Start with space for 8K identifiers. ExternalLookup(externalLookup) { // Populate the identifier table with info about keywords for the current // language. AddKeywords(LangOpts); // Add the '_experimental_modules_import' contextual keyword. get("import").setModulesImport(true); } //===----------------------------------------------------------------------===// // Language Keyword Implementation //===----------------------------------------------------------------------===// // Constants for TokenKinds.def namespace { enum { KEYC99 = 0x1, KEYCXX = 0x2, KEYCXX11 = 0x4, KEYGNU = 0x8, KEYMS = 0x10, BOOLSUPPORT = 0x20, KEYALTIVEC = 0x40, KEYNOCXX = 0x80, KEYBORLAND = 0x100, KEYOPENCL = 0x200, KEYC11 = 0x400, KEYARC = 0x800, KEYNOMS = 0x01000, WCHARSUPPORT = 0x02000, KEYALL = (0xffff & ~KEYNOMS) // Because KEYNOMS is used to exclude. }; } /// AddKeyword - This method is used to associate a token ID with specific /// identifiers because they are language keywords. This causes the lexer to /// automatically map matching identifiers to specialized token codes. /// /// The C90/C99/CPP/CPP0x flags are set to 3 if the token is a keyword in a /// future language standard, set to 2 if the token should be enabled in the /// specified language, set to 1 if it is an extension in the specified /// language, and set to 0 if disabled in the specified language. static void AddKeyword(StringRef Keyword, tok::TokenKind TokenCode, unsigned Flags, const LangOptions &LangOpts, IdentifierTable &Table) { unsigned AddResult = 0; if (Flags == KEYALL) AddResult = 2; else if (LangOpts.CPlusPlus && (Flags & KEYCXX)) AddResult = 2; else if (LangOpts.CPlusPlus11 && (Flags & KEYCXX11)) AddResult = 2; else if (LangOpts.C99 && (Flags & KEYC99)) AddResult = 2; else if (LangOpts.GNUKeywords && (Flags & KEYGNU)) AddResult = 1; else if (LangOpts.MicrosoftExt && (Flags & KEYMS)) AddResult = 1; else if (LangOpts.Borland && (Flags & KEYBORLAND)) AddResult = 1; else if (LangOpts.Bool && (Flags & BOOLSUPPORT)) AddResult = 2; else if (LangOpts.WChar && (Flags & WCHARSUPPORT)) AddResult = 2; else if (LangOpts.AltiVec && (Flags & KEYALTIVEC)) AddResult = 2; else if (LangOpts.OpenCL && (Flags & KEYOPENCL)) AddResult = 2; else if (!LangOpts.CPlusPlus && (Flags & KEYNOCXX)) AddResult = 2; else if (LangOpts.C11 && (Flags & KEYC11)) AddResult = 2; // We treat bridge casts as objective-C keywords so we can warn on them // in non-arc mode. else if (LangOpts.ObjC2 && (Flags & KEYARC)) AddResult = 2; else if (LangOpts.CPlusPlus && (Flags & KEYCXX11)) AddResult = 3; // Don't add this keyword under MicrosoftMode. if (LangOpts.MicrosoftMode && (Flags & KEYNOMS)) return; // Don't add this keyword if disabled in this language. if (AddResult == 0) return; IdentifierInfo &Info = Table.get(Keyword, AddResult == 3 ? tok::identifier : TokenCode); Info.setIsExtensionToken(AddResult == 1); Info.setIsCXX11CompatKeyword(AddResult == 3); } /// AddCXXOperatorKeyword - Register a C++ operator keyword alternative /// representations. static void AddCXXOperatorKeyword(StringRef Keyword, tok::TokenKind TokenCode, IdentifierTable &Table) { IdentifierInfo &Info = Table.get(Keyword, TokenCode); Info.setIsCPlusPlusOperatorKeyword(); } /// AddObjCKeyword - Register an Objective-C \@@keyword like "class" "selector" /// or "property". static void AddObjCKeyword(StringRef Name, tok::ObjCKeywordKind ObjCID, IdentifierTable &Table) { Table.get(Name).setObjCKeywordID(ObjCID); } /// AddKeywords - Add all keywords to the symbol table. /// void IdentifierTable::AddKeywords(const LangOptions &LangOpts) { // Add keywords and tokens for the current language. #define KEYWORD(NAME, FLAGS) \ AddKeyword(StringRef(#NAME), tok::kw_ ## NAME, \ FLAGS, LangOpts, *this); #define ALIAS(NAME, TOK, FLAGS) \ AddKeyword(StringRef(NAME), tok::kw_ ## TOK, \ FLAGS, LangOpts, *this); #define CXX_KEYWORD_OPERATOR(NAME, ALIAS) \ if (LangOpts.CXXOperatorNames) \ AddCXXOperatorKeyword(StringRef(#NAME), tok::ALIAS, *this); #define OBJC1_AT_KEYWORD(NAME) \ if (LangOpts.ObjC1) \ AddObjCKeyword(StringRef(#NAME), tok::objc_##NAME, *this); #define OBJC2_AT_KEYWORD(NAME) \ if (LangOpts.ObjC2) \ AddObjCKeyword(StringRef(#NAME), tok::objc_##NAME, *this); #define TESTING_KEYWORD(NAME, FLAGS) #include "clang/Basic/TokenKinds.def" if (LangOpts.ParseUnknownAnytype) AddKeyword("__unknown_anytype", tok::kw___unknown_anytype, KEYALL, LangOpts, *this); } tok::PPKeywordKind IdentifierInfo::getPPKeywordID() const { // We use a perfect hash function here involving the length of the keyword, // the first and third character. For preprocessor ID's there are no // collisions (if there were, the switch below would complain about duplicate // case values). Note that this depends on 'if' being null terminated. #define HASH(LEN, FIRST, THIRD) \ (LEN << 5) + (((FIRST-'a') + (THIRD-'a')) & 31) #define CASE(LEN, FIRST, THIRD, NAME) \ case HASH(LEN, FIRST, THIRD): \ return memcmp(Name, #NAME, LEN) ? tok::pp_not_keyword : tok::pp_ ## NAME unsigned Len = getLength(); if (Len < 2) return tok::pp_not_keyword; const char *Name = getNameStart(); switch (HASH(Len, Name[0], Name[2])) { default: return tok::pp_not_keyword; CASE( 2, 'i', '\0', if); CASE( 4, 'e', 'i', elif); CASE( 4, 'e', 's', else); CASE( 4, 'l', 'n', line); CASE( 4, 's', 'c', sccs); CASE( 5, 'e', 'd', endif); CASE( 5, 'e', 'r', error); CASE( 5, 'i', 'e', ident); CASE( 5, 'i', 'd', ifdef); CASE( 5, 'u', 'd', undef); CASE( 6, 'a', 's', assert); CASE( 6, 'd', 'f', define); CASE( 6, 'i', 'n', ifndef); CASE( 6, 'i', 'p', import); CASE( 6, 'p', 'a', pragma); CASE( 7, 'd', 'f', defined); CASE( 7, 'i', 'c', include); CASE( 7, 'w', 'r', warning); CASE( 8, 'u', 'a', unassert); CASE(12, 'i', 'c', include_next); CASE(14, '_', 'p', __public_macro); CASE(15, '_', 'p', __private_macro); CASE(16, '_', 'i', __include_macros); #undef CASE #undef HASH } } //===----------------------------------------------------------------------===// // Stats Implementation //===----------------------------------------------------------------------===// /// PrintStats - Print statistics about how well the identifier table is doing /// at hashing identifiers. void IdentifierTable::PrintStats() const { unsigned NumBuckets = HashTable.getNumBuckets(); unsigned NumIdentifiers = HashTable.getNumItems(); unsigned NumEmptyBuckets = NumBuckets-NumIdentifiers; unsigned AverageIdentifierSize = 0; unsigned MaxIdentifierLength = 0; // TODO: Figure out maximum times an identifier had to probe for -stats. for (llvm::StringMap::const_iterator I = HashTable.begin(), E = HashTable.end(); I != E; ++I) { unsigned IdLen = I->getKeyLength(); AverageIdentifierSize += IdLen; if (MaxIdentifierLength < IdLen) MaxIdentifierLength = IdLen; } fprintf(stderr, "\n*** Identifier Table Stats:\n"); fprintf(stderr, "# Identifiers: %d\n", NumIdentifiers); fprintf(stderr, "# Empty Buckets: %d\n", NumEmptyBuckets); fprintf(stderr, "Hash density (#identifiers per bucket): %f\n", NumIdentifiers/(double)NumBuckets); fprintf(stderr, "Ave identifier length: %f\n", (AverageIdentifierSize/(double)NumIdentifiers)); fprintf(stderr, "Max identifier length: %d\n", MaxIdentifierLength); // Compute statistics about the memory allocated for identifiers. HashTable.getAllocator().PrintStats(); } //===----------------------------------------------------------------------===// // SelectorTable Implementation //===----------------------------------------------------------------------===// unsigned llvm::DenseMapInfo::getHashValue(clang::Selector S) { return DenseMapInfo::getHashValue(S.getAsOpaquePtr()); } namespace clang { /// MultiKeywordSelector - One of these variable length records is kept for each /// selector containing more than one keyword. We use a folding set /// to unique aggregate names (keyword selectors in ObjC parlance). Access to /// this class is provided strictly through Selector. class MultiKeywordSelector : public DeclarationNameExtra, public llvm::FoldingSetNode { MultiKeywordSelector(unsigned nKeys) { ExtraKindOrNumArgs = NUM_EXTRA_KINDS + nKeys; } public: // Constructor for keyword selectors. MultiKeywordSelector(unsigned nKeys, IdentifierInfo **IIV) { assert((nKeys > 1) && "not a multi-keyword selector"); ExtraKindOrNumArgs = NUM_EXTRA_KINDS + nKeys; // Fill in the trailing keyword array. IdentifierInfo **KeyInfo = reinterpret_cast(this+1); for (unsigned i = 0; i != nKeys; ++i) KeyInfo[i] = IIV[i]; } // getName - Derive the full selector name and return it. std::string getName() const; unsigned getNumArgs() const { return ExtraKindOrNumArgs - NUM_EXTRA_KINDS; } typedef IdentifierInfo *const *keyword_iterator; keyword_iterator keyword_begin() const { return reinterpret_cast(this+1); } keyword_iterator keyword_end() const { return keyword_begin()+getNumArgs(); } IdentifierInfo *getIdentifierInfoForSlot(unsigned i) const { assert(i < getNumArgs() && "getIdentifierInfoForSlot(): illegal index"); return keyword_begin()[i]; } static void Profile(llvm::FoldingSetNodeID &ID, keyword_iterator ArgTys, unsigned NumArgs) { ID.AddInteger(NumArgs); for (unsigned i = 0; i != NumArgs; ++i) ID.AddPointer(ArgTys[i]); } void Profile(llvm::FoldingSetNodeID &ID) { Profile(ID, keyword_begin(), getNumArgs()); } }; } // end namespace clang. unsigned Selector::getNumArgs() const { unsigned IIF = getIdentifierInfoFlag(); if (IIF <= ZeroArg) return 0; if (IIF == OneArg) return 1; // We point to a MultiKeywordSelector. MultiKeywordSelector *SI = getMultiKeywordSelector(); return SI->getNumArgs(); } IdentifierInfo *Selector::getIdentifierInfoForSlot(unsigned argIndex) const { if (getIdentifierInfoFlag() < MultiArg) { assert(argIndex == 0 && "illegal keyword index"); return getAsIdentifierInfo(); } // We point to a MultiKeywordSelector. MultiKeywordSelector *SI = getMultiKeywordSelector(); return SI->getIdentifierInfoForSlot(argIndex); } StringRef Selector::getNameForSlot(unsigned int argIndex) const { IdentifierInfo *II = getIdentifierInfoForSlot(argIndex); return II? II->getName() : StringRef(); } std::string MultiKeywordSelector::getName() const { SmallString<256> Str; llvm::raw_svector_ostream OS(Str); for (keyword_iterator I = keyword_begin(), E = keyword_end(); I != E; ++I) { if (*I) OS << (*I)->getName(); OS << ':'; } return OS.str(); } std::string Selector::getAsString() const { if (InfoPtr == 0) return ""; if (getIdentifierInfoFlag() < MultiArg) { IdentifierInfo *II = getAsIdentifierInfo(); // If the number of arguments is 0 then II is guaranteed to not be null. if (getNumArgs() == 0) return II->getName(); if (!II) return ":"; return II->getName().str() + ":"; } // We have a multiple keyword selector. return getMultiKeywordSelector()->getName(); } /// Interpreting the given string using the normal CamelCase /// conventions, determine whether the given string starts with the /// given "word", which is assumed to end in a lowercase letter. static bool startsWithWord(StringRef name, StringRef word) { if (name.size() < word.size()) return false; return ((name.size() == word.size() || !isLowercase(name[word.size()])) && name.startswith(word)); } ObjCMethodFamily Selector::getMethodFamilyImpl(Selector sel) { IdentifierInfo *first = sel.getIdentifierInfoForSlot(0); if (!first) return OMF_None; StringRef name = first->getName(); if (sel.isUnarySelector()) { if (name == "autorelease") return OMF_autorelease; if (name == "dealloc") return OMF_dealloc; if (name == "finalize") return OMF_finalize; if (name == "release") return OMF_release; if (name == "retain") return OMF_retain; if (name == "retainCount") return OMF_retainCount; if (name == "self") return OMF_self; } if (name == "performSelector") return OMF_performSelector; // The other method families may begin with a prefix of underscores. while (!name.empty() && name.front() == '_') name = name.substr(1); if (name.empty()) return OMF_None; switch (name.front()) { case 'a': if (startsWithWord(name, "alloc")) return OMF_alloc; break; case 'c': if (startsWithWord(name, "copy")) return OMF_copy; break; case 'i': if (startsWithWord(name, "init")) return OMF_init; break; case 'm': if (startsWithWord(name, "mutableCopy")) return OMF_mutableCopy; break; case 'n': if (startsWithWord(name, "new")) return OMF_new; break; default: break; } return OMF_None; } ObjCInstanceTypeFamily Selector::getInstTypeMethodFamily(Selector sel) { IdentifierInfo *first = sel.getIdentifierInfoForSlot(0); if (!first) return OIT_None; StringRef name = first->getName(); if (name.empty()) return OIT_None; switch (name.front()) { case 'a': if (startsWithWord(name, "array")) return OIT_Array; break; case 'd': if (startsWithWord(name, "default")) return OIT_ReturnsSelf; if (startsWithWord(name, "dictionary")) return OIT_Dictionary; break; case 's': if (startsWithWord(name, "shared")) return OIT_ReturnsSelf; if (startsWithWord(name, "standard")) return OIT_Singleton; case 'i': if (startsWithWord(name, "init")) return OIT_Init; default: break; } return OIT_None; } namespace { struct SelectorTableImpl { llvm::FoldingSet Table; llvm::BumpPtrAllocator Allocator; }; } // end anonymous namespace. static SelectorTableImpl &getSelectorTableImpl(void *P) { return *static_cast(P); } SmallString<64> SelectorTable::constructSetterName(StringRef Name) { SmallString<64> SetterName("set"); SetterName += Name; SetterName[3] = toUppercase(SetterName[3]); return SetterName; } Selector SelectorTable::constructSetterSelector(IdentifierTable &Idents, SelectorTable &SelTable, const IdentifierInfo *Name) { IdentifierInfo *SetterName = &Idents.get(constructSetterName(Name->getName())); return SelTable.getUnarySelector(SetterName); } size_t SelectorTable::getTotalMemory() const { SelectorTableImpl &SelTabImpl = getSelectorTableImpl(Impl); return SelTabImpl.Allocator.getTotalMemory(); } Selector SelectorTable::getSelector(unsigned nKeys, IdentifierInfo **IIV) { if (nKeys < 2) return Selector(IIV[0], nKeys); SelectorTableImpl &SelTabImpl = getSelectorTableImpl(Impl); // Unique selector, to guarantee there is one per name. llvm::FoldingSetNodeID ID; MultiKeywordSelector::Profile(ID, IIV, nKeys); void *InsertPos = 0; if (MultiKeywordSelector *SI = SelTabImpl.Table.FindNodeOrInsertPos(ID, InsertPos)) return Selector(SI); // MultiKeywordSelector objects are not allocated with new because they have a // variable size array (for parameter types) at the end of them. unsigned Size = sizeof(MultiKeywordSelector) + nKeys*sizeof(IdentifierInfo *); MultiKeywordSelector *SI = (MultiKeywordSelector*)SelTabImpl.Allocator.Allocate(Size, llvm::alignOf()); new (SI) MultiKeywordSelector(nKeys, IIV); SelTabImpl.Table.InsertNode(SI, InsertPos); return Selector(SI); } SelectorTable::SelectorTable() { Impl = new SelectorTableImpl(); } SelectorTable::~SelectorTable() { delete &getSelectorTableImpl(Impl); } const char *clang::getOperatorSpelling(OverloadedOperatorKind Operator) { switch (Operator) { case OO_None: case NUM_OVERLOADED_OPERATORS: return 0; #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \ case OO_##Name: return Spelling; #include "clang/Basic/OperatorKinds.def" } llvm_unreachable("Invalid OverloadedOperatorKind!"); } @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import clang 3.5svn r198450. @ text @a400 4 void Selector::print(llvm::raw_ostream &OS) const { OS << getAsString(); } @ 1.1.1.3 log @Import Clang 3.5svn r199312 @ text @d16 1 a17 1 #include "clang/Basic/LangOptions.h" d142 2 a143 2 // Don't add this keyword under MSVCCompat. if (LangOpts.MSVCCompat && (Flags & KEYNOMS)) @ 1.1.1.3.2.1 log @Rebase. @ text @d15 1 a16 1 #include "clang/Basic/IdentifierTable.h" a17 1 #include "clang/Basic/OperatorKinds.h" a19 1 #include "llvm/ADT/SmallString.h" d45 2 a46 2 FETokenInfo = nullptr; Entry = nullptr; d63 1 a63 1 StringRef Next() override { return StringRef(); } a107 1 HALFSUPPORT = 0x04000, a131 1 else if (LangOpts.Half && (Flags & HALFSUPPORT)) AddResult = 2; d528 1 a528 1 void *InsertPos = nullptr; d556 1 a556 1 return nullptr; @ 1.1.1.4 log @Import Clang 3.5svn r209886. @ text @d15 1 a16 1 #include "clang/Basic/IdentifierTable.h" a17 1 #include "clang/Basic/OperatorKinds.h" a19 1 #include "llvm/ADT/SmallString.h" d45 2 a46 2 FETokenInfo = nullptr; Entry = nullptr; d63 1 a63 1 StringRef Next() override { return StringRef(); } a107 1 HALFSUPPORT = 0x04000, a131 1 else if (LangOpts.Half && (Flags & HALFSUPPORT)) AddResult = 2; d528 1 a528 1 void *InsertPos = nullptr; d556 1 a556 1 return nullptr; @ 1.1.1.4.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @a112 33 /// \brief How a keyword is treated in the selected standard. enum KeywordStatus { KS_Disabled, // Disabled KS_Extension, // Is an extension KS_Enabled, // Enabled KS_Future // Is a keyword in future standard }; } /// \brief Translates flags as specified in TokenKinds.def into keyword status /// in the given language standard. static KeywordStatus getKeywordStatus(const LangOptions &LangOpts, unsigned Flags) { if (Flags == KEYALL) return KS_Enabled; if (LangOpts.CPlusPlus && (Flags & KEYCXX)) return KS_Enabled; if (LangOpts.CPlusPlus11 && (Flags & KEYCXX11)) return KS_Enabled; if (LangOpts.C99 && (Flags & KEYC99)) return KS_Enabled; if (LangOpts.GNUKeywords && (Flags & KEYGNU)) return KS_Extension; if (LangOpts.MicrosoftExt && (Flags & KEYMS)) return KS_Extension; if (LangOpts.Borland && (Flags & KEYBORLAND)) return KS_Extension; if (LangOpts.Bool && (Flags & BOOLSUPPORT)) return KS_Enabled; if (LangOpts.Half && (Flags & HALFSUPPORT)) return KS_Enabled; if (LangOpts.WChar && (Flags & WCHARSUPPORT)) return KS_Enabled; if (LangOpts.AltiVec && (Flags & KEYALTIVEC)) return KS_Enabled; if (LangOpts.OpenCL && (Flags & KEYOPENCL)) return KS_Enabled; if (!LangOpts.CPlusPlus && (Flags & KEYNOCXX)) return KS_Enabled; if (LangOpts.C11 && (Flags & KEYC11)) return KS_Enabled; // We treat bridge casts as objective-C keywords so we can warn on them // in non-arc mode. if (LangOpts.ObjC2 && (Flags & KEYARC)) return KS_Enabled; if (LangOpts.CPlusPlus && (Flags & KEYCXX11)) return KS_Future; return KS_Disabled; d118 5 d126 19 a144 1 KeywordStatus AddResult = getKeywordStatus(LangOpts, Flags); d150 1 a150 1 if (AddResult == KS_Disabled) return; d153 3 a155 3 Table.get(Keyword, AddResult == KS_Future ? tok::identifier : TokenCode); Info.setIsExtensionToken(AddResult == KS_Extension); Info.setIsCXX11CompatKeyword(AddResult == KS_Future); a201 25 /// \brief Checks if the specified token kind represents a keyword in the /// specified language. /// \returns Status of the keyword in the language. static KeywordStatus getTokenKwStatus(const LangOptions &LangOpts, tok::TokenKind K) { switch (K) { #define KEYWORD(NAME, FLAGS) \ case tok::kw_##NAME: return getKeywordStatus(LangOpts, FLAGS); #include "clang/Basic/TokenKinds.def" default: return KS_Disabled; } } /// \brief Returns true if the identifier represents a keyword in the /// specified language. bool IdentifierInfo::isKeyword(const LangOptions &LangOpts) { switch (getTokenKwStatus(LangOpts, getTokenID())) { case KS_Enabled: case KS_Extension: return true; default: return false; } } a430 1 if (name == "initialize") return OMF_initialize; a488 27 ObjCStringFormatFamily Selector::getStringFormatFamilyImpl(Selector sel) { IdentifierInfo *first = sel.getIdentifierInfoForSlot(0); if (!first) return SFF_None; StringRef name = first->getName(); switch (name.front()) { case 'a': if (name == "appendFormat") return SFF_NSString; break; case 'i': if (name == "initWithFormat") return SFF_NSString; break; case 'l': if (name == "localizedStringWithFormat") return SFF_NSString; break; case 's': if (name == "stringByAppendingFormat" || name == "stringWithFormat") return SFF_NSString; break; } return SFF_None; } @ 1.1.1.5 log @Import Clang 3.6RC1 r227398. @ text @a112 33 /// \brief How a keyword is treated in the selected standard. enum KeywordStatus { KS_Disabled, // Disabled KS_Extension, // Is an extension KS_Enabled, // Enabled KS_Future // Is a keyword in future standard }; } /// \brief Translates flags as specified in TokenKinds.def into keyword status /// in the given language standard. static KeywordStatus getKeywordStatus(const LangOptions &LangOpts, unsigned Flags) { if (Flags == KEYALL) return KS_Enabled; if (LangOpts.CPlusPlus && (Flags & KEYCXX)) return KS_Enabled; if (LangOpts.CPlusPlus11 && (Flags & KEYCXX11)) return KS_Enabled; if (LangOpts.C99 && (Flags & KEYC99)) return KS_Enabled; if (LangOpts.GNUKeywords && (Flags & KEYGNU)) return KS_Extension; if (LangOpts.MicrosoftExt && (Flags & KEYMS)) return KS_Extension; if (LangOpts.Borland && (Flags & KEYBORLAND)) return KS_Extension; if (LangOpts.Bool && (Flags & BOOLSUPPORT)) return KS_Enabled; if (LangOpts.Half && (Flags & HALFSUPPORT)) return KS_Enabled; if (LangOpts.WChar && (Flags & WCHARSUPPORT)) return KS_Enabled; if (LangOpts.AltiVec && (Flags & KEYALTIVEC)) return KS_Enabled; if (LangOpts.OpenCL && (Flags & KEYOPENCL)) return KS_Enabled; if (!LangOpts.CPlusPlus && (Flags & KEYNOCXX)) return KS_Enabled; if (LangOpts.C11 && (Flags & KEYC11)) return KS_Enabled; // We treat bridge casts as objective-C keywords so we can warn on them // in non-arc mode. if (LangOpts.ObjC2 && (Flags & KEYARC)) return KS_Enabled; if (LangOpts.CPlusPlus && (Flags & KEYCXX11)) return KS_Future; return KS_Disabled; d118 5 d126 19 a144 1 KeywordStatus AddResult = getKeywordStatus(LangOpts, Flags); d150 1 a150 1 if (AddResult == KS_Disabled) return; d153 3 a155 3 Table.get(Keyword, AddResult == KS_Future ? tok::identifier : TokenCode); Info.setIsExtensionToken(AddResult == KS_Extension); Info.setIsCXX11CompatKeyword(AddResult == KS_Future); a201 25 /// \brief Checks if the specified token kind represents a keyword in the /// specified language. /// \returns Status of the keyword in the language. static KeywordStatus getTokenKwStatus(const LangOptions &LangOpts, tok::TokenKind K) { switch (K) { #define KEYWORD(NAME, FLAGS) \ case tok::kw_##NAME: return getKeywordStatus(LangOpts, FLAGS); #include "clang/Basic/TokenKinds.def" default: return KS_Disabled; } } /// \brief Returns true if the identifier represents a keyword in the /// specified language. bool IdentifierInfo::isKeyword(const LangOptions &LangOpts) { switch (getTokenKwStatus(LangOpts, getTokenID())) { case KS_Enabled: case KS_Extension: return true; default: return false; } } a430 1 if (name == "initialize") return OMF_initialize; a488 27 ObjCStringFormatFamily Selector::getStringFormatFamilyImpl(Selector sel) { IdentifierInfo *first = sel.getIdentifierInfoForSlot(0); if (!first) return SFF_None; StringRef name = first->getName(); switch (name.front()) { case 'a': if (name == "appendFormat") return SFF_NSString; break; case 'i': if (name == "initWithFormat") return SFF_NSString; break; case 'l': if (name == "localizedStringWithFormat") return SFF_NSString; break; case 's': if (name == "stringByAppendingFormat" || name == "stringWithFormat") return SFF_NSString; break; } return SFF_None; } @ 1.1.1.6 log @Import Clang 3.8.0rc3 r261930. @ text @a18 1 #include "clang/Basic/Specifiers.h" d38 1 a38 1 IsFutureCompatKeyword = false; d73 2 d108 4 a111 10 KEYNOMS18 = 0x01000, KEYNOOPENCL = 0x02000, WCHARSUPPORT = 0x04000, HALFSUPPORT = 0x08000, KEYCONCEPTS = 0x10000, KEYOBJC2 = 0x20000, KEYZVECTOR = 0x40000, KEYCOROUTINES = 0x80000, KEYALL = (0xfffff & ~KEYNOMS18 & ~KEYNOOPENCL) // KEYNOMS18 and KEYNOOPENCL are used to exclude. a143 3 if (LangOpts.ConceptsTS && (Flags & KEYCONCEPTS)) return KS_Enabled; if (LangOpts.ObjC2 && (Flags & KEYOBJC2)) return KS_Enabled; if (LangOpts.Coroutines && (Flags & KEYCOROUTINES)) return KS_Enabled; d157 2 a158 8 if (LangOpts.MSVCCompat && (Flags & KEYNOMS18) && !LangOpts.isCompatibleWithMSVC(LangOptions::MSVC2015)) return; // Don't add this keyword under OpenCL. if (LangOpts.OpenCL && (Flags & KEYNOOPENCL)) return; d165 1 a165 1 Info.setIsFutureCompatKeyword(AddResult == KS_Future); a209 3 if (LangOpts.DeclSpecKeyword) AddKeyword("__declspec", tok::kw___declspec, KEYALL, LangOpts, *this); a631 15 StringRef clang::getNullabilitySpelling(NullabilityKind kind, bool isContextSensitive) { switch (kind) { case NullabilityKind::NonNull: return isContextSensitive ? "nonnull" : "_Nonnull"; case NullabilityKind::Nullable: return isContextSensitive ? "nullable" : "_Nullable"; case NullabilityKind::Unspecified: return isContextSensitive ? "null_unspecified" : "_Null_unspecified"; } llvm_unreachable("Unknown nullability kind."); } @ 1.1.1.6.2.1 log @Sync with HEAD @ text @a44 1 FEChangedAfterLoad = false; d115 1 a115 2 KEYMODULES = 0x100000, KEYALL = (0x1fffff & ~KEYNOMS18 & d149 1 d151 1 a151 3 if (LangOpts.ConceptsTS && (Flags & KEYCONCEPTS)) return KS_Enabled; if (LangOpts.CoroutinesTS && (Flags & KEYCOROUTINES)) return KS_Enabled; if (LangOpts.ModulesTS && (Flags & KEYMODULES)) return KS_Enabled; d443 2 a444 3 if (getNumArgs() == 0) { assert(II && "If the number of arguments is 0 then II is guaranteed to " "not be null."); a445 1 } d621 2 a622 2 (MultiKeywordSelector *)SelTabImpl.Allocator.Allocate( Size, alignof(MultiKeywordSelector)); @ 1.1.1.7 log @Import Clang pre-4.0.0 r291444. @ text @a44 1 FEChangedAfterLoad = false; d115 1 a115 2 KEYMODULES = 0x100000, KEYALL = (0x1fffff & ~KEYNOMS18 & d149 1 d151 1 a151 3 if (LangOpts.ConceptsTS && (Flags & KEYCONCEPTS)) return KS_Enabled; if (LangOpts.CoroutinesTS && (Flags & KEYCOROUTINES)) return KS_Enabled; if (LangOpts.ModulesTS && (Flags & KEYMODULES)) return KS_Enabled; d443 2 a444 3 if (getNumArgs() == 0) { assert(II && "If the number of arguments is 0 then II is guaranteed to " "not be null."); a445 1 } d621 2 a622 2 (MultiKeywordSelector *)SelTabImpl.Allocator.Allocate( Size, alignof(MultiKeywordSelector)); @ 1.1.1.8 log @Import clang r309604 from branches/release_50 @ text @d247 1 a247 1 bool IdentifierInfo::isKeyword(const LangOptions &LangOpts) const { a256 13 /// \brief Returns true if the identifier represents a C++ keyword in the /// specified language. bool IdentifierInfo::isCPlusPlusKeyword(const LangOptions &LangOpts) const { if (!LangOpts.CPlusPlus || !isKeyword(LangOpts)) return false; // This is a C++ keyword if this identifier is not a keyword when checked // using LangOptions without C++ support. LangOptions LangOptsNoCPP = LangOpts; LangOptsNoCPP.CPlusPlus = false; LangOptsNoCPP.CPlusPlus11 = false; return !isKeyword(LangOptsNoCPP); } d490 2 a491 4 if (name == "performSelector" || name == "performSelectorInBackground" || name == "performSelectorOnMainThread") return OMF_performSelector; a538 1 break; @ 1.1.1.8.4.1 log @Sync with HEAD @ text @d1 1 a1 1 //===- IdentifierTable.cpp - Hash table for identifier lookup -------------===// d15 1 a16 1 #include "clang/Basic/CharInfo.h" d20 1 a20 2 #include "clang/Basic/TokenKinds.h" #include "llvm/ADT/DenseMapInfo.h" a22 3 #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" #include "llvm/Support/Allocator.h" a24 1 #include a25 2 #include #include d49 2 d57 1 a57 1 IdentifierIterator::~IdentifierIterator() = default; d59 1 a59 1 IdentifierInfoLookup::~IdentifierInfoLookup() = default; d62 8 a69 10 /// A simple identifier lookup iterator that represents an /// empty sequence of identifiers. class EmptyLookupIterator : public IdentifierIterator { public: StringRef Next() override { return StringRef(); } }; } // namespace d75 4 a78 3 IdentifierTable::IdentifierTable(IdentifierInfoLookup *ExternalLookup) : HashTable(8192), // Start with space for 8K identifiers. ExternalLookup(ExternalLookup) {} a79 3 IdentifierTable::IdentifierTable(const LangOptions &LangOpts, IdentifierInfoLookup *ExternalLookup) : IdentifierTable(ExternalLookup) { d83 4 a94 1 d105 1 a105 1 KEYOPENCLC = 0x200, d112 6 a117 10 CHAR8SUPPORT = 0x10000, KEYCONCEPTS = 0x20000, KEYOBJC2 = 0x40000, KEYZVECTOR = 0x80000, KEYCOROUTINES = 0x100000, KEYMODULES = 0x200000, KEYCXX2A = 0x400000, KEYOPENCLCXX = 0x800000, KEYALLCXX = KEYCXX | KEYCXX11 | KEYCXX2A, KEYALL = (0xffffff & ~KEYNOMS18 & d121 1 a121 1 /// How a keyword is treated in the selected standard. d128 1 d130 1 a130 3 } // namespace /// Translates flags as specified in TokenKinds.def into keyword status a136 1 if (LangOpts.CPlusPlus2a && (Flags & KEYCXX2A)) return KS_Enabled; a143 1 if (LangOpts.Char8 && (Flags & CHAR8SUPPORT)) return KS_Enabled; d145 1 a145 3 if (LangOpts.OpenCL && !LangOpts.OpenCLCPlusPlus && (Flags & KEYOPENCLC)) return KS_Enabled; if (LangOpts.OpenCLCPlusPlus && (Flags & KEYOPENCLCXX)) return KS_Enabled; d155 1 a155 1 if (LangOpts.CPlusPlus && (Flags & KEYALLCXX)) return KS_Future; a229 3 // Add the '_experimental_modules_import' contextual keyword. get("import").setModulesImport(true); d232 1 a232 1 /// Checks if the specified token kind represents a keyword in the d245 1 a245 1 /// Returns true if the identifier represents a keyword in the d257 1 a257 1 /// Returns true if the identifier represents a C++ keyword in the a266 1 LangOptsNoCPP.CPlusPlus2a = false; a364 1 a373 1 d391 1 a391 2 using keyword_iterator = IdentifierInfo *const *; a394 1 a397 1 a401 1 a407 1 d412 1 a412 2 } // namespace clang. a429 1 a478 2 LLVM_DUMP_METHOD void Selector::dump() const { print(llvm::errs()); } d591 5 a595 7 struct SelectorTableImpl { llvm::FoldingSet Table; llvm::BumpPtrAllocator Allocator; }; } // namespace a617 6 std::string SelectorTable::getPropertyNameFromSetterSelector(Selector Sel) { StringRef Name = Sel.getNameForSlot(0); assert(Name.startswith("set") && "invalid setter name"); return (Twine(toLowercase(Name[3])) + Name.drop_front(4)).str(); } @ 1.1.1.8.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.8.2.1 log @Sync with HEAD @ text @d1 1 a1 1 //===- IdentifierTable.cpp - Hash table for identifier lookup -------------===// d15 1 a16 1 #include "clang/Basic/CharInfo.h" d20 1 a20 2 #include "clang/Basic/TokenKinds.h" #include "llvm/ADT/DenseMapInfo.h" a22 3 #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" #include "llvm/Support/Allocator.h" a24 1 #include a25 2 #include #include d49 2 d57 1 a57 1 IdentifierIterator::~IdentifierIterator() = default; d59 1 a59 1 IdentifierInfoLookup::~IdentifierInfoLookup() = default; d62 8 a69 10 /// A simple identifier lookup iterator that represents an /// empty sequence of identifiers. class EmptyLookupIterator : public IdentifierIterator { public: StringRef Next() override { return StringRef(); } }; } // namespace d75 4 a78 3 IdentifierTable::IdentifierTable(IdentifierInfoLookup *ExternalLookup) : HashTable(8192), // Start with space for 8K identifiers. ExternalLookup(ExternalLookup) {} a79 3 IdentifierTable::IdentifierTable(const LangOptions &LangOpts, IdentifierInfoLookup *ExternalLookup) : IdentifierTable(ExternalLookup) { d83 4 a94 1 d105 1 a105 1 KEYOPENCLC = 0x200, d112 6 a117 10 CHAR8SUPPORT = 0x10000, KEYCONCEPTS = 0x20000, KEYOBJC2 = 0x40000, KEYZVECTOR = 0x80000, KEYCOROUTINES = 0x100000, KEYMODULES = 0x200000, KEYCXX2A = 0x400000, KEYOPENCLCXX = 0x800000, KEYALLCXX = KEYCXX | KEYCXX11 | KEYCXX2A, KEYALL = (0xffffff & ~KEYNOMS18 & d121 1 a121 1 /// How a keyword is treated in the selected standard. d128 1 d130 1 a130 3 } // namespace /// Translates flags as specified in TokenKinds.def into keyword status a136 1 if (LangOpts.CPlusPlus2a && (Flags & KEYCXX2A)) return KS_Enabled; a143 1 if (LangOpts.Char8 && (Flags & CHAR8SUPPORT)) return KS_Enabled; d145 1 a145 3 if (LangOpts.OpenCL && !LangOpts.OpenCLCPlusPlus && (Flags & KEYOPENCLC)) return KS_Enabled; if (LangOpts.OpenCLCPlusPlus && (Flags & KEYOPENCLCXX)) return KS_Enabled; d155 1 a155 1 if (LangOpts.CPlusPlus && (Flags & KEYALLCXX)) return KS_Future; a229 3 // Add the '_experimental_modules_import' contextual keyword. get("import").setModulesImport(true); d232 1 a232 1 /// Checks if the specified token kind represents a keyword in the d245 1 a245 1 /// Returns true if the identifier represents a keyword in the d257 1 a257 1 /// Returns true if the identifier represents a C++ keyword in the a266 1 LangOptsNoCPP.CPlusPlus2a = false; a364 1 a373 1 d391 1 a391 2 using keyword_iterator = IdentifierInfo *const *; a394 1 a397 1 a401 1 a407 1 d412 1 a412 2 } // namespace clang. a429 1 a478 2 LLVM_DUMP_METHOD void Selector::dump() const { print(llvm::errs()); } d591 5 a595 7 struct SelectorTableImpl { llvm::FoldingSet Table; llvm::BumpPtrAllocator Allocator; }; } // namespace a617 6 std::string SelectorTable::getPropertyNameFromSetterSelector(Selector Sel) { StringRef Name = Sel.getNameForSlot(0); assert(Name.startswith("set") && "invalid setter name"); return (Twine(toLowercase(Name[3])) + Name.drop_front(4)).str(); } @ 1.1.1.9 log @Import clang r337282 from trunk @ text @d1 1 a1 1 //===- IdentifierTable.cpp - Hash table for identifier lookup -------------===// d15 1 a16 1 #include "clang/Basic/CharInfo.h" d20 1 a20 2 #include "clang/Basic/TokenKinds.h" #include "llvm/ADT/DenseMapInfo.h" a22 3 #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" #include "llvm/Support/Allocator.h" a24 1 #include a25 2 #include #include d49 2 d57 1 a57 1 IdentifierIterator::~IdentifierIterator() = default; d59 1 a59 1 IdentifierInfoLookup::~IdentifierInfoLookup() = default; d62 8 a69 10 /// A simple identifier lookup iterator that represents an /// empty sequence of identifiers. class EmptyLookupIterator : public IdentifierIterator { public: StringRef Next() override { return StringRef(); } }; } // namespace d75 4 a78 3 IdentifierTable::IdentifierTable(IdentifierInfoLookup *ExternalLookup) : HashTable(8192), // Start with space for 8K identifiers. ExternalLookup(ExternalLookup) {} a79 3 IdentifierTable::IdentifierTable(const LangOptions &LangOpts, IdentifierInfoLookup *ExternalLookup) : IdentifierTable(ExternalLookup) { d83 4 a94 1 d105 1 a105 1 KEYOPENCLC = 0x200, d112 6 a117 10 CHAR8SUPPORT = 0x10000, KEYCONCEPTS = 0x20000, KEYOBJC2 = 0x40000, KEYZVECTOR = 0x80000, KEYCOROUTINES = 0x100000, KEYMODULES = 0x200000, KEYCXX2A = 0x400000, KEYOPENCLCXX = 0x800000, KEYALLCXX = KEYCXX | KEYCXX11 | KEYCXX2A, KEYALL = (0xffffff & ~KEYNOMS18 & d121 1 a121 1 /// How a keyword is treated in the selected standard. d128 1 d130 1 a130 3 } // namespace /// Translates flags as specified in TokenKinds.def into keyword status a136 1 if (LangOpts.CPlusPlus2a && (Flags & KEYCXX2A)) return KS_Enabled; a143 1 if (LangOpts.Char8 && (Flags & CHAR8SUPPORT)) return KS_Enabled; d145 1 a145 3 if (LangOpts.OpenCL && !LangOpts.OpenCLCPlusPlus && (Flags & KEYOPENCLC)) return KS_Enabled; if (LangOpts.OpenCLCPlusPlus && (Flags & KEYOPENCLCXX)) return KS_Enabled; d155 1 a155 1 if (LangOpts.CPlusPlus && (Flags & KEYALLCXX)) return KS_Future; a229 3 // Add the '_experimental_modules_import' contextual keyword. get("import").setModulesImport(true); d232 1 a232 1 /// Checks if the specified token kind represents a keyword in the d245 1 a245 1 /// Returns true if the identifier represents a keyword in the d257 1 a257 1 /// Returns true if the identifier represents a C++ keyword in the a266 1 LangOptsNoCPP.CPlusPlus2a = false; a364 1 a373 1 d391 1 a391 2 using keyword_iterator = IdentifierInfo *const *; a394 1 a397 1 a401 1 a407 1 d412 1 a412 2 } // namespace clang. a429 1 a478 2 LLVM_DUMP_METHOD void Selector::dump() const { print(llvm::errs()); } d591 5 a595 7 struct SelectorTableImpl { llvm::FoldingSet Table; llvm::BumpPtrAllocator Allocator; }; } // namespace a617 6 std::string SelectorTable::getPropertyNameFromSetterSelector(Selector Sel) { StringRef Name = Sel.getNameForSlot(0); assert(Name.startswith("set") && "invalid setter name"); return (Twine(toLowercase(Name[3])) + Name.drop_front(4)).str(); } @ 1.1.1.10 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.4.4.1 log @file IdentifierTable.cpp was added on branch tls-maxphys on 2014-08-19 23:47:26 +0000 @ text @d1 568 @ 1.1.1.4.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 568 //===--- IdentifierTable.cpp - Hash table for identifier lookup -----------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file implements the IdentifierInfo, IdentifierVisitor, and // IdentifierTable interfaces. // //===----------------------------------------------------------------------===// #include "clang/Basic/CharInfo.h" #include "clang/Basic/IdentifierTable.h" #include "clang/Basic/LangOptions.h" #include "clang/Basic/OperatorKinds.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/FoldingSet.h" #include "llvm/ADT/SmallString.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/raw_ostream.h" #include using namespace clang; //===----------------------------------------------------------------------===// // IdentifierInfo Implementation //===----------------------------------------------------------------------===// IdentifierInfo::IdentifierInfo() { TokenID = tok::identifier; ObjCOrBuiltinID = 0; HasMacro = false; HadMacro = false; IsExtension = false; IsCXX11CompatKeyword = false; IsPoisoned = false; IsCPPOperatorKeyword = false; NeedsHandleIdentifier = false; IsFromAST = false; ChangedAfterLoad = false; RevertedTokenID = false; OutOfDate = false; IsModulesImport = false; FETokenInfo = nullptr; Entry = nullptr; } //===----------------------------------------------------------------------===// // IdentifierTable Implementation //===----------------------------------------------------------------------===// IdentifierIterator::~IdentifierIterator() { } IdentifierInfoLookup::~IdentifierInfoLookup() {} namespace { /// \brief A simple identifier lookup iterator that represents an /// empty sequence of identifiers. class EmptyLookupIterator : public IdentifierIterator { public: StringRef Next() override { return StringRef(); } }; } IdentifierIterator *IdentifierInfoLookup::getIdentifiers() { return new EmptyLookupIterator(); } ExternalIdentifierLookup::~ExternalIdentifierLookup() {} IdentifierTable::IdentifierTable(const LangOptions &LangOpts, IdentifierInfoLookup* externalLookup) : HashTable(8192), // Start with space for 8K identifiers. ExternalLookup(externalLookup) { // Populate the identifier table with info about keywords for the current // language. AddKeywords(LangOpts); // Add the '_experimental_modules_import' contextual keyword. get("import").setModulesImport(true); } //===----------------------------------------------------------------------===// // Language Keyword Implementation //===----------------------------------------------------------------------===// // Constants for TokenKinds.def namespace { enum { KEYC99 = 0x1, KEYCXX = 0x2, KEYCXX11 = 0x4, KEYGNU = 0x8, KEYMS = 0x10, BOOLSUPPORT = 0x20, KEYALTIVEC = 0x40, KEYNOCXX = 0x80, KEYBORLAND = 0x100, KEYOPENCL = 0x200, KEYC11 = 0x400, KEYARC = 0x800, KEYNOMS = 0x01000, WCHARSUPPORT = 0x02000, HALFSUPPORT = 0x04000, KEYALL = (0xffff & ~KEYNOMS) // Because KEYNOMS is used to exclude. }; } /// AddKeyword - This method is used to associate a token ID with specific /// identifiers because they are language keywords. This causes the lexer to /// automatically map matching identifiers to specialized token codes. /// /// The C90/C99/CPP/CPP0x flags are set to 3 if the token is a keyword in a /// future language standard, set to 2 if the token should be enabled in the /// specified language, set to 1 if it is an extension in the specified /// language, and set to 0 if disabled in the specified language. static void AddKeyword(StringRef Keyword, tok::TokenKind TokenCode, unsigned Flags, const LangOptions &LangOpts, IdentifierTable &Table) { unsigned AddResult = 0; if (Flags == KEYALL) AddResult = 2; else if (LangOpts.CPlusPlus && (Flags & KEYCXX)) AddResult = 2; else if (LangOpts.CPlusPlus11 && (Flags & KEYCXX11)) AddResult = 2; else if (LangOpts.C99 && (Flags & KEYC99)) AddResult = 2; else if (LangOpts.GNUKeywords && (Flags & KEYGNU)) AddResult = 1; else if (LangOpts.MicrosoftExt && (Flags & KEYMS)) AddResult = 1; else if (LangOpts.Borland && (Flags & KEYBORLAND)) AddResult = 1; else if (LangOpts.Bool && (Flags & BOOLSUPPORT)) AddResult = 2; else if (LangOpts.Half && (Flags & HALFSUPPORT)) AddResult = 2; else if (LangOpts.WChar && (Flags & WCHARSUPPORT)) AddResult = 2; else if (LangOpts.AltiVec && (Flags & KEYALTIVEC)) AddResult = 2; else if (LangOpts.OpenCL && (Flags & KEYOPENCL)) AddResult = 2; else if (!LangOpts.CPlusPlus && (Flags & KEYNOCXX)) AddResult = 2; else if (LangOpts.C11 && (Flags & KEYC11)) AddResult = 2; // We treat bridge casts as objective-C keywords so we can warn on them // in non-arc mode. else if (LangOpts.ObjC2 && (Flags & KEYARC)) AddResult = 2; else if (LangOpts.CPlusPlus && (Flags & KEYCXX11)) AddResult = 3; // Don't add this keyword under MSVCCompat. if (LangOpts.MSVCCompat && (Flags & KEYNOMS)) return; // Don't add this keyword if disabled in this language. if (AddResult == 0) return; IdentifierInfo &Info = Table.get(Keyword, AddResult == 3 ? tok::identifier : TokenCode); Info.setIsExtensionToken(AddResult == 1); Info.setIsCXX11CompatKeyword(AddResult == 3); } /// AddCXXOperatorKeyword - Register a C++ operator keyword alternative /// representations. static void AddCXXOperatorKeyword(StringRef Keyword, tok::TokenKind TokenCode, IdentifierTable &Table) { IdentifierInfo &Info = Table.get(Keyword, TokenCode); Info.setIsCPlusPlusOperatorKeyword(); } /// AddObjCKeyword - Register an Objective-C \@@keyword like "class" "selector" /// or "property". static void AddObjCKeyword(StringRef Name, tok::ObjCKeywordKind ObjCID, IdentifierTable &Table) { Table.get(Name).setObjCKeywordID(ObjCID); } /// AddKeywords - Add all keywords to the symbol table. /// void IdentifierTable::AddKeywords(const LangOptions &LangOpts) { // Add keywords and tokens for the current language. #define KEYWORD(NAME, FLAGS) \ AddKeyword(StringRef(#NAME), tok::kw_ ## NAME, \ FLAGS, LangOpts, *this); #define ALIAS(NAME, TOK, FLAGS) \ AddKeyword(StringRef(NAME), tok::kw_ ## TOK, \ FLAGS, LangOpts, *this); #define CXX_KEYWORD_OPERATOR(NAME, ALIAS) \ if (LangOpts.CXXOperatorNames) \ AddCXXOperatorKeyword(StringRef(#NAME), tok::ALIAS, *this); #define OBJC1_AT_KEYWORD(NAME) \ if (LangOpts.ObjC1) \ AddObjCKeyword(StringRef(#NAME), tok::objc_##NAME, *this); #define OBJC2_AT_KEYWORD(NAME) \ if (LangOpts.ObjC2) \ AddObjCKeyword(StringRef(#NAME), tok::objc_##NAME, *this); #define TESTING_KEYWORD(NAME, FLAGS) #include "clang/Basic/TokenKinds.def" if (LangOpts.ParseUnknownAnytype) AddKeyword("__unknown_anytype", tok::kw___unknown_anytype, KEYALL, LangOpts, *this); } tok::PPKeywordKind IdentifierInfo::getPPKeywordID() const { // We use a perfect hash function here involving the length of the keyword, // the first and third character. For preprocessor ID's there are no // collisions (if there were, the switch below would complain about duplicate // case values). Note that this depends on 'if' being null terminated. #define HASH(LEN, FIRST, THIRD) \ (LEN << 5) + (((FIRST-'a') + (THIRD-'a')) & 31) #define CASE(LEN, FIRST, THIRD, NAME) \ case HASH(LEN, FIRST, THIRD): \ return memcmp(Name, #NAME, LEN) ? tok::pp_not_keyword : tok::pp_ ## NAME unsigned Len = getLength(); if (Len < 2) return tok::pp_not_keyword; const char *Name = getNameStart(); switch (HASH(Len, Name[0], Name[2])) { default: return tok::pp_not_keyword; CASE( 2, 'i', '\0', if); CASE( 4, 'e', 'i', elif); CASE( 4, 'e', 's', else); CASE( 4, 'l', 'n', line); CASE( 4, 's', 'c', sccs); CASE( 5, 'e', 'd', endif); CASE( 5, 'e', 'r', error); CASE( 5, 'i', 'e', ident); CASE( 5, 'i', 'd', ifdef); CASE( 5, 'u', 'd', undef); CASE( 6, 'a', 's', assert); CASE( 6, 'd', 'f', define); CASE( 6, 'i', 'n', ifndef); CASE( 6, 'i', 'p', import); CASE( 6, 'p', 'a', pragma); CASE( 7, 'd', 'f', defined); CASE( 7, 'i', 'c', include); CASE( 7, 'w', 'r', warning); CASE( 8, 'u', 'a', unassert); CASE(12, 'i', 'c', include_next); CASE(14, '_', 'p', __public_macro); CASE(15, '_', 'p', __private_macro); CASE(16, '_', 'i', __include_macros); #undef CASE #undef HASH } } //===----------------------------------------------------------------------===// // Stats Implementation //===----------------------------------------------------------------------===// /// PrintStats - Print statistics about how well the identifier table is doing /// at hashing identifiers. void IdentifierTable::PrintStats() const { unsigned NumBuckets = HashTable.getNumBuckets(); unsigned NumIdentifiers = HashTable.getNumItems(); unsigned NumEmptyBuckets = NumBuckets-NumIdentifiers; unsigned AverageIdentifierSize = 0; unsigned MaxIdentifierLength = 0; // TODO: Figure out maximum times an identifier had to probe for -stats. for (llvm::StringMap::const_iterator I = HashTable.begin(), E = HashTable.end(); I != E; ++I) { unsigned IdLen = I->getKeyLength(); AverageIdentifierSize += IdLen; if (MaxIdentifierLength < IdLen) MaxIdentifierLength = IdLen; } fprintf(stderr, "\n*** Identifier Table Stats:\n"); fprintf(stderr, "# Identifiers: %d\n", NumIdentifiers); fprintf(stderr, "# Empty Buckets: %d\n", NumEmptyBuckets); fprintf(stderr, "Hash density (#identifiers per bucket): %f\n", NumIdentifiers/(double)NumBuckets); fprintf(stderr, "Ave identifier length: %f\n", (AverageIdentifierSize/(double)NumIdentifiers)); fprintf(stderr, "Max identifier length: %d\n", MaxIdentifierLength); // Compute statistics about the memory allocated for identifiers. HashTable.getAllocator().PrintStats(); } //===----------------------------------------------------------------------===// // SelectorTable Implementation //===----------------------------------------------------------------------===// unsigned llvm::DenseMapInfo::getHashValue(clang::Selector S) { return DenseMapInfo::getHashValue(S.getAsOpaquePtr()); } namespace clang { /// MultiKeywordSelector - One of these variable length records is kept for each /// selector containing more than one keyword. We use a folding set /// to unique aggregate names (keyword selectors in ObjC parlance). Access to /// this class is provided strictly through Selector. class MultiKeywordSelector : public DeclarationNameExtra, public llvm::FoldingSetNode { MultiKeywordSelector(unsigned nKeys) { ExtraKindOrNumArgs = NUM_EXTRA_KINDS + nKeys; } public: // Constructor for keyword selectors. MultiKeywordSelector(unsigned nKeys, IdentifierInfo **IIV) { assert((nKeys > 1) && "not a multi-keyword selector"); ExtraKindOrNumArgs = NUM_EXTRA_KINDS + nKeys; // Fill in the trailing keyword array. IdentifierInfo **KeyInfo = reinterpret_cast(this+1); for (unsigned i = 0; i != nKeys; ++i) KeyInfo[i] = IIV[i]; } // getName - Derive the full selector name and return it. std::string getName() const; unsigned getNumArgs() const { return ExtraKindOrNumArgs - NUM_EXTRA_KINDS; } typedef IdentifierInfo *const *keyword_iterator; keyword_iterator keyword_begin() const { return reinterpret_cast(this+1); } keyword_iterator keyword_end() const { return keyword_begin()+getNumArgs(); } IdentifierInfo *getIdentifierInfoForSlot(unsigned i) const { assert(i < getNumArgs() && "getIdentifierInfoForSlot(): illegal index"); return keyword_begin()[i]; } static void Profile(llvm::FoldingSetNodeID &ID, keyword_iterator ArgTys, unsigned NumArgs) { ID.AddInteger(NumArgs); for (unsigned i = 0; i != NumArgs; ++i) ID.AddPointer(ArgTys[i]); } void Profile(llvm::FoldingSetNodeID &ID) { Profile(ID, keyword_begin(), getNumArgs()); } }; } // end namespace clang. unsigned Selector::getNumArgs() const { unsigned IIF = getIdentifierInfoFlag(); if (IIF <= ZeroArg) return 0; if (IIF == OneArg) return 1; // We point to a MultiKeywordSelector. MultiKeywordSelector *SI = getMultiKeywordSelector(); return SI->getNumArgs(); } IdentifierInfo *Selector::getIdentifierInfoForSlot(unsigned argIndex) const { if (getIdentifierInfoFlag() < MultiArg) { assert(argIndex == 0 && "illegal keyword index"); return getAsIdentifierInfo(); } // We point to a MultiKeywordSelector. MultiKeywordSelector *SI = getMultiKeywordSelector(); return SI->getIdentifierInfoForSlot(argIndex); } StringRef Selector::getNameForSlot(unsigned int argIndex) const { IdentifierInfo *II = getIdentifierInfoForSlot(argIndex); return II? II->getName() : StringRef(); } std::string MultiKeywordSelector::getName() const { SmallString<256> Str; llvm::raw_svector_ostream OS(Str); for (keyword_iterator I = keyword_begin(), E = keyword_end(); I != E; ++I) { if (*I) OS << (*I)->getName(); OS << ':'; } return OS.str(); } std::string Selector::getAsString() const { if (InfoPtr == 0) return ""; if (getIdentifierInfoFlag() < MultiArg) { IdentifierInfo *II = getAsIdentifierInfo(); // If the number of arguments is 0 then II is guaranteed to not be null. if (getNumArgs() == 0) return II->getName(); if (!II) return ":"; return II->getName().str() + ":"; } // We have a multiple keyword selector. return getMultiKeywordSelector()->getName(); } void Selector::print(llvm::raw_ostream &OS) const { OS << getAsString(); } /// Interpreting the given string using the normal CamelCase /// conventions, determine whether the given string starts with the /// given "word", which is assumed to end in a lowercase letter. static bool startsWithWord(StringRef name, StringRef word) { if (name.size() < word.size()) return false; return ((name.size() == word.size() || !isLowercase(name[word.size()])) && name.startswith(word)); } ObjCMethodFamily Selector::getMethodFamilyImpl(Selector sel) { IdentifierInfo *first = sel.getIdentifierInfoForSlot(0); if (!first) return OMF_None; StringRef name = first->getName(); if (sel.isUnarySelector()) { if (name == "autorelease") return OMF_autorelease; if (name == "dealloc") return OMF_dealloc; if (name == "finalize") return OMF_finalize; if (name == "release") return OMF_release; if (name == "retain") return OMF_retain; if (name == "retainCount") return OMF_retainCount; if (name == "self") return OMF_self; } if (name == "performSelector") return OMF_performSelector; // The other method families may begin with a prefix of underscores. while (!name.empty() && name.front() == '_') name = name.substr(1); if (name.empty()) return OMF_None; switch (name.front()) { case 'a': if (startsWithWord(name, "alloc")) return OMF_alloc; break; case 'c': if (startsWithWord(name, "copy")) return OMF_copy; break; case 'i': if (startsWithWord(name, "init")) return OMF_init; break; case 'm': if (startsWithWord(name, "mutableCopy")) return OMF_mutableCopy; break; case 'n': if (startsWithWord(name, "new")) return OMF_new; break; default: break; } return OMF_None; } ObjCInstanceTypeFamily Selector::getInstTypeMethodFamily(Selector sel) { IdentifierInfo *first = sel.getIdentifierInfoForSlot(0); if (!first) return OIT_None; StringRef name = first->getName(); if (name.empty()) return OIT_None; switch (name.front()) { case 'a': if (startsWithWord(name, "array")) return OIT_Array; break; case 'd': if (startsWithWord(name, "default")) return OIT_ReturnsSelf; if (startsWithWord(name, "dictionary")) return OIT_Dictionary; break; case 's': if (startsWithWord(name, "shared")) return OIT_ReturnsSelf; if (startsWithWord(name, "standard")) return OIT_Singleton; case 'i': if (startsWithWord(name, "init")) return OIT_Init; default: break; } return OIT_None; } namespace { struct SelectorTableImpl { llvm::FoldingSet Table; llvm::BumpPtrAllocator Allocator; }; } // end anonymous namespace. static SelectorTableImpl &getSelectorTableImpl(void *P) { return *static_cast(P); } SmallString<64> SelectorTable::constructSetterName(StringRef Name) { SmallString<64> SetterName("set"); SetterName += Name; SetterName[3] = toUppercase(SetterName[3]); return SetterName; } Selector SelectorTable::constructSetterSelector(IdentifierTable &Idents, SelectorTable &SelTable, const IdentifierInfo *Name) { IdentifierInfo *SetterName = &Idents.get(constructSetterName(Name->getName())); return SelTable.getUnarySelector(SetterName); } size_t SelectorTable::getTotalMemory() const { SelectorTableImpl &SelTabImpl = getSelectorTableImpl(Impl); return SelTabImpl.Allocator.getTotalMemory(); } Selector SelectorTable::getSelector(unsigned nKeys, IdentifierInfo **IIV) { if (nKeys < 2) return Selector(IIV[0], nKeys); SelectorTableImpl &SelTabImpl = getSelectorTableImpl(Impl); // Unique selector, to guarantee there is one per name. llvm::FoldingSetNodeID ID; MultiKeywordSelector::Profile(ID, IIV, nKeys); void *InsertPos = nullptr; if (MultiKeywordSelector *SI = SelTabImpl.Table.FindNodeOrInsertPos(ID, InsertPos)) return Selector(SI); // MultiKeywordSelector objects are not allocated with new because they have a // variable size array (for parameter types) at the end of them. unsigned Size = sizeof(MultiKeywordSelector) + nKeys*sizeof(IdentifierInfo *); MultiKeywordSelector *SI = (MultiKeywordSelector*)SelTabImpl.Allocator.Allocate(Size, llvm::alignOf()); new (SI) MultiKeywordSelector(nKeys, IIV); SelTabImpl.Table.InsertNode(SI, InsertPos); return Selector(SI); } SelectorTable::SelectorTable() { Impl = new SelectorTableImpl(); } SelectorTable::~SelectorTable() { delete &getSelectorTableImpl(Impl); } const char *clang::getOperatorSpelling(OverloadedOperatorKind Operator) { switch (Operator) { case OO_None: case NUM_OVERLOADED_OPERATORS: return nullptr; #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \ case OO_##Name: return Spelling; #include "clang/Basic/OperatorKinds.def" } llvm_unreachable("Invalid OverloadedOperatorKind!"); } @ 1.1.1.3.4.1 log @file IdentifierTable.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:26 +0000 @ text @d1 564 @ 1.1.1.3.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 564 //===--- IdentifierTable.cpp - Hash table for identifier lookup -----------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file implements the IdentifierInfo, IdentifierVisitor, and // IdentifierTable interfaces. // //===----------------------------------------------------------------------===// #include "clang/Basic/IdentifierTable.h" #include "clang/Basic/CharInfo.h" #include "clang/Basic/LangOptions.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/FoldingSet.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/raw_ostream.h" #include using namespace clang; //===----------------------------------------------------------------------===// // IdentifierInfo Implementation //===----------------------------------------------------------------------===// IdentifierInfo::IdentifierInfo() { TokenID = tok::identifier; ObjCOrBuiltinID = 0; HasMacro = false; HadMacro = false; IsExtension = false; IsCXX11CompatKeyword = false; IsPoisoned = false; IsCPPOperatorKeyword = false; NeedsHandleIdentifier = false; IsFromAST = false; ChangedAfterLoad = false; RevertedTokenID = false; OutOfDate = false; IsModulesImport = false; FETokenInfo = 0; Entry = 0; } //===----------------------------------------------------------------------===// // IdentifierTable Implementation //===----------------------------------------------------------------------===// IdentifierIterator::~IdentifierIterator() { } IdentifierInfoLookup::~IdentifierInfoLookup() {} namespace { /// \brief A simple identifier lookup iterator that represents an /// empty sequence of identifiers. class EmptyLookupIterator : public IdentifierIterator { public: virtual StringRef Next() { return StringRef(); } }; } IdentifierIterator *IdentifierInfoLookup::getIdentifiers() { return new EmptyLookupIterator(); } ExternalIdentifierLookup::~ExternalIdentifierLookup() {} IdentifierTable::IdentifierTable(const LangOptions &LangOpts, IdentifierInfoLookup* externalLookup) : HashTable(8192), // Start with space for 8K identifiers. ExternalLookup(externalLookup) { // Populate the identifier table with info about keywords for the current // language. AddKeywords(LangOpts); // Add the '_experimental_modules_import' contextual keyword. get("import").setModulesImport(true); } //===----------------------------------------------------------------------===// // Language Keyword Implementation //===----------------------------------------------------------------------===// // Constants for TokenKinds.def namespace { enum { KEYC99 = 0x1, KEYCXX = 0x2, KEYCXX11 = 0x4, KEYGNU = 0x8, KEYMS = 0x10, BOOLSUPPORT = 0x20, KEYALTIVEC = 0x40, KEYNOCXX = 0x80, KEYBORLAND = 0x100, KEYOPENCL = 0x200, KEYC11 = 0x400, KEYARC = 0x800, KEYNOMS = 0x01000, WCHARSUPPORT = 0x02000, KEYALL = (0xffff & ~KEYNOMS) // Because KEYNOMS is used to exclude. }; } /// AddKeyword - This method is used to associate a token ID with specific /// identifiers because they are language keywords. This causes the lexer to /// automatically map matching identifiers to specialized token codes. /// /// The C90/C99/CPP/CPP0x flags are set to 3 if the token is a keyword in a /// future language standard, set to 2 if the token should be enabled in the /// specified language, set to 1 if it is an extension in the specified /// language, and set to 0 if disabled in the specified language. static void AddKeyword(StringRef Keyword, tok::TokenKind TokenCode, unsigned Flags, const LangOptions &LangOpts, IdentifierTable &Table) { unsigned AddResult = 0; if (Flags == KEYALL) AddResult = 2; else if (LangOpts.CPlusPlus && (Flags & KEYCXX)) AddResult = 2; else if (LangOpts.CPlusPlus11 && (Flags & KEYCXX11)) AddResult = 2; else if (LangOpts.C99 && (Flags & KEYC99)) AddResult = 2; else if (LangOpts.GNUKeywords && (Flags & KEYGNU)) AddResult = 1; else if (LangOpts.MicrosoftExt && (Flags & KEYMS)) AddResult = 1; else if (LangOpts.Borland && (Flags & KEYBORLAND)) AddResult = 1; else if (LangOpts.Bool && (Flags & BOOLSUPPORT)) AddResult = 2; else if (LangOpts.WChar && (Flags & WCHARSUPPORT)) AddResult = 2; else if (LangOpts.AltiVec && (Flags & KEYALTIVEC)) AddResult = 2; else if (LangOpts.OpenCL && (Flags & KEYOPENCL)) AddResult = 2; else if (!LangOpts.CPlusPlus && (Flags & KEYNOCXX)) AddResult = 2; else if (LangOpts.C11 && (Flags & KEYC11)) AddResult = 2; // We treat bridge casts as objective-C keywords so we can warn on them // in non-arc mode. else if (LangOpts.ObjC2 && (Flags & KEYARC)) AddResult = 2; else if (LangOpts.CPlusPlus && (Flags & KEYCXX11)) AddResult = 3; // Don't add this keyword under MSVCCompat. if (LangOpts.MSVCCompat && (Flags & KEYNOMS)) return; // Don't add this keyword if disabled in this language. if (AddResult == 0) return; IdentifierInfo &Info = Table.get(Keyword, AddResult == 3 ? tok::identifier : TokenCode); Info.setIsExtensionToken(AddResult == 1); Info.setIsCXX11CompatKeyword(AddResult == 3); } /// AddCXXOperatorKeyword - Register a C++ operator keyword alternative /// representations. static void AddCXXOperatorKeyword(StringRef Keyword, tok::TokenKind TokenCode, IdentifierTable &Table) { IdentifierInfo &Info = Table.get(Keyword, TokenCode); Info.setIsCPlusPlusOperatorKeyword(); } /// AddObjCKeyword - Register an Objective-C \@@keyword like "class" "selector" /// or "property". static void AddObjCKeyword(StringRef Name, tok::ObjCKeywordKind ObjCID, IdentifierTable &Table) { Table.get(Name).setObjCKeywordID(ObjCID); } /// AddKeywords - Add all keywords to the symbol table. /// void IdentifierTable::AddKeywords(const LangOptions &LangOpts) { // Add keywords and tokens for the current language. #define KEYWORD(NAME, FLAGS) \ AddKeyword(StringRef(#NAME), tok::kw_ ## NAME, \ FLAGS, LangOpts, *this); #define ALIAS(NAME, TOK, FLAGS) \ AddKeyword(StringRef(NAME), tok::kw_ ## TOK, \ FLAGS, LangOpts, *this); #define CXX_KEYWORD_OPERATOR(NAME, ALIAS) \ if (LangOpts.CXXOperatorNames) \ AddCXXOperatorKeyword(StringRef(#NAME), tok::ALIAS, *this); #define OBJC1_AT_KEYWORD(NAME) \ if (LangOpts.ObjC1) \ AddObjCKeyword(StringRef(#NAME), tok::objc_##NAME, *this); #define OBJC2_AT_KEYWORD(NAME) \ if (LangOpts.ObjC2) \ AddObjCKeyword(StringRef(#NAME), tok::objc_##NAME, *this); #define TESTING_KEYWORD(NAME, FLAGS) #include "clang/Basic/TokenKinds.def" if (LangOpts.ParseUnknownAnytype) AddKeyword("__unknown_anytype", tok::kw___unknown_anytype, KEYALL, LangOpts, *this); } tok::PPKeywordKind IdentifierInfo::getPPKeywordID() const { // We use a perfect hash function here involving the length of the keyword, // the first and third character. For preprocessor ID's there are no // collisions (if there were, the switch below would complain about duplicate // case values). Note that this depends on 'if' being null terminated. #define HASH(LEN, FIRST, THIRD) \ (LEN << 5) + (((FIRST-'a') + (THIRD-'a')) & 31) #define CASE(LEN, FIRST, THIRD, NAME) \ case HASH(LEN, FIRST, THIRD): \ return memcmp(Name, #NAME, LEN) ? tok::pp_not_keyword : tok::pp_ ## NAME unsigned Len = getLength(); if (Len < 2) return tok::pp_not_keyword; const char *Name = getNameStart(); switch (HASH(Len, Name[0], Name[2])) { default: return tok::pp_not_keyword; CASE( 2, 'i', '\0', if); CASE( 4, 'e', 'i', elif); CASE( 4, 'e', 's', else); CASE( 4, 'l', 'n', line); CASE( 4, 's', 'c', sccs); CASE( 5, 'e', 'd', endif); CASE( 5, 'e', 'r', error); CASE( 5, 'i', 'e', ident); CASE( 5, 'i', 'd', ifdef); CASE( 5, 'u', 'd', undef); CASE( 6, 'a', 's', assert); CASE( 6, 'd', 'f', define); CASE( 6, 'i', 'n', ifndef); CASE( 6, 'i', 'p', import); CASE( 6, 'p', 'a', pragma); CASE( 7, 'd', 'f', defined); CASE( 7, 'i', 'c', include); CASE( 7, 'w', 'r', warning); CASE( 8, 'u', 'a', unassert); CASE(12, 'i', 'c', include_next); CASE(14, '_', 'p', __public_macro); CASE(15, '_', 'p', __private_macro); CASE(16, '_', 'i', __include_macros); #undef CASE #undef HASH } } //===----------------------------------------------------------------------===// // Stats Implementation //===----------------------------------------------------------------------===// /// PrintStats - Print statistics about how well the identifier table is doing /// at hashing identifiers. void IdentifierTable::PrintStats() const { unsigned NumBuckets = HashTable.getNumBuckets(); unsigned NumIdentifiers = HashTable.getNumItems(); unsigned NumEmptyBuckets = NumBuckets-NumIdentifiers; unsigned AverageIdentifierSize = 0; unsigned MaxIdentifierLength = 0; // TODO: Figure out maximum times an identifier had to probe for -stats. for (llvm::StringMap::const_iterator I = HashTable.begin(), E = HashTable.end(); I != E; ++I) { unsigned IdLen = I->getKeyLength(); AverageIdentifierSize += IdLen; if (MaxIdentifierLength < IdLen) MaxIdentifierLength = IdLen; } fprintf(stderr, "\n*** Identifier Table Stats:\n"); fprintf(stderr, "# Identifiers: %d\n", NumIdentifiers); fprintf(stderr, "# Empty Buckets: %d\n", NumEmptyBuckets); fprintf(stderr, "Hash density (#identifiers per bucket): %f\n", NumIdentifiers/(double)NumBuckets); fprintf(stderr, "Ave identifier length: %f\n", (AverageIdentifierSize/(double)NumIdentifiers)); fprintf(stderr, "Max identifier length: %d\n", MaxIdentifierLength); // Compute statistics about the memory allocated for identifiers. HashTable.getAllocator().PrintStats(); } //===----------------------------------------------------------------------===// // SelectorTable Implementation //===----------------------------------------------------------------------===// unsigned llvm::DenseMapInfo::getHashValue(clang::Selector S) { return DenseMapInfo::getHashValue(S.getAsOpaquePtr()); } namespace clang { /// MultiKeywordSelector - One of these variable length records is kept for each /// selector containing more than one keyword. We use a folding set /// to unique aggregate names (keyword selectors in ObjC parlance). Access to /// this class is provided strictly through Selector. class MultiKeywordSelector : public DeclarationNameExtra, public llvm::FoldingSetNode { MultiKeywordSelector(unsigned nKeys) { ExtraKindOrNumArgs = NUM_EXTRA_KINDS + nKeys; } public: // Constructor for keyword selectors. MultiKeywordSelector(unsigned nKeys, IdentifierInfo **IIV) { assert((nKeys > 1) && "not a multi-keyword selector"); ExtraKindOrNumArgs = NUM_EXTRA_KINDS + nKeys; // Fill in the trailing keyword array. IdentifierInfo **KeyInfo = reinterpret_cast(this+1); for (unsigned i = 0; i != nKeys; ++i) KeyInfo[i] = IIV[i]; } // getName - Derive the full selector name and return it. std::string getName() const; unsigned getNumArgs() const { return ExtraKindOrNumArgs - NUM_EXTRA_KINDS; } typedef IdentifierInfo *const *keyword_iterator; keyword_iterator keyword_begin() const { return reinterpret_cast(this+1); } keyword_iterator keyword_end() const { return keyword_begin()+getNumArgs(); } IdentifierInfo *getIdentifierInfoForSlot(unsigned i) const { assert(i < getNumArgs() && "getIdentifierInfoForSlot(): illegal index"); return keyword_begin()[i]; } static void Profile(llvm::FoldingSetNodeID &ID, keyword_iterator ArgTys, unsigned NumArgs) { ID.AddInteger(NumArgs); for (unsigned i = 0; i != NumArgs; ++i) ID.AddPointer(ArgTys[i]); } void Profile(llvm::FoldingSetNodeID &ID) { Profile(ID, keyword_begin(), getNumArgs()); } }; } // end namespace clang. unsigned Selector::getNumArgs() const { unsigned IIF = getIdentifierInfoFlag(); if (IIF <= ZeroArg) return 0; if (IIF == OneArg) return 1; // We point to a MultiKeywordSelector. MultiKeywordSelector *SI = getMultiKeywordSelector(); return SI->getNumArgs(); } IdentifierInfo *Selector::getIdentifierInfoForSlot(unsigned argIndex) const { if (getIdentifierInfoFlag() < MultiArg) { assert(argIndex == 0 && "illegal keyword index"); return getAsIdentifierInfo(); } // We point to a MultiKeywordSelector. MultiKeywordSelector *SI = getMultiKeywordSelector(); return SI->getIdentifierInfoForSlot(argIndex); } StringRef Selector::getNameForSlot(unsigned int argIndex) const { IdentifierInfo *II = getIdentifierInfoForSlot(argIndex); return II? II->getName() : StringRef(); } std::string MultiKeywordSelector::getName() const { SmallString<256> Str; llvm::raw_svector_ostream OS(Str); for (keyword_iterator I = keyword_begin(), E = keyword_end(); I != E; ++I) { if (*I) OS << (*I)->getName(); OS << ':'; } return OS.str(); } std::string Selector::getAsString() const { if (InfoPtr == 0) return ""; if (getIdentifierInfoFlag() < MultiArg) { IdentifierInfo *II = getAsIdentifierInfo(); // If the number of arguments is 0 then II is guaranteed to not be null. if (getNumArgs() == 0) return II->getName(); if (!II) return ":"; return II->getName().str() + ":"; } // We have a multiple keyword selector. return getMultiKeywordSelector()->getName(); } void Selector::print(llvm::raw_ostream &OS) const { OS << getAsString(); } /// Interpreting the given string using the normal CamelCase /// conventions, determine whether the given string starts with the /// given "word", which is assumed to end in a lowercase letter. static bool startsWithWord(StringRef name, StringRef word) { if (name.size() < word.size()) return false; return ((name.size() == word.size() || !isLowercase(name[word.size()])) && name.startswith(word)); } ObjCMethodFamily Selector::getMethodFamilyImpl(Selector sel) { IdentifierInfo *first = sel.getIdentifierInfoForSlot(0); if (!first) return OMF_None; StringRef name = first->getName(); if (sel.isUnarySelector()) { if (name == "autorelease") return OMF_autorelease; if (name == "dealloc") return OMF_dealloc; if (name == "finalize") return OMF_finalize; if (name == "release") return OMF_release; if (name == "retain") return OMF_retain; if (name == "retainCount") return OMF_retainCount; if (name == "self") return OMF_self; } if (name == "performSelector") return OMF_performSelector; // The other method families may begin with a prefix of underscores. while (!name.empty() && name.front() == '_') name = name.substr(1); if (name.empty()) return OMF_None; switch (name.front()) { case 'a': if (startsWithWord(name, "alloc")) return OMF_alloc; break; case 'c': if (startsWithWord(name, "copy")) return OMF_copy; break; case 'i': if (startsWithWord(name, "init")) return OMF_init; break; case 'm': if (startsWithWord(name, "mutableCopy")) return OMF_mutableCopy; break; case 'n': if (startsWithWord(name, "new")) return OMF_new; break; default: break; } return OMF_None; } ObjCInstanceTypeFamily Selector::getInstTypeMethodFamily(Selector sel) { IdentifierInfo *first = sel.getIdentifierInfoForSlot(0); if (!first) return OIT_None; StringRef name = first->getName(); if (name.empty()) return OIT_None; switch (name.front()) { case 'a': if (startsWithWord(name, "array")) return OIT_Array; break; case 'd': if (startsWithWord(name, "default")) return OIT_ReturnsSelf; if (startsWithWord(name, "dictionary")) return OIT_Dictionary; break; case 's': if (startsWithWord(name, "shared")) return OIT_ReturnsSelf; if (startsWithWord(name, "standard")) return OIT_Singleton; case 'i': if (startsWithWord(name, "init")) return OIT_Init; default: break; } return OIT_None; } namespace { struct SelectorTableImpl { llvm::FoldingSet Table; llvm::BumpPtrAllocator Allocator; }; } // end anonymous namespace. static SelectorTableImpl &getSelectorTableImpl(void *P) { return *static_cast(P); } SmallString<64> SelectorTable::constructSetterName(StringRef Name) { SmallString<64> SetterName("set"); SetterName += Name; SetterName[3] = toUppercase(SetterName[3]); return SetterName; } Selector SelectorTable::constructSetterSelector(IdentifierTable &Idents, SelectorTable &SelTable, const IdentifierInfo *Name) { IdentifierInfo *SetterName = &Idents.get(constructSetterName(Name->getName())); return SelTable.getUnarySelector(SetterName); } size_t SelectorTable::getTotalMemory() const { SelectorTableImpl &SelTabImpl = getSelectorTableImpl(Impl); return SelTabImpl.Allocator.getTotalMemory(); } Selector SelectorTable::getSelector(unsigned nKeys, IdentifierInfo **IIV) { if (nKeys < 2) return Selector(IIV[0], nKeys); SelectorTableImpl &SelTabImpl = getSelectorTableImpl(Impl); // Unique selector, to guarantee there is one per name. llvm::FoldingSetNodeID ID; MultiKeywordSelector::Profile(ID, IIV, nKeys); void *InsertPos = 0; if (MultiKeywordSelector *SI = SelTabImpl.Table.FindNodeOrInsertPos(ID, InsertPos)) return Selector(SI); // MultiKeywordSelector objects are not allocated with new because they have a // variable size array (for parameter types) at the end of them. unsigned Size = sizeof(MultiKeywordSelector) + nKeys*sizeof(IdentifierInfo *); MultiKeywordSelector *SI = (MultiKeywordSelector*)SelTabImpl.Allocator.Allocate(Size, llvm::alignOf()); new (SI) MultiKeywordSelector(nKeys, IIV); SelTabImpl.Table.InsertNode(SI, InsertPos); return Selector(SI); } SelectorTable::SelectorTable() { Impl = new SelectorTableImpl(); } SelectorTable::~SelectorTable() { delete &getSelectorTableImpl(Impl); } const char *clang::getOperatorSpelling(OverloadedOperatorKind Operator) { switch (Operator) { case OO_None: case NUM_OVERLOADED_OPERATORS: return 0; #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \ case OO_##Name: return Spelling; #include "clang/Basic/OperatorKinds.def" } llvm_unreachable("Invalid OverloadedOperatorKind!"); } @