• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===--- IdentifierTable.h - Hash table for identifier lookup ---*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the IdentifierInfo, IdentifierTable, and Selector
11 // interfaces.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_CLANG_BASIC_IDENTIFIERTABLE_H
16 #define LLVM_CLANG_BASIC_IDENTIFIERTABLE_H
17 
18 #include "clang/Basic/OperatorKinds.h"
19 #include "clang/Basic/TokenKinds.h"
20 #include "clang/Basic/LLVM.h"
21 #include "llvm/ADT/StringMap.h"
22 #include "llvm/ADT/StringRef.h"
23 #include "llvm/ADT/OwningPtr.h"
24 #include "llvm/Support/PointerLikeTypeTraits.h"
25 #include <cassert>
26 #include <string>
27 
28 namespace llvm {
29   template <typename T> struct DenseMapInfo;
30 }
31 
32 namespace clang {
33   class LangOptions;
34   class IdentifierInfo;
35   class IdentifierTable;
36   class SourceLocation;
37   class MultiKeywordSelector; // private class used by Selector
38   class DeclarationName;      // AST class that stores declaration names
39 
40   /// IdentifierLocPair - A simple pair of identifier info and location.
41   typedef std::pair<IdentifierInfo*, SourceLocation> IdentifierLocPair;
42 
43 
44 /// IdentifierInfo - One of these records is kept for each identifier that
45 /// is lexed.  This contains information about whether the token was #define'd,
46 /// is a language keyword, or if it is a front-end token of some sort (e.g. a
47 /// variable or function name).  The preprocessor keeps this information in a
48 /// set, and all tok::identifier tokens have a pointer to one of these.
49 class IdentifierInfo {
50   unsigned TokenID            : 9; // Front-end token ID or tok::identifier.
51   // Objective-C keyword ('protocol' in '@protocol') or builtin (__builtin_inf).
52   // First NUM_OBJC_KEYWORDS values are for Objective-C, the remaining values
53   // are for builtins.
54   unsigned ObjCOrBuiltinID    :11;
55   bool HasMacro               : 1; // True if there is a #define for this.
56   bool IsExtension            : 1; // True if identifier is a lang extension.
57   bool IsCXX11CompatKeyword   : 1; // True if identifier is a keyword in C++11.
58   bool IsPoisoned             : 1; // True if identifier is poisoned.
59   bool IsCPPOperatorKeyword   : 1; // True if ident is a C++ operator keyword.
60   bool NeedsHandleIdentifier  : 1; // See "RecomputeNeedsHandleIdentifier".
61   bool IsFromAST              : 1; // True if identifier was loaded (at least
62                                    // partially) from an AST file.
63   bool ChangedAfterLoad       : 1; // True if identifier has changed from the
64                                    // definition loaded from an AST file.
65   bool RevertedTokenID        : 1; // True if RevertTokenIDToIdentifier was
66                                    // called.
67   bool OutOfDate              : 1; // True if there may be additional
68                                    // information about this identifier
69                                    // stored externally.
70   bool IsModulesImport               : 1; // True if this is the 'import' contextual
71                                    // keyword.
72   // 1 bit left in 32-bit word.
73 
74   void *FETokenInfo;               // Managed by the language front-end.
75   llvm::StringMapEntry<IdentifierInfo*> *Entry;
76 
77   IdentifierInfo(const IdentifierInfo&);  // NONCOPYABLE.
78   void operator=(const IdentifierInfo&);  // NONASSIGNABLE.
79 
80   friend class IdentifierTable;
81 
82 public:
83   IdentifierInfo();
84 
85 
86   /// isStr - Return true if this is the identifier for the specified string.
87   /// This is intended to be used for string literals only: II->isStr("foo").
88   template <std::size_t StrLen>
isStr(const char (& Str)[StrLen])89   bool isStr(const char (&Str)[StrLen]) const {
90     return getLength() == StrLen-1 && !memcmp(getNameStart(), Str, StrLen-1);
91   }
92 
93   /// getNameStart - Return the beginning of the actual string for this
94   /// identifier.  The returned string is properly null terminated.
95   ///
getNameStart()96   const char *getNameStart() const {
97     if (Entry) return Entry->getKeyData();
98     // FIXME: This is gross. It would be best not to embed specific details
99     // of the PTH file format here.
100     // The 'this' pointer really points to a
101     // std::pair<IdentifierInfo, const char*>, where internal pointer
102     // points to the external string data.
103     typedef std::pair<IdentifierInfo, const char*> actualtype;
104     return ((const actualtype*) this)->second;
105   }
106 
107   /// getLength - Efficiently return the length of this identifier info.
108   ///
getLength()109   unsigned getLength() const {
110     if (Entry) return Entry->getKeyLength();
111     // FIXME: This is gross. It would be best not to embed specific details
112     // of the PTH file format here.
113     // The 'this' pointer really points to a
114     // std::pair<IdentifierInfo, const char*>, where internal pointer
115     // points to the external string data.
116     typedef std::pair<IdentifierInfo, const char*> actualtype;
117     const char* p = ((const actualtype*) this)->second - 2;
118     return (((unsigned) p[0]) | (((unsigned) p[1]) << 8)) - 1;
119   }
120 
121   /// getName - Return the actual identifier string.
getName()122   StringRef getName() const {
123     return StringRef(getNameStart(), getLength());
124   }
125 
126   /// hasMacroDefinition - Return true if this identifier is #defined to some
127   /// other value.
hasMacroDefinition()128   bool hasMacroDefinition() const {
129     return HasMacro;
130   }
setHasMacroDefinition(bool Val)131   void setHasMacroDefinition(bool Val) {
132     if (HasMacro == Val) return;
133 
134     HasMacro = Val;
135     if (Val)
136       NeedsHandleIdentifier = 1;
137     else
138       RecomputeNeedsHandleIdentifier();
139   }
140 
141   /// getTokenID - If this is a source-language token (e.g. 'for'), this API
142   /// can be used to cause the lexer to map identifiers to source-language
143   /// tokens.
getTokenID()144   tok::TokenKind getTokenID() const { return (tok::TokenKind)TokenID; }
145 
146   /// \brief True if RevertTokenIDToIdentifier() was called.
hasRevertedTokenIDToIdentifier()147   bool hasRevertedTokenIDToIdentifier() const { return RevertedTokenID; }
148 
149   /// \brief Revert TokenID to tok::identifier; used for GNU libstdc++ 4.2
150   /// compatibility.
151   ///
152   /// TokenID is normally read-only but there are 2 instances where we revert it
153   /// to tok::identifier for libstdc++ 4.2. Keep track of when this happens
154   /// using this method so we can inform serialization about it.
RevertTokenIDToIdentifier()155   void RevertTokenIDToIdentifier() {
156     assert(TokenID != tok::identifier && "Already at tok::identifier");
157     TokenID = tok::identifier;
158     RevertedTokenID = true;
159   }
160 
161   /// getPPKeywordID - Return the preprocessor keyword ID for this identifier.
162   /// For example, "define" will return tok::pp_define.
163   tok::PPKeywordKind getPPKeywordID() const;
164 
165   /// getObjCKeywordID - Return the Objective-C keyword ID for the this
166   /// identifier.  For example, 'class' will return tok::objc_class if ObjC is
167   /// enabled.
getObjCKeywordID()168   tok::ObjCKeywordKind getObjCKeywordID() const {
169     if (ObjCOrBuiltinID < tok::NUM_OBJC_KEYWORDS)
170       return tok::ObjCKeywordKind(ObjCOrBuiltinID);
171     else
172       return tok::objc_not_keyword;
173   }
setObjCKeywordID(tok::ObjCKeywordKind ID)174   void setObjCKeywordID(tok::ObjCKeywordKind ID) { ObjCOrBuiltinID = ID; }
175 
176   /// getBuiltinID - Return a value indicating whether this is a builtin
177   /// function.  0 is not-built-in.  1 is builtin-for-some-nonprimary-target.
178   /// 2+ are specific builtin functions.
getBuiltinID()179   unsigned getBuiltinID() const {
180     if (ObjCOrBuiltinID >= tok::NUM_OBJC_KEYWORDS)
181       return ObjCOrBuiltinID - tok::NUM_OBJC_KEYWORDS;
182     else
183       return 0;
184   }
setBuiltinID(unsigned ID)185   void setBuiltinID(unsigned ID) {
186     ObjCOrBuiltinID = ID + tok::NUM_OBJC_KEYWORDS;
187     assert(ObjCOrBuiltinID - unsigned(tok::NUM_OBJC_KEYWORDS) == ID
188            && "ID too large for field!");
189   }
190 
getObjCOrBuiltinID()191   unsigned getObjCOrBuiltinID() const { return ObjCOrBuiltinID; }
setObjCOrBuiltinID(unsigned ID)192   void setObjCOrBuiltinID(unsigned ID) { ObjCOrBuiltinID = ID; }
193 
194   /// get/setExtension - Initialize information about whether or not this
195   /// language token is an extension.  This controls extension warnings, and is
196   /// only valid if a custom token ID is set.
isExtensionToken()197   bool isExtensionToken() const { return IsExtension; }
setIsExtensionToken(bool Val)198   void setIsExtensionToken(bool Val) {
199     IsExtension = Val;
200     if (Val)
201       NeedsHandleIdentifier = 1;
202     else
203       RecomputeNeedsHandleIdentifier();
204   }
205 
206   /// is/setIsCXX11CompatKeyword - Initialize information about whether or not
207   /// this language token is a keyword in C++11. This controls compatibility
208   /// warnings, and is only true when not parsing C++11. Once a compatibility
209   /// problem has been diagnosed with this keyword, the flag will be cleared.
isCXX11CompatKeyword()210   bool isCXX11CompatKeyword() const { return IsCXX11CompatKeyword; }
setIsCXX11CompatKeyword(bool Val)211   void setIsCXX11CompatKeyword(bool Val) {
212     IsCXX11CompatKeyword = Val;
213     if (Val)
214       NeedsHandleIdentifier = 1;
215     else
216       RecomputeNeedsHandleIdentifier();
217   }
218 
219   /// setIsPoisoned - Mark this identifier as poisoned.  After poisoning, the
220   /// Preprocessor will emit an error every time this token is used.
221   void setIsPoisoned(bool Value = true) {
222     IsPoisoned = Value;
223     if (Value)
224       NeedsHandleIdentifier = 1;
225     else
226       RecomputeNeedsHandleIdentifier();
227   }
228 
229   /// isPoisoned - Return true if this token has been poisoned.
isPoisoned()230   bool isPoisoned() const { return IsPoisoned; }
231 
232   /// isCPlusPlusOperatorKeyword/setIsCPlusPlusOperatorKeyword controls whether
233   /// this identifier is a C++ alternate representation of an operator.
234   void setIsCPlusPlusOperatorKeyword(bool Val = true) {
235     IsCPPOperatorKeyword = Val;
236     if (Val)
237       NeedsHandleIdentifier = 1;
238     else
239       RecomputeNeedsHandleIdentifier();
240   }
isCPlusPlusOperatorKeyword()241   bool isCPlusPlusOperatorKeyword() const { return IsCPPOperatorKeyword; }
242 
243   /// getFETokenInfo/setFETokenInfo - The language front-end is allowed to
244   /// associate arbitrary metadata with this token.
245   template<typename T>
getFETokenInfo()246   T *getFETokenInfo() const { return static_cast<T*>(FETokenInfo); }
setFETokenInfo(void * T)247   void setFETokenInfo(void *T) { FETokenInfo = T; }
248 
249   /// isHandleIdentifierCase - Return true if the Preprocessor::HandleIdentifier
250   /// must be called on a token of this identifier.  If this returns false, we
251   /// know that HandleIdentifier will not affect the token.
isHandleIdentifierCase()252   bool isHandleIdentifierCase() const { return NeedsHandleIdentifier; }
253 
254   /// isFromAST - Return true if the identifier in its current state was loaded
255   /// from an AST file.
isFromAST()256   bool isFromAST() const { return IsFromAST; }
257 
setIsFromAST()258   void setIsFromAST() { IsFromAST = true; }
259 
260   /// \brief Determine whether this identifier has changed since it was loaded
261   /// from an AST file.
hasChangedSinceDeserialization()262   bool hasChangedSinceDeserialization() const {
263     return ChangedAfterLoad;
264   }
265 
266   /// \brief Note that this identifier has changed since it was loaded from
267   /// an AST file.
setChangedSinceDeserialization()268   void setChangedSinceDeserialization() {
269     ChangedAfterLoad = true;
270   }
271 
272   /// \brief Determine whether the information for this identifier is out of
273   /// date with respect to the external source.
isOutOfDate()274   bool isOutOfDate() const { return OutOfDate; }
275 
276   /// \brief Set whether the information for this identifier is out of
277   /// date with respect to the external source.
setOutOfDate(bool OOD)278   void setOutOfDate(bool OOD) {
279     OutOfDate = OOD;
280     if (OOD)
281       NeedsHandleIdentifier = true;
282     else
283       RecomputeNeedsHandleIdentifier();
284   }
285 
286   /// \brief Determine whether this is the contextual keyword
287   /// '__experimental_modules_import'.
isModulesImport()288   bool isModulesImport() const { return IsModulesImport; }
289 
290   /// \brief Set whether this identifier is the contextual keyword
291   /// '__experimental_modules_import'.
setModulesImport(bool I)292   void setModulesImport(bool I) {
293     IsModulesImport = I;
294     if (I)
295       NeedsHandleIdentifier = true;
296     else
297       RecomputeNeedsHandleIdentifier();
298   }
299 
300 private:
301   /// RecomputeNeedsHandleIdentifier - The Preprocessor::HandleIdentifier does
302   /// several special (but rare) things to identifiers of various sorts.  For
303   /// example, it changes the "for" keyword token from tok::identifier to
304   /// tok::for.
305   ///
306   /// This method is very tied to the definition of HandleIdentifier.  Any
307   /// change to it should be reflected here.
RecomputeNeedsHandleIdentifier()308   void RecomputeNeedsHandleIdentifier() {
309     NeedsHandleIdentifier =
310       (isPoisoned() | hasMacroDefinition() | isCPlusPlusOperatorKeyword() |
311        isExtensionToken() | isCXX11CompatKeyword() || isOutOfDate() ||
312        isModulesImport());
313   }
314 };
315 
316 /// \brief an RAII object for [un]poisoning an identifier
317 /// within a certain scope. II is allowed to be null, in
318 /// which case, objects of this type have no effect.
319 class PoisonIdentifierRAIIObject {
320   IdentifierInfo *const II;
321   const bool OldValue;
322 public:
PoisonIdentifierRAIIObject(IdentifierInfo * II,bool NewValue)323   PoisonIdentifierRAIIObject(IdentifierInfo *II, bool NewValue)
324     : II(II), OldValue(II ? II->isPoisoned() : false) {
325     if(II)
326       II->setIsPoisoned(NewValue);
327   }
328 
~PoisonIdentifierRAIIObject()329   ~PoisonIdentifierRAIIObject() {
330     if(II)
331       II->setIsPoisoned(OldValue);
332   }
333 };
334 
335 /// \brief An iterator that walks over all of the known identifiers
336 /// in the lookup table.
337 ///
338 /// Since this iterator uses an abstract interface via virtual
339 /// functions, it uses an object-oriented interface rather than the
340 /// more standard C++ STL iterator interface. In this OO-style
341 /// iteration, the single function \c Next() provides dereference,
342 /// advance, and end-of-sequence checking in a single
343 /// operation. Subclasses of this iterator type will provide the
344 /// actual functionality.
345 class IdentifierIterator {
346 private:
347   IdentifierIterator(const IdentifierIterator&); // Do not implement
348   IdentifierIterator &operator=(const IdentifierIterator&); // Do not implement
349 
350 protected:
IdentifierIterator()351   IdentifierIterator() { }
352 
353 public:
354   virtual ~IdentifierIterator();
355 
356   /// \brief Retrieve the next string in the identifier table and
357   /// advances the iterator for the following string.
358   ///
359   /// \returns The next string in the identifier table. If there is
360   /// no such string, returns an empty \c StringRef.
361   virtual StringRef Next() = 0;
362 };
363 
364 /// IdentifierInfoLookup - An abstract class used by IdentifierTable that
365 ///  provides an interface for performing lookups from strings
366 /// (const char *) to IdentiferInfo objects.
367 class IdentifierInfoLookup {
368 public:
369   virtual ~IdentifierInfoLookup();
370 
371   /// get - Return the identifier token info for the specified named identifier.
372   ///  Unlike the version in IdentifierTable, this returns a pointer instead
373   ///  of a reference.  If the pointer is NULL then the IdentifierInfo cannot
374   ///  be found.
375   virtual IdentifierInfo* get(StringRef Name) = 0;
376 
377   /// \brief Retrieve an iterator into the set of all identifiers
378   /// known to this identifier lookup source.
379   ///
380   /// This routine provides access to all of the identifiers known to
381   /// the identifier lookup, allowing access to the contents of the
382   /// identifiers without introducing the overhead of constructing
383   /// IdentifierInfo objects for each.
384   ///
385   /// \returns A new iterator into the set of known identifiers. The
386   /// caller is responsible for deleting this iterator.
387   virtual IdentifierIterator *getIdentifiers() const;
388 };
389 
390 /// \brief An abstract class used to resolve numerical identifier
391 /// references (meaningful only to some external source) into
392 /// IdentifierInfo pointers.
393 class ExternalIdentifierLookup {
394 public:
395   virtual ~ExternalIdentifierLookup();
396 
397   /// \brief Return the identifier associated with the given ID number.
398   ///
399   /// The ID 0 is associated with the NULL identifier.
400   virtual IdentifierInfo *GetIdentifier(unsigned ID) = 0;
401 };
402 
403 /// IdentifierTable - This table implements an efficient mapping from strings to
404 /// IdentifierInfo nodes.  It has no other purpose, but this is an
405 /// extremely performance-critical piece of the code, as each occurrence of
406 /// every identifier goes through here when lexed.
407 class IdentifierTable {
408   // Shark shows that using MallocAllocator is *much* slower than using this
409   // BumpPtrAllocator!
410   typedef llvm::StringMap<IdentifierInfo*, llvm::BumpPtrAllocator> HashTableTy;
411   HashTableTy HashTable;
412 
413   IdentifierInfoLookup* ExternalLookup;
414 
415 public:
416   /// IdentifierTable ctor - Create the identifier table, populating it with
417   /// info about the language keywords for the language specified by LangOpts.
418   IdentifierTable(const LangOptions &LangOpts,
419                   IdentifierInfoLookup* externalLookup = 0);
420 
421   /// \brief Set the external identifier lookup mechanism.
setExternalIdentifierLookup(IdentifierInfoLookup * IILookup)422   void setExternalIdentifierLookup(IdentifierInfoLookup *IILookup) {
423     ExternalLookup = IILookup;
424   }
425 
426   /// \brief Retrieve the external identifier lookup object, if any.
getExternalIdentifierLookup()427   IdentifierInfoLookup *getExternalIdentifierLookup() const {
428     return ExternalLookup;
429   }
430 
getAllocator()431   llvm::BumpPtrAllocator& getAllocator() {
432     return HashTable.getAllocator();
433   }
434 
435   /// get - Return the identifier token info for the specified named identifier.
436   ///
get(StringRef Name)437   IdentifierInfo &get(StringRef Name) {
438     llvm::StringMapEntry<IdentifierInfo*> &Entry =
439       HashTable.GetOrCreateValue(Name);
440 
441     IdentifierInfo *II = Entry.getValue();
442     if (II) return *II;
443 
444     // No entry; if we have an external lookup, look there first.
445     if (ExternalLookup) {
446       II = ExternalLookup->get(Name);
447       if (II) {
448         // Cache in the StringMap for subsequent lookups.
449         Entry.setValue(II);
450         return *II;
451       }
452     }
453 
454     // Lookups failed, make a new IdentifierInfo.
455     void *Mem = getAllocator().Allocate<IdentifierInfo>();
456     II = new (Mem) IdentifierInfo();
457     Entry.setValue(II);
458 
459     // Make sure getName() knows how to find the IdentifierInfo
460     // contents.
461     II->Entry = &Entry;
462 
463     return *II;
464   }
465 
get(StringRef Name,tok::TokenKind TokenCode)466   IdentifierInfo &get(StringRef Name, tok::TokenKind TokenCode) {
467     IdentifierInfo &II = get(Name);
468     II.TokenID = TokenCode;
469     assert(II.TokenID == (unsigned) TokenCode && "TokenCode too large");
470     return II;
471   }
472 
473   /// \brief Gets an IdentifierInfo for the given name without consulting
474   ///        external sources.
475   ///
476   /// This is a version of get() meant for external sources that want to
477   /// introduce or modify an identifier. If they called get(), they would
478   /// likely end up in a recursion.
getOwn(StringRef Name)479   IdentifierInfo &getOwn(StringRef Name) {
480     llvm::StringMapEntry<IdentifierInfo*> &Entry =
481       HashTable.GetOrCreateValue(Name);
482 
483     IdentifierInfo *II = Entry.getValue();
484     if (!II) {
485 
486       // Lookups failed, make a new IdentifierInfo.
487       void *Mem = getAllocator().Allocate<IdentifierInfo>();
488       II = new (Mem) IdentifierInfo();
489       Entry.setValue(II);
490 
491       // Make sure getName() knows how to find the IdentifierInfo
492       // contents.
493       II->Entry = &Entry;
494 
495       // If this is the 'import' contextual keyword, mark it as such.
496       if (Name.equals("import"))
497         II->setModulesImport(true);
498     }
499 
500     return *II;
501   }
502 
503   typedef HashTableTy::const_iterator iterator;
504   typedef HashTableTy::const_iterator const_iterator;
505 
begin()506   iterator begin() const { return HashTable.begin(); }
end()507   iterator end() const   { return HashTable.end(); }
size()508   unsigned size() const { return HashTable.size(); }
509 
510   /// PrintStats - Print some statistics to stderr that indicate how well the
511   /// hashing is doing.
512   void PrintStats() const;
513 
514   void AddKeywords(const LangOptions &LangOpts);
515 };
516 
517 /// ObjCMethodFamily - A family of Objective-C methods.  These
518 /// families have no inherent meaning in the language, but are
519 /// nonetheless central enough in the existing implementations to
520 /// merit direct AST support.  While, in theory, arbitrary methods can
521 /// be considered to form families, we focus here on the methods
522 /// involving allocation and retain-count management, as these are the
523 /// most "core" and the most likely to be useful to diverse clients
524 /// without extra information.
525 ///
526 /// Both selectors and actual method declarations may be classified
527 /// into families.  Method families may impose additional restrictions
528 /// beyond their selector name; for example, a method called '_init'
529 /// that returns void is not considered to be in the 'init' family
530 /// (but would be if it returned 'id').  It is also possible to
531 /// explicitly change or remove a method's family.  Therefore the
532 /// method's family should be considered the single source of truth.
533 enum ObjCMethodFamily {
534   /// \brief No particular method family.
535   OMF_None,
536 
537   // Selectors in these families may have arbitrary arity, may be
538   // written with arbitrary leading underscores, and may have
539   // additional CamelCase "words" in their first selector chunk
540   // following the family name.
541   OMF_alloc,
542   OMF_copy,
543   OMF_init,
544   OMF_mutableCopy,
545   OMF_new,
546 
547   // These families are singletons consisting only of the nullary
548   // selector with the given name.
549   OMF_autorelease,
550   OMF_dealloc,
551   OMF_finalize,
552   OMF_release,
553   OMF_retain,
554   OMF_retainCount,
555   OMF_self,
556 
557   // performSelector families
558   OMF_performSelector
559 };
560 
561 /// Enough bits to store any enumerator in ObjCMethodFamily or
562 /// InvalidObjCMethodFamily.
563 enum { ObjCMethodFamilyBitWidth = 4 };
564 
565 /// An invalid value of ObjCMethodFamily.
566 enum { InvalidObjCMethodFamily = (1 << ObjCMethodFamilyBitWidth) - 1 };
567 
568 /// Selector - This smart pointer class efficiently represents Objective-C
569 /// method names. This class will either point to an IdentifierInfo or a
570 /// MultiKeywordSelector (which is private). This enables us to optimize
571 /// selectors that take no arguments and selectors that take 1 argument, which
572 /// accounts for 78% of all selectors in Cocoa.h.
573 class Selector {
574   friend class Diagnostic;
575 
576   enum IdentifierInfoFlag {
577     // MultiKeywordSelector = 0.
578     ZeroArg  = 0x1,
579     OneArg   = 0x2,
580     ArgFlags = ZeroArg|OneArg
581   };
582   uintptr_t InfoPtr; // a pointer to the MultiKeywordSelector or IdentifierInfo.
583 
Selector(IdentifierInfo * II,unsigned nArgs)584   Selector(IdentifierInfo *II, unsigned nArgs) {
585     InfoPtr = reinterpret_cast<uintptr_t>(II);
586     assert((InfoPtr & ArgFlags) == 0 &&"Insufficiently aligned IdentifierInfo");
587     assert(nArgs < 2 && "nArgs not equal to 0/1");
588     InfoPtr |= nArgs+1;
589   }
Selector(MultiKeywordSelector * SI)590   Selector(MultiKeywordSelector *SI) {
591     InfoPtr = reinterpret_cast<uintptr_t>(SI);
592     assert((InfoPtr & ArgFlags) == 0 &&"Insufficiently aligned IdentifierInfo");
593   }
594 
getAsIdentifierInfo()595   IdentifierInfo *getAsIdentifierInfo() const {
596     if (getIdentifierInfoFlag())
597       return reinterpret_cast<IdentifierInfo *>(InfoPtr & ~ArgFlags);
598     return 0;
599   }
getIdentifierInfoFlag()600   unsigned getIdentifierInfoFlag() const {
601     return InfoPtr & ArgFlags;
602   }
603 
604   static ObjCMethodFamily getMethodFamilyImpl(Selector sel);
605 
606 public:
607   friend class SelectorTable; // only the SelectorTable can create these
608   friend class DeclarationName; // and the AST's DeclarationName.
609 
610   /// The default ctor should only be used when creating data structures that
611   ///  will contain selectors.
Selector()612   Selector() : InfoPtr(0) {}
Selector(uintptr_t V)613   Selector(uintptr_t V) : InfoPtr(V) {}
614 
615   /// operator==/!= - Indicate whether the specified selectors are identical.
616   bool operator==(Selector RHS) const {
617     return InfoPtr == RHS.InfoPtr;
618   }
619   bool operator!=(Selector RHS) const {
620     return InfoPtr != RHS.InfoPtr;
621   }
getAsOpaquePtr()622   void *getAsOpaquePtr() const {
623     return reinterpret_cast<void*>(InfoPtr);
624   }
625 
626   /// \brief Determine whether this is the empty selector.
isNull()627   bool isNull() const { return InfoPtr == 0; }
628 
629   // Predicates to identify the selector type.
isKeywordSelector()630   bool isKeywordSelector() const {
631     return getIdentifierInfoFlag() != ZeroArg;
632   }
isUnarySelector()633   bool isUnarySelector() const {
634     return getIdentifierInfoFlag() == ZeroArg;
635   }
636   unsigned getNumArgs() const;
637 
638 
639   /// \brief Retrieve the identifier at a given position in the selector.
640   ///
641   /// Note that the identifier pointer returned may be NULL. Clients that only
642   /// care about the text of the identifier string, and not the specific,
643   /// uniqued identifier pointer, should use \c getNameForSlot(), which returns
644   /// an empty string when the identifier pointer would be NULL.
645   ///
646   /// \param argIndex The index for which we want to retrieve the identifier.
647   /// This index shall be less than \c getNumArgs() unless this is a keyword
648   /// selector, in which case 0 is the only permissible value.
649   ///
650   /// \returns the uniqued identifier for this slot, or NULL if this slot has
651   /// no corresponding identifier.
652   IdentifierInfo *getIdentifierInfoForSlot(unsigned argIndex) const;
653 
654   /// \brief Retrieve the name at a given position in the selector.
655   ///
656   /// \param argIndex The index for which we want to retrieve the name.
657   /// This index shall be less than \c getNumArgs() unless this is a keyword
658   /// selector, in which case 0 is the only permissible value.
659   ///
660   /// \returns the name for this slot, which may be the empty string if no
661   /// name was supplied.
662   StringRef getNameForSlot(unsigned argIndex) const;
663 
664   /// getAsString - Derive the full selector name (e.g. "foo:bar:") and return
665   /// it as an std::string.
666   std::string getAsString() const;
667 
668   /// getMethodFamily - Derive the conventional family of this method.
getMethodFamily()669   ObjCMethodFamily getMethodFamily() const {
670     return getMethodFamilyImpl(*this);
671   }
672 
getEmptyMarker()673   static Selector getEmptyMarker() {
674     return Selector(uintptr_t(-1));
675   }
getTombstoneMarker()676   static Selector getTombstoneMarker() {
677     return Selector(uintptr_t(-2));
678   }
679 };
680 
681 /// SelectorTable - This table allows us to fully hide how we implement
682 /// multi-keyword caching.
683 class SelectorTable {
684   void *Impl;  // Actually a SelectorTableImpl
685   SelectorTable(const SelectorTable&); // DISABLED: DO NOT IMPLEMENT
686   void operator=(const SelectorTable&); // DISABLED: DO NOT IMPLEMENT
687 public:
688   SelectorTable();
689   ~SelectorTable();
690 
691   /// getSelector - This can create any sort of selector.  NumArgs indicates
692   /// whether this is a no argument selector "foo", a single argument selector
693   /// "foo:" or multi-argument "foo:bar:".
694   Selector getSelector(unsigned NumArgs, IdentifierInfo **IIV);
695 
getUnarySelector(IdentifierInfo * ID)696   Selector getUnarySelector(IdentifierInfo *ID) {
697     return Selector(ID, 1);
698   }
getNullarySelector(IdentifierInfo * ID)699   Selector getNullarySelector(IdentifierInfo *ID) {
700     return Selector(ID, 0);
701   }
702 
703   /// Return the total amount of memory allocated for managing selectors.
704   size_t getTotalMemory() const;
705 
706   /// constructSetterName - Return the setter name for the given
707   /// identifier, i.e. "set" + Name where the initial character of Name
708   /// has been capitalized.
709   static Selector constructSetterName(IdentifierTable &Idents,
710                                       SelectorTable &SelTable,
711                                       const IdentifierInfo *Name);
712 };
713 
714 /// DeclarationNameExtra - Common base of the MultiKeywordSelector,
715 /// CXXSpecialName, and CXXOperatorIdName classes, all of which are
716 /// private classes that describe different kinds of names.
717 class DeclarationNameExtra {
718 public:
719   /// ExtraKind - The kind of "extra" information stored in the
720   /// DeclarationName. See @c ExtraKindOrNumArgs for an explanation of
721   /// how these enumerator values are used.
722   enum ExtraKind {
723     CXXConstructor = 0,
724     CXXDestructor,
725     CXXConversionFunction,
726 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
727     CXXOperator##Name,
728 #include "clang/Basic/OperatorKinds.def"
729     CXXLiteralOperator,
730     CXXUsingDirective,
731     NUM_EXTRA_KINDS
732   };
733 
734   /// ExtraKindOrNumArgs - Either the kind of C++ special name or
735   /// operator-id (if the value is one of the CXX* enumerators of
736   /// ExtraKind), in which case the DeclarationNameExtra is also a
737   /// CXXSpecialName, (for CXXConstructor, CXXDestructor, or
738   /// CXXConversionFunction) CXXOperatorIdName, or CXXLiteralOperatorName,
739   /// it may be also name common to C++ using-directives (CXXUsingDirective),
740   /// otherwise it is NUM_EXTRA_KINDS+NumArgs, where NumArgs is the number of
741   /// arguments in the Objective-C selector, in which case the
742   /// DeclarationNameExtra is also a MultiKeywordSelector.
743   unsigned ExtraKindOrNumArgs;
744 };
745 
746 }  // end namespace clang
747 
748 namespace llvm {
749 /// Define DenseMapInfo so that Selectors can be used as keys in DenseMap and
750 /// DenseSets.
751 template <>
752 struct DenseMapInfo<clang::Selector> {
753   static inline clang::Selector getEmptyKey() {
754     return clang::Selector::getEmptyMarker();
755   }
756   static inline clang::Selector getTombstoneKey() {
757     return clang::Selector::getTombstoneMarker();
758   }
759 
760   static unsigned getHashValue(clang::Selector S);
761 
762   static bool isEqual(clang::Selector LHS, clang::Selector RHS) {
763     return LHS == RHS;
764   }
765 };
766 
767 template <>
768 struct isPodLike<clang::Selector> { static const bool value = true; };
769 
770 template<>
771 class PointerLikeTypeTraits<clang::Selector> {
772 public:
773   static inline const void *getAsVoidPointer(clang::Selector P) {
774     return P.getAsOpaquePtr();
775   }
776   static inline clang::Selector getFromVoidPointer(const void *P) {
777     return clang::Selector(reinterpret_cast<uintptr_t>(P));
778   }
779   enum { NumLowBitsAvailable = 0 };
780 };
781 
782 // Provide PointerLikeTypeTraits for IdentifierInfo pointers, which
783 // are not guaranteed to be 8-byte aligned.
784 template<>
785 class PointerLikeTypeTraits<clang::IdentifierInfo*> {
786 public:
787   static inline void *getAsVoidPointer(clang::IdentifierInfo* P) {
788     return P;
789   }
790   static inline clang::IdentifierInfo *getFromVoidPointer(void *P) {
791     return static_cast<clang::IdentifierInfo*>(P);
792   }
793   enum { NumLowBitsAvailable = 1 };
794 };
795 
796 template<>
797 class PointerLikeTypeTraits<const clang::IdentifierInfo*> {
798 public:
799   static inline const void *getAsVoidPointer(const clang::IdentifierInfo* P) {
800     return P;
801   }
802   static inline const clang::IdentifierInfo *getFromVoidPointer(const void *P) {
803     return static_cast<const clang::IdentifierInfo*>(P);
804   }
805   enum { NumLowBitsAvailable = 1 };
806 };
807 
808 }  // end namespace llvm
809 #endif
810