1//===- IdentifierTable.h - Hash table for identifier lookup -----*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9/// \file
10/// Defines the clang::IdentifierInfo, clang::IdentifierTable, and
11/// clang::Selector interfaces.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_CLANG_BASIC_IDENTIFIERTABLE_H
16#define LLVM_CLANG_BASIC_IDENTIFIERTABLE_H
17
18#include "clang/Basic/LLVM.h"
19#include "clang/Basic/TokenKinds.h"
20#include "llvm/ADT/DenseMapInfo.h"
21#include "llvm/ADT/SmallString.h"
22#include "llvm/ADT/StringMap.h"
23#include "llvm/ADT/StringRef.h"
24#include "llvm/Support/Allocator.h"
25#include "llvm/Support/PointerLikeTypeTraits.h"
26#include "llvm/Support/type_traits.h"
27#include <cassert>
28#include <cstddef>
29#include <cstdint>
30#include <cstring>
31#include <string>
32#include <utility>
33
34namespace clang {
35
36class DeclarationName;
37class DeclarationNameTable;
38class IdentifierInfo;
39class LangOptions;
40class MultiKeywordSelector;
41class SourceLocation;
42
43enum class ReservedIdentifierStatus {
44 NotReserved = 0,
45 StartsWithUnderscoreAtGlobalScope,
46 StartsWithDoubleUnderscore,
47 StartsWithUnderscoreFollowedByCapitalLetter,
48 ContainsDoubleUnderscore,
49};
50
51/// A simple pair of identifier info and location.
52using IdentifierLocPair = std::pair<IdentifierInfo *, SourceLocation>;
53
54/// IdentifierInfo and other related classes are aligned to
55/// 8 bytes so that DeclarationName can use the lower 3 bits
56/// of a pointer to one of these classes.
57enum { IdentifierInfoAlignment = 8 };
58
59static constexpr int ObjCOrBuiltinIDBits = 15;
60
61/// One of these records is kept for each identifier that
62/// is lexed. This contains information about whether the token was \#define'd,
63/// is a language keyword, or if it is a front-end token of some sort (e.g. a
64/// variable or function name). The preprocessor keeps this information in a
65/// set, and all tok::identifier tokens have a pointer to one of these.
66/// It is aligned to 8 bytes because DeclarationName needs the lower 3 bits.
67class alignas(IdentifierInfoAlignment) IdentifierInfo {
68 friend class IdentifierTable;
69
70 // Front-end token ID or tok::identifier.
71 unsigned TokenID : 9;
72
73 // ObjC keyword ('protocol' in '@protocol') or builtin (__builtin_inf).
74 // First NUM_OBJC_KEYWORDS values are for Objective-C,
75 // the remaining values are for builtins.
76 unsigned ObjCOrBuiltinID : ObjCOrBuiltinIDBits;
77
78 // True if there is a #define for this.
79 unsigned HasMacro : 1;
80
81 // True if there was a #define for this.
82 unsigned HadMacro : 1;
83
84 // True if the identifier is a language extension.
85 unsigned IsExtension : 1;
86
87 // True if the identifier is a keyword in a newer or proposed Standard.
88 unsigned IsFutureCompatKeyword : 1;
89
90 // True if the identifier is poisoned.
91 unsigned IsPoisoned : 1;
92
93 // True if the identifier is a C++ operator keyword.
94 unsigned IsCPPOperatorKeyword : 1;
95
96 // Internal bit set by the member function RecomputeNeedsHandleIdentifier.
97 // See comment about RecomputeNeedsHandleIdentifier for more info.
98 unsigned NeedsHandleIdentifier : 1;
99
100 // True if the identifier was loaded (at least partially) from an AST file.
101 unsigned IsFromAST : 1;
102
103 // True if the identifier has changed from the definition
104 // loaded from an AST file.
105 unsigned ChangedAfterLoad : 1;
106
107 // True if the identifier's frontend information has changed from the
108 // definition loaded from an AST file.
109 unsigned FEChangedAfterLoad : 1;
110
111 // True if revertTokenIDToIdentifier was called.
112 unsigned RevertedTokenID : 1;
113
114 // True if there may be additional information about
115 // this identifier stored externally.
116 unsigned OutOfDate : 1;
117
118 // True if this is the 'import' contextual keyword.
119 unsigned IsModulesImport : 1;
120
121 // True if this is a mangled OpenMP variant name.
122 unsigned IsMangledOpenMPVariantName : 1;
123
124 // 28 bits left in a 64-bit word.
125
126 // Managed by the language front-end.
127 void *FETokenInfo = nullptr;
128
129 llvm::StringMapEntry<IdentifierInfo *> *Entry = nullptr;
130
131 IdentifierInfo()
132 : TokenID(tok::identifier), ObjCOrBuiltinID(0), HasMacro(false),
133 HadMacro(false), IsExtension(false), IsFutureCompatKeyword(false),
134 IsPoisoned(false), IsCPPOperatorKeyword(false),
135 NeedsHandleIdentifier(false), IsFromAST(false), ChangedAfterLoad(false),
136 FEChangedAfterLoad(false), RevertedTokenID(false), OutOfDate(false),
137 IsModulesImport(false), IsMangledOpenMPVariantName(false) {}
138
139public:
140 IdentifierInfo(const IdentifierInfo &) = delete;
141 IdentifierInfo &operator=(const IdentifierInfo &) = delete;
142 IdentifierInfo(IdentifierInfo &&) = delete;
143 IdentifierInfo &operator=(IdentifierInfo &&) = delete;
144
145 /// Return true if this is the identifier for the specified string.
146 ///
147 /// This is intended to be used for string literals only: II->isStr("foo").
148 template <std::size_t StrLen>
149 bool isStr(const char (&Str)[StrLen]) const {
150 return getLength() == StrLen-1 &&
151 memcmp(getNameStart(), Str, StrLen-1) == 0;
152 }
153
154 /// Return true if this is the identifier for the specified StringRef.
155 bool isStr(llvm::StringRef Str) const {
156 llvm::StringRef ThisStr(getNameStart(), getLength());
157 return ThisStr == Str;
158 }
159
160 /// Return the beginning of the actual null-terminated string for this
161 /// identifier.
162 const char *getNameStart() const { return Entry->getKeyData(); }
163
164 /// Efficiently return the length of this identifier info.
165 unsigned getLength() const { return Entry->getKeyLength(); }
166
167 /// Return the actual identifier string.
168 StringRef getName() const {
169 return StringRef(getNameStart(), getLength());
170 }
171
172 /// Return true if this identifier is \#defined to some other value.
173 /// \note The current definition may be in a module and not currently visible.
174 bool hasMacroDefinition() const {
175 return HasMacro;
176 }
177 void setHasMacroDefinition(bool Val) {
178 if (HasMacro == Val) return;
179
180 HasMacro = Val;
181 if (Val) {
182 NeedsHandleIdentifier = true;
183 HadMacro = true;
184 } else {
185 RecomputeNeedsHandleIdentifier();
186 }
187 }
188 /// Returns true if this identifier was \#defined to some value at any
189 /// moment. In this case there should be an entry for the identifier in the
190 /// macro history table in Preprocessor.
191 bool hadMacroDefinition() const {
192 return HadMacro;
193 }
194
195 /// If this is a source-language token (e.g. 'for'), this API
196 /// can be used to cause the lexer to map identifiers to source-language
197 /// tokens.
198 tok::TokenKind getTokenID() const { return (tok::TokenKind)TokenID; }
199
200 /// True if revertTokenIDToIdentifier() was called.
201 bool hasRevertedTokenIDToIdentifier() const { return RevertedTokenID; }
202
203 /// Revert TokenID to tok::identifier; used for GNU libstdc++ 4.2
204 /// compatibility.
205 ///
206 /// TokenID is normally read-only but there are 2 instances where we revert it
207 /// to tok::identifier for libstdc++ 4.2. Keep track of when this happens
208 /// using this method so we can inform serialization about it.
209 void revertTokenIDToIdentifier() {
210 assert(TokenID != tok::identifier && "Already at tok::identifier");
211 TokenID = tok::identifier;
212 RevertedTokenID = true;
213 }
214 void revertIdentifierToTokenID(tok::TokenKind TK) {
215 assert(TokenID == tok::identifier && "Should be at tok::identifier");
216 TokenID = TK;
217 RevertedTokenID = false;
218 }
219
220 /// Return the preprocessor keyword ID for this identifier.
221 ///
222 /// For example, "define" will return tok::pp_define.
223 tok::PPKeywordKind getPPKeywordID() const;
224
225 /// Return the Objective-C keyword ID for the this identifier.
226 ///
227 /// For example, 'class' will return tok::objc_class if ObjC is enabled.
228 tok::ObjCKeywordKind getObjCKeywordID() const {
229 if (ObjCOrBuiltinID < tok::NUM_OBJC_KEYWORDS)
230 return tok::ObjCKeywordKind(ObjCOrBuiltinID);
231 else
232 return tok::objc_not_keyword;
233 }
234 void setObjCKeywordID(tok::ObjCKeywordKind ID) { ObjCOrBuiltinID = ID; }
235
236 /// Return a value indicating whether this is a builtin function.
237 ///
238 /// 0 is not-built-in. 1+ are specific builtin functions.
239 unsigned getBuiltinID() const {
240 if (ObjCOrBuiltinID >= tok::NUM_OBJC_KEYWORDS)
241 return ObjCOrBuiltinID - tok::NUM_OBJC_KEYWORDS;
242 else
243 return 0;
244 }
245 void setBuiltinID(unsigned ID) {
246 ObjCOrBuiltinID = ID + tok::NUM_OBJC_KEYWORDS;
247 assert(ObjCOrBuiltinID - unsigned(tok::NUM_OBJC_KEYWORDS) == ID
248 && "ID too large for field!");
249 }
250
251 unsigned getObjCOrBuiltinID() const { return ObjCOrBuiltinID; }
252 void setObjCOrBuiltinID(unsigned ID) { ObjCOrBuiltinID = ID; }
253
254 /// get/setExtension - Initialize information about whether or not this
255 /// language token is an extension. This controls extension warnings, and is
256 /// only valid if a custom token ID is set.
257 bool isExtensionToken() const { return IsExtension; }
258 void setIsExtensionToken(bool Val) {
259 IsExtension = Val;
260 if (Val)
261 NeedsHandleIdentifier = true;
262 else
263 RecomputeNeedsHandleIdentifier();
264 }
265
266 /// is/setIsFutureCompatKeyword - Initialize information about whether or not
267 /// this language token is a keyword in a newer or proposed Standard. This
268 /// controls compatibility warnings, and is only true when not parsing the
269 /// corresponding Standard. Once a compatibility problem has been diagnosed
270 /// with this keyword, the flag will be cleared.
271 bool isFutureCompatKeyword() const { return IsFutureCompatKeyword; }
272 void setIsFutureCompatKeyword(bool Val) {
273 IsFutureCompatKeyword = Val;
274 if (Val)
275 NeedsHandleIdentifier = true;
276 else
277 RecomputeNeedsHandleIdentifier();
278 }
279
280 /// setIsPoisoned - Mark this identifier as poisoned. After poisoning, the
281 /// Preprocessor will emit an error every time this token is used.
282 void setIsPoisoned(bool Value = true) {
283 IsPoisoned = Value;
284 if (Value)
285 NeedsHandleIdentifier = true;
286 else
287 RecomputeNeedsHandleIdentifier();
288 }
289
290 /// Return true if this token has been poisoned.
291 bool isPoisoned() const { return IsPoisoned; }
292
293 /// isCPlusPlusOperatorKeyword/setIsCPlusPlusOperatorKeyword controls whether
294 /// this identifier is a C++ alternate representation of an operator.
295 void setIsCPlusPlusOperatorKeyword(bool Val = true) {
296 IsCPPOperatorKeyword = Val;
297 }
298 bool isCPlusPlusOperatorKeyword() const { return IsCPPOperatorKeyword; }
299
300 /// Return true if this token is a keyword in the specified language.
301 bool isKeyword(const LangOptions &LangOpts) const;
302
303 /// Return true if this token is a C++ keyword in the specified
304 /// language.
305 bool isCPlusPlusKeyword(const LangOptions &LangOpts) const;
306
307 /// Get and set FETokenInfo. The language front-end is allowed to associate
308 /// arbitrary metadata with this token.
309 void *getFETokenInfo() const { return FETokenInfo; }
310 void setFETokenInfo(void *T) { FETokenInfo = T; }
311
312 /// Return true if the Preprocessor::HandleIdentifier must be called
313 /// on a token of this identifier.
314 ///
315 /// If this returns false, we know that HandleIdentifier will not affect
316 /// the token.
317 bool isHandleIdentifierCase() const { return NeedsHandleIdentifier; }
318
319 /// Return true if the identifier in its current state was loaded
320 /// from an AST file.
321 bool isFromAST() const { return IsFromAST; }
322
323 void setIsFromAST() { IsFromAST = true; }
324
325 /// Determine whether this identifier has changed since it was loaded
326 /// from an AST file.
327 bool hasChangedSinceDeserialization() const {
328 return ChangedAfterLoad;
329 }
330
331 /// Note that this identifier has changed since it was loaded from
332 /// an AST file.
333 void setChangedSinceDeserialization() {
334 ChangedAfterLoad = true;
335 }
336
337 /// Determine whether the frontend token information for this
338 /// identifier has changed since it was loaded from an AST file.
339 bool hasFETokenInfoChangedSinceDeserialization() const {
340 return FEChangedAfterLoad;
341 }
342
343 /// Note that the frontend token information for this identifier has
344 /// changed since it was loaded from an AST file.
345 void setFETokenInfoChangedSinceDeserialization() {
346 FEChangedAfterLoad = true;
347 }
348
349 /// Determine whether the information for this identifier is out of
350 /// date with respect to the external source.
351 bool isOutOfDate() const { return OutOfDate; }
352
353 /// Set whether the information for this identifier is out of
354 /// date with respect to the external source.
355 void setOutOfDate(bool OOD) {
356 OutOfDate = OOD;
357 if (OOD)
358 NeedsHandleIdentifier = true;
359 else
360 RecomputeNeedsHandleIdentifier();
361 }
362
363 /// Determine whether this is the contextual keyword \c import.
364 bool isModulesImport() const { return IsModulesImport; }
365
366 /// Set whether this identifier is the contextual keyword \c import.
367 void setModulesImport(bool I) {
368 IsModulesImport = I;
369 if (I)
370 NeedsHandleIdentifier = true;
371 else
372 RecomputeNeedsHandleIdentifier();
373 }
374
375 /// Determine whether this is the mangled name of an OpenMP variant.
376 bool isMangledOpenMPVariantName() const { return IsMangledOpenMPVariantName; }
377
378 /// Set whether this is the mangled name of an OpenMP variant.
379 void setMangledOpenMPVariantName(bool I) { IsMangledOpenMPVariantName = I; }
380
381 /// Return true if this identifier is an editor placeholder.
382 ///
383 /// Editor placeholders are produced by the code-completion engine and are
384 /// represented as characters between '<#' and '#>' in the source code. An
385 /// example of auto-completed call with a placeholder parameter is shown
386 /// below:
387 /// \code
388 /// function(<#int x#>);
389 /// \endcode
390 bool isEditorPlaceholder() const {
391 return getName().startswith("<#") && getName().endswith("#>");
392 }
393
394 /// Determine whether \p this is a name reserved for the implementation (C99
395 /// 7.1.3, C++ [lib.global.names]).
396 ReservedIdentifierStatus isReserved(const LangOptions &LangOpts) const;
397
398 /// Provide less than operator for lexicographical sorting.
399 bool operator<(const IdentifierInfo &RHS) const {
400 return getName() < RHS.getName();
401 }
402
403private:
404 /// The Preprocessor::HandleIdentifier does several special (but rare)
405 /// things to identifiers of various sorts. For example, it changes the
406 /// \c for keyword token from tok::identifier to tok::for.
407 ///
408 /// This method is very tied to the definition of HandleIdentifier. Any
409 /// change to it should be reflected here.
410 void RecomputeNeedsHandleIdentifier() {
411 NeedsHandleIdentifier = isPoisoned() || hasMacroDefinition() ||
412 isExtensionToken() || isFutureCompatKeyword() ||
413 isOutOfDate() || isModulesImport();
414 }
415};
416
417/// An RAII object for [un]poisoning an identifier within a scope.
418///
419/// \p II is allowed to be null, in which case objects of this type have
420/// no effect.
421class PoisonIdentifierRAIIObject {
422 IdentifierInfo *const II;
423 const bool OldValue;
424
425public:
426 PoisonIdentifierRAIIObject(IdentifierInfo *II, bool NewValue)
427 : II(II), OldValue(II ? II->isPoisoned() : false) {
428 if(II)
429 II->setIsPoisoned(NewValue);
430 }
431
432 ~PoisonIdentifierRAIIObject() {
433 if(II)
434 II->setIsPoisoned(OldValue);
435 }
436};
437
438/// An iterator that walks over all of the known identifiers
439/// in the lookup table.
440///
441/// Since this iterator uses an abstract interface via virtual
442/// functions, it uses an object-oriented interface rather than the
443/// more standard C++ STL iterator interface. In this OO-style
444/// iteration, the single function \c Next() provides dereference,
445/// advance, and end-of-sequence checking in a single
446/// operation. Subclasses of this iterator type will provide the
447/// actual functionality.
448class IdentifierIterator {
449protected:
450 IdentifierIterator() = default;
451
452public:
453 IdentifierIterator(const IdentifierIterator &) = delete;
454 IdentifierIterator &operator=(const IdentifierIterator &) = delete;
455
456 virtual ~IdentifierIterator();
457
458 /// Retrieve the next string in the identifier table and
459 /// advances the iterator for the following string.
460 ///
461 /// \returns The next string in the identifier table. If there is
462 /// no such string, returns an empty \c StringRef.
463 virtual StringRef Next() = 0;
464};
465
466/// Provides lookups to, and iteration over, IdentiferInfo objects.
467class IdentifierInfoLookup {
468public:
469 virtual ~IdentifierInfoLookup();
470
471 /// Return the IdentifierInfo for the specified named identifier.
472 ///
473 /// Unlike the version in IdentifierTable, this returns a pointer instead
474 /// of a reference. If the pointer is null then the IdentifierInfo cannot
475 /// be found.
476 virtual IdentifierInfo* get(StringRef Name) = 0;
477
478 /// Retrieve an iterator into the set of all identifiers
479 /// known to this identifier lookup source.
480 ///
481 /// This routine provides access to all of the identifiers known to
482 /// the identifier lookup, allowing access to the contents of the
483 /// identifiers without introducing the overhead of constructing
484 /// IdentifierInfo objects for each.
485 ///
486 /// \returns A new iterator into the set of known identifiers. The
487 /// caller is responsible for deleting this iterator.
488 virtual IdentifierIterator *getIdentifiers();
489};
490
491/// Implements an efficient mapping from strings to IdentifierInfo nodes.
492///
493/// This has no other purpose, but this is an extremely performance-critical
494/// piece of the code, as each occurrence of every identifier goes through
495/// here when lexed.
496class IdentifierTable {
497 // Shark shows that using MallocAllocator is *much* slower than using this
498 // BumpPtrAllocator!
499 using HashTableTy = llvm::StringMap<IdentifierInfo *, llvm::BumpPtrAllocator>;
500 HashTableTy HashTable;
501
502 IdentifierInfoLookup* ExternalLookup;
503
504public:
505 /// Create the identifier table.
506 explicit IdentifierTable(IdentifierInfoLookup *ExternalLookup = nullptr);
507
508 /// Create the identifier table, populating it with info about the
509 /// language keywords for the language specified by \p LangOpts.
510 explicit IdentifierTable(const LangOptions &LangOpts,
511 IdentifierInfoLookup *ExternalLookup = nullptr);
512
513 /// Set the external identifier lookup mechanism.
514 void setExternalIdentifierLookup(IdentifierInfoLookup *IILookup) {
515 ExternalLookup = IILookup;
516 }
517
518 /// Retrieve the external identifier lookup object, if any.
519 IdentifierInfoLookup *getExternalIdentifierLookup() const {
520 return ExternalLookup;
521 }
522
523 llvm::BumpPtrAllocator& getAllocator() {
524 return HashTable.getAllocator();
525 }
526
527 /// Return the identifier token info for the specified named
528 /// identifier.
529 IdentifierInfo &get(StringRef Name) {
530 auto &Entry = *HashTable.insert(std::make_pair(Name, nullptr)).first;
531
532 IdentifierInfo *&II = Entry.second;
533 if (II) return *II;
534
535 // No entry; if we have an external lookup, look there first.
536 if (ExternalLookup) {
537 II = ExternalLookup->get(Name);
538 if (II)
539 return *II;
540 }
541
542 // Lookups failed, make a new IdentifierInfo.
543 void *Mem = getAllocator().Allocate<IdentifierInfo>();
544 II = new (Mem) IdentifierInfo();
545
546 // Make sure getName() knows how to find the IdentifierInfo
547 // contents.
548 II->Entry = &Entry;
549
550 return *II;
551 }
552
553 IdentifierInfo &get(StringRef Name, tok::TokenKind TokenCode) {
554 IdentifierInfo &II = get(Name);
555 II.TokenID = TokenCode;
556 assert(II.TokenID == (unsigned) TokenCode && "TokenCode too large");
557 return II;
558 }
559
560 /// Gets an IdentifierInfo for the given name without consulting
561 /// external sources.
562 ///
563 /// This is a version of get() meant for external sources that want to
564 /// introduce or modify an identifier. If they called get(), they would
565 /// likely end up in a recursion.
566 IdentifierInfo &getOwn(StringRef Name) {
567 auto &Entry = *HashTable.insert(std::make_pair(Name, nullptr)).first;
568
569 IdentifierInfo *&II = Entry.second;
570 if (II)
571 return *II;
572
573 // Lookups failed, make a new IdentifierInfo.
574 void *Mem = getAllocator().Allocate<IdentifierInfo>();
575 II = new (Mem) IdentifierInfo();
576
577 // Make sure getName() knows how to find the IdentifierInfo
578 // contents.
579 II->Entry = &Entry;
580
581 // If this is the 'import' contextual keyword, mark it as such.
582 if (Name.equals("import"))
583 II->setModulesImport(true);
584
585 return *II;
586 }
587
588 using iterator = HashTableTy::const_iterator;
589 using const_iterator = HashTableTy::const_iterator;
590
591 iterator begin() const { return HashTable.begin(); }
592 iterator end() const { return HashTable.end(); }
593 unsigned size() const { return HashTable.size(); }
594
595 iterator find(StringRef Name) const { return HashTable.find(Name); }
596
597 /// Print some statistics to stderr that indicate how well the
598 /// hashing is doing.
599 void PrintStats() const;
600
601 /// Populate the identifier table with info about the language keywords
602 /// for the language specified by \p LangOpts.
603 void AddKeywords(const LangOptions &LangOpts);
604};
605
606/// A family of Objective-C methods.
607///
608/// These families have no inherent meaning in the language, but are
609/// nonetheless central enough in the existing implementations to
610/// merit direct AST support. While, in theory, arbitrary methods can
611/// be considered to form families, we focus here on the methods
612/// involving allocation and retain-count management, as these are the
613/// most "core" and the most likely to be useful to diverse clients
614/// without extra information.
615///
616/// Both selectors and actual method declarations may be classified
617/// into families. Method families may impose additional restrictions
618/// beyond their selector name; for example, a method called '_init'
619/// that returns void is not considered to be in the 'init' family
620/// (but would be if it returned 'id'). It is also possible to
621/// explicitly change or remove a method's family. Therefore the
622/// method's family should be considered the single source of truth.
623enum ObjCMethodFamily {
624 /// No particular method family.
625 OMF_None,
626
627 // Selectors in these families may have arbitrary arity, may be
628 // written with arbitrary leading underscores, and may have
629 // additional CamelCase "words" in their first selector chunk
630 // following the family name.
631 OMF_alloc,
632 OMF_copy,
633 OMF_init,
634 OMF_mutableCopy,
635 OMF_new,
636
637 // These families are singletons consisting only of the nullary
638 // selector with the given name.
639 OMF_autorelease,
640 OMF_dealloc,
641 OMF_finalize,
642 OMF_release,
643 OMF_retain,
644 OMF_retainCount,
645 OMF_self,
646 OMF_initialize,
647
648 // performSelector families
649 OMF_performSelector
650};
651
652/// Enough bits to store any enumerator in ObjCMethodFamily or
653/// InvalidObjCMethodFamily.
654enum { ObjCMethodFamilyBitWidth = 4 };
655
656/// An invalid value of ObjCMethodFamily.
657enum { InvalidObjCMethodFamily = (1 << ObjCMethodFamilyBitWidth) - 1 };
658
659/// A family of Objective-C methods.
660///
661/// These are family of methods whose result type is initially 'id', but
662/// but are candidate for the result type to be changed to 'instancetype'.
663enum ObjCInstanceTypeFamily {
664 OIT_None,
665 OIT_Array,
666 OIT_Dictionary,
667 OIT_Singleton,
668 OIT_Init,
669 OIT_ReturnsSelf
670};
671
672enum ObjCStringFormatFamily {
673 SFF_None,
674 SFF_NSString,
675 SFF_CFString
676};
677
678/// Smart pointer class that efficiently represents Objective-C method
679/// names.
680///
681/// This class will either point to an IdentifierInfo or a
682/// MultiKeywordSelector (which is private). This enables us to optimize
683/// selectors that take no arguments and selectors that take 1 argument, which
684/// accounts for 78% of all selectors in Cocoa.h.
685class Selector {
686 friend class Diagnostic;
687 friend class SelectorTable; // only the SelectorTable can create these
688 friend class DeclarationName; // and the AST's DeclarationName.
689
690 enum IdentifierInfoFlag {
691 // Empty selector = 0. Note that these enumeration values must
692 // correspond to the enumeration values of DeclarationName::StoredNameKind
693 ZeroArg = 0x01,
694 OneArg = 0x02,
695 MultiArg = 0x07,
696 ArgFlags = 0x07
697 };
698
699 /// A pointer to the MultiKeywordSelector or IdentifierInfo. We use the low
700 /// three bits of InfoPtr to store an IdentifierInfoFlag. Note that in any
701 /// case IdentifierInfo and MultiKeywordSelector are already aligned to
702 /// 8 bytes even on 32 bits archs because of DeclarationName.
703 uintptr_t InfoPtr = 0;
704
705 Selector(IdentifierInfo *II, unsigned nArgs) {
706 InfoPtr = reinterpret_cast<uintptr_t>(II);
707 assert((InfoPtr & ArgFlags) == 0 &&"Insufficiently aligned IdentifierInfo");
708 assert(nArgs < 2 && "nArgs not equal to 0/1");
709 InfoPtr |= nArgs+1;
710 }
711
712 Selector(MultiKeywordSelector *SI) {
713 InfoPtr = reinterpret_cast<uintptr_t>(SI);
714 assert((InfoPtr & ArgFlags) == 0 &&"Insufficiently aligned IdentifierInfo");
715 InfoPtr |= MultiArg;
716 }
717
718 IdentifierInfo *getAsIdentifierInfo() const {
719 if (getIdentifierInfoFlag() < MultiArg)
720 return reinterpret_cast<IdentifierInfo *>(InfoPtr & ~ArgFlags);
721 return nullptr;
722 }
723
724 MultiKeywordSelector *getMultiKeywordSelector() const {
725 return reinterpret_cast<MultiKeywordSelector *>(InfoPtr & ~ArgFlags);
726 }
727
728 unsigned getIdentifierInfoFlag() const {
729 return InfoPtr & ArgFlags;
730 }
731
732 static ObjCMethodFamily getMethodFamilyImpl(Selector sel);
733
734 static ObjCStringFormatFamily getStringFormatFamilyImpl(Selector sel);
735
736public:
737 /// The default ctor should only be used when creating data structures that
738 /// will contain selectors.
739 Selector() = default;
740 explicit Selector(uintptr_t V) : InfoPtr(V) {}
741
742 /// operator==/!= - Indicate whether the specified selectors are identical.
743 bool operator==(Selector RHS) const {
744 return InfoPtr == RHS.InfoPtr;
745 }
746 bool operator!=(Selector RHS) const {
747 return InfoPtr != RHS.InfoPtr;
748 }
749
750 void *getAsOpaquePtr() const {
751 return reinterpret_cast<void*>(InfoPtr);
752 }
753
754 /// Determine whether this is the empty selector.
755 bool isNull() const { return InfoPtr == 0; }
756
757 // Predicates to identify the selector type.
758 bool isKeywordSelector() const {
759 return getIdentifierInfoFlag() != ZeroArg;
760 }
761
762 bool isUnarySelector() const {
763 return getIdentifierInfoFlag() == ZeroArg;
764 }
765
766 /// If this selector is the specific keyword selector described by Names.
767 bool isKeywordSelector(ArrayRef<StringRef> Names) const;
768
769 /// If this selector is the specific unary selector described by Name.
770 bool isUnarySelector(StringRef Name) const;
771
772 unsigned getNumArgs() const;
773
774 /// Retrieve the identifier at a given position in the selector.
775 ///
776 /// Note that the identifier pointer returned may be NULL. Clients that only
777 /// care about the text of the identifier string, and not the specific,
778 /// uniqued identifier pointer, should use \c getNameForSlot(), which returns
779 /// an empty string when the identifier pointer would be NULL.
780 ///
781 /// \param argIndex The index for which we want to retrieve the identifier.
782 /// This index shall be less than \c getNumArgs() unless this is a keyword
783 /// selector, in which case 0 is the only permissible value.
784 ///
785 /// \returns the uniqued identifier for this slot, or NULL if this slot has
786 /// no corresponding identifier.
787 IdentifierInfo *getIdentifierInfoForSlot(unsigned argIndex) const;
788
789 /// Retrieve the name at a given position in the selector.
790 ///
791 /// \param argIndex The index for which we want to retrieve the name.
792 /// This index shall be less than \c getNumArgs() unless this is a keyword
793 /// selector, in which case 0 is the only permissible value.
794 ///
795 /// \returns the name for this slot, which may be the empty string if no
796 /// name was supplied.
797 StringRef getNameForSlot(unsigned argIndex) const;
798
799 /// Derive the full selector name (e.g. "foo:bar:") and return
800 /// it as an std::string.
801 std::string getAsString() const;
802
803 /// Prints the full selector name (e.g. "foo:bar:").
804 void print(llvm::raw_ostream &OS) const;
805
806 void dump() const;
807
808 /// Derive the conventional family of this method.
809 ObjCMethodFamily getMethodFamily() const {
810 return getMethodFamilyImpl(*this);
811 }
812
813 ObjCStringFormatFamily getStringFormatFamily() const {
814 return getStringFormatFamilyImpl(*this);
815 }
816
817 static Selector getEmptyMarker() {
818 return Selector(uintptr_t(-1));
819 }
820
821 static Selector getTombstoneMarker() {
822 return Selector(uintptr_t(-2));
823 }
824
825 static ObjCInstanceTypeFamily getInstTypeMethodFamily(Selector sel);
826};
827
828/// This table allows us to fully hide how we implement
829/// multi-keyword caching.
830class SelectorTable {
831 // Actually a SelectorTableImpl
832 void *Impl;
833
834public:
835 SelectorTable();
836 SelectorTable(const SelectorTable &) = delete;
837 SelectorTable &operator=(const SelectorTable &) = delete;
838 ~SelectorTable();
839
840 /// Can create any sort of selector.
841 ///
842 /// \p NumArgs indicates whether this is a no argument selector "foo", a
843 /// single argument selector "foo:" or multi-argument "foo:bar:".
844 Selector getSelector(unsigned NumArgs, IdentifierInfo **IIV);
845
846 Selector getUnarySelector(IdentifierInfo *ID) {
847 return Selector(ID, 1);
848 }
849
850 Selector getNullarySelector(IdentifierInfo *ID) {
851 return Selector(ID, 0);
852 }
853
854 /// Return the total amount of memory allocated for managing selectors.
855 size_t getTotalMemory() const;
856
857 /// Return the default setter name for the given identifier.
858 ///
859 /// This is "set" + \p Name where the initial character of \p Name
860 /// has been capitalized.
861 static SmallString<64> constructSetterName(StringRef Name);
862
863 /// Return the default setter selector for the given identifier.
864 ///
865 /// This is "set" + \p Name where the initial character of \p Name
866 /// has been capitalized.
867 static Selector constructSetterSelector(IdentifierTable &Idents,
868 SelectorTable &SelTable,
869 const IdentifierInfo *Name);
870
871 /// Return the property name for the given setter selector.
872 static std::string getPropertyNameFromSetterSelector(Selector Sel);
873};
874
875namespace detail {
876
877/// DeclarationNameExtra is used as a base of various uncommon special names.
878/// This class is needed since DeclarationName has not enough space to store
879/// the kind of every possible names. Therefore the kind of common names is
880/// stored directly in DeclarationName, and the kind of uncommon names is
881/// stored in DeclarationNameExtra. It is aligned to 8 bytes because
882/// DeclarationName needs the lower 3 bits to store the kind of common names.
883/// DeclarationNameExtra is tightly coupled to DeclarationName and any change
884/// here is very likely to require changes in DeclarationName(Table).
885class alignas(IdentifierInfoAlignment) DeclarationNameExtra {
886 friend class clang::DeclarationName;
887 friend class clang::DeclarationNameTable;
888
889protected:
890 /// The kind of "extra" information stored in the DeclarationName. See
891 /// @c ExtraKindOrNumArgs for an explanation of how these enumerator values
892 /// are used. Note that DeclarationName depends on the numerical values
893 /// of the enumerators in this enum. See DeclarationName::StoredNameKind
894 /// for more info.
895 enum ExtraKind {
896 CXXDeductionGuideName,
897 CXXLiteralOperatorName,
898 CXXUsingDirective,
899 ObjCMultiArgSelector
900 };
901
902 /// ExtraKindOrNumArgs has one of the following meaning:
903 /// * The kind of an uncommon C++ special name. This DeclarationNameExtra
904 /// is in this case in fact either a CXXDeductionGuideNameExtra or
905 /// a CXXLiteralOperatorIdName.
906 ///
907 /// * It may be also name common to C++ using-directives (CXXUsingDirective),
908 ///
909 /// * Otherwise it is ObjCMultiArgSelector+NumArgs, where NumArgs is
910 /// the number of arguments in the Objective-C selector, in which
911 /// case the DeclarationNameExtra is also a MultiKeywordSelector.
912 unsigned ExtraKindOrNumArgs;
913
914 DeclarationNameExtra(ExtraKind Kind) : ExtraKindOrNumArgs(Kind) {}
915 DeclarationNameExtra(unsigned NumArgs)
916 : ExtraKindOrNumArgs(ObjCMultiArgSelector + NumArgs) {}
917
918 /// Return the corresponding ExtraKind.
919 ExtraKind getKind() const {
920 return static_cast<ExtraKind>(ExtraKindOrNumArgs >
921 (unsigned)ObjCMultiArgSelector
922 ? (unsigned)ObjCMultiArgSelector
923 : ExtraKindOrNumArgs);
924 }
925
926 /// Return the number of arguments in an ObjC selector. Only valid when this
927 /// is indeed an ObjCMultiArgSelector.
928 unsigned getNumArgs() const {
929 assert(ExtraKindOrNumArgs >= (unsigned)ObjCMultiArgSelector &&
930 "getNumArgs called but this is not an ObjC selector!");
931 return ExtraKindOrNumArgs - (unsigned)ObjCMultiArgSelector;
932 }
933};
934
935} // namespace detail
936
937} // namespace clang
938
939namespace llvm {
940
941/// Define DenseMapInfo so that Selectors can be used as keys in DenseMap and
942/// DenseSets.
943template <>
944struct DenseMapInfo<clang::Selector> {
945 static clang::Selector getEmptyKey() {
946 return clang::Selector::getEmptyMarker();
947 }
948
949 static clang::Selector getTombstoneKey() {
950 return clang::Selector::getTombstoneMarker();
951 }
952
953 static unsigned getHashValue(clang::Selector S);
954
955 static bool isEqual(clang::Selector LHS, clang::Selector RHS) {
956 return LHS == RHS;
957 }
958};
959
960template<>
961struct PointerLikeTypeTraits<clang::Selector> {
962 static const void *getAsVoidPointer(clang::Selector P) {
963 return P.getAsOpaquePtr();
964 }
965
966 static clang::Selector getFromVoidPointer(const void *P) {
967 return clang::Selector(reinterpret_cast<uintptr_t>(P));
968 }
969
970 static constexpr int NumLowBitsAvailable = 0;
971};
972
973// Provide PointerLikeTypeTraits for IdentifierInfo pointers, which
974// are not guaranteed to be 8-byte aligned.
975template<>
976struct PointerLikeTypeTraits<clang::IdentifierInfo*> {
977 static void *getAsVoidPointer(clang::IdentifierInfo* P) {
978 return P;
979 }
980
981 static clang::IdentifierInfo *getFromVoidPointer(void *P) {
982 return static_cast<clang::IdentifierInfo*>(P);
983 }
984
985 static constexpr int NumLowBitsAvailable = 1;
986};
987
988template<>
989struct PointerLikeTypeTraits<const clang::IdentifierInfo*> {
990 static const void *getAsVoidPointer(const clang::IdentifierInfo* P) {
991 return P;
992 }
993
994 static const clang::IdentifierInfo *getFromVoidPointer(const void *P) {
995 return static_cast<const clang::IdentifierInfo*>(P);
996 }
997
998 static constexpr int NumLowBitsAvailable = 1;
999};
1000
1001} // namespace llvm
1002
1003#endif // LLVM_CLANG_BASIC_IDENTIFIERTABLE_H
1004