1 //===- MacroInfo.h - Information about #defined identifiers -----*- 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::MacroInfo and clang::MacroDirective classes.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_LEX_MACROINFO_H
15 #define LLVM_CLANG_LEX_MACROINFO_H
16 
17 #include "clang/Lex/Token.h"
18 #include "clang/Basic/LLVM.h"
19 #include "clang/Basic/SourceLocation.h"
20 #include "llvm/ADT/ArrayRef.h"
21 #include "llvm/ADT/FoldingSet.h"
22 #include "llvm/ADT/PointerIntPair.h"
23 #include "llvm/ADT/SmallVector.h"
24 #include "llvm/Support/Allocator.h"
25 #include <algorithm>
26 #include <cassert>
27 
28 namespace clang {
29 
30 class DefMacroDirective;
31 class IdentifierInfo;
32 class Module;
33 class Preprocessor;
34 class SourceManager;
35 
36 /// Encapsulates the data about a macro definition (e.g. its tokens).
37 ///
38 /// There's an instance of this class for every #define.
39 class MacroInfo {
40   //===--------------------------------------------------------------------===//
41   // State set when the macro is defined.
42 
43   /// The location the macro is defined.
44   SourceLocation Location;
45 
46   /// The location of the last token in the macro.
47   SourceLocation EndLocation;
48 
49   /// The list of arguments for a function-like macro.
50   ///
51   /// ParameterList points to the first of NumParameters pointers.
52   ///
53   /// This can be empty, for, e.g. "#define X()".  In a C99-style variadic
54   /// macro, this includes the \c __VA_ARGS__ identifier on the list.
55   IdentifierInfo **ParameterList = nullptr;
56 
57   /// This is the list of tokens that the macro is defined to.
58   const Token *ReplacementTokens = nullptr;
59 
60   /// \see ParameterList
61   unsigned NumParameters = 0;
62 
63   /// \see ReplacementTokens
64   unsigned NumReplacementTokens = 0;
65 
66   /// Length in characters of the macro definition.
67   mutable unsigned DefinitionLength;
68   mutable bool IsDefinitionLengthCached : 1;
69 
70   /// True if this macro is function-like, false if it is object-like.
71   bool IsFunctionLike : 1;
72 
73   /// True if this macro is of the form "#define X(...)" or
74   /// "#define X(Y,Z,...)".
75   ///
76   /// The __VA_ARGS__ token should be replaced with the contents of "..." in an
77   /// invocation.
78   bool IsC99Varargs : 1;
79 
80   /// True if this macro is of the form "#define X(a...)".
81   ///
82   /// The "a" identifier in the replacement list will be replaced with all
83   /// arguments of the macro starting with the specified one.
84   bool IsGNUVarargs : 1;
85 
86   /// True if this macro requires processing before expansion.
87   ///
88   /// This is the case for builtin macros such as __LINE__, so long as they have
89   /// not been redefined, but not for regular predefined macros from the
90   /// "<built-in>" memory buffer (see Preprocessing::getPredefinesFileID).
91   bool IsBuiltinMacro : 1;
92 
93   /// Whether this macro contains the sequence ", ## __VA_ARGS__"
94   bool HasCommaPasting : 1;
95 
96   //===--------------------------------------------------------------------===//
97   // State that changes as the macro is used.
98 
99   /// True if we have started an expansion of this macro already.
100   ///
101   /// This disables recursive expansion, which would be quite bad for things
102   /// like \#define A A.
103   bool IsDisabled : 1;
104 
105   /// True if this macro is either defined in the main file and has
106   /// been used, or if it is not defined in the main file.
107   ///
108   /// This is used to emit -Wunused-macros diagnostics.
109   bool IsUsed : 1;
110 
111   /// True if this macro can be redefined without emitting a warning.
112   bool IsAllowRedefinitionsWithoutWarning : 1;
113 
114   /// Must warn if the macro is unused at the end of translation unit.
115   bool IsWarnIfUnused : 1;
116 
117   /// Whether this macro was used as header guard.
118   bool UsedForHeaderGuard : 1;
119 
120   // Only the Preprocessor gets to create these.
121   MacroInfo(SourceLocation DefLoc);
122 
123 public:
124   /// Return the location that the macro was defined at.
getDefinitionLoc()125   SourceLocation getDefinitionLoc() const { return Location; }
126 
127   /// Set the location of the last token in the macro.
setDefinitionEndLoc(SourceLocation EndLoc)128   void setDefinitionEndLoc(SourceLocation EndLoc) { EndLocation = EndLoc; }
129 
130   /// Return the location of the last token in the macro.
getDefinitionEndLoc()131   SourceLocation getDefinitionEndLoc() const { return EndLocation; }
132 
133   /// Get length in characters of the macro definition.
getDefinitionLength(const SourceManager & SM)134   unsigned getDefinitionLength(const SourceManager &SM) const {
135     if (IsDefinitionLengthCached)
136       return DefinitionLength;
137     return getDefinitionLengthSlow(SM);
138   }
139 
140   /// Return true if the specified macro definition is equal to
141   /// this macro in spelling, arguments, and whitespace.
142   ///
143   /// \param Syntactically if true, the macro definitions can be identical even
144   /// if they use different identifiers for the function macro parameters.
145   /// Otherwise the comparison is lexical and this implements the rules in
146   /// C99 6.10.3.
147   bool isIdenticalTo(const MacroInfo &Other, Preprocessor &PP,
148                      bool Syntactically) const;
149 
150   /// Set or clear the isBuiltinMacro flag.
151   void setIsBuiltinMacro(bool Val = true) { IsBuiltinMacro = Val; }
152 
153   /// Set the value of the IsUsed flag.
setIsUsed(bool Val)154   void setIsUsed(bool Val) { IsUsed = Val; }
155 
156   /// Set the value of the IsAllowRedefinitionsWithoutWarning flag.
setIsAllowRedefinitionsWithoutWarning(bool Val)157   void setIsAllowRedefinitionsWithoutWarning(bool Val) {
158     IsAllowRedefinitionsWithoutWarning = Val;
159   }
160 
161   /// Set the value of the IsWarnIfUnused flag.
setIsWarnIfUnused(bool val)162   void setIsWarnIfUnused(bool val) { IsWarnIfUnused = val; }
163 
164   /// Set the specified list of identifiers as the parameter list for
165   /// this macro.
setParameterList(ArrayRef<IdentifierInfo * > List,llvm::BumpPtrAllocator & PPAllocator)166   void setParameterList(ArrayRef<IdentifierInfo *> List,
167                        llvm::BumpPtrAllocator &PPAllocator) {
168     assert(ParameterList == nullptr && NumParameters == 0 &&
169            "Parameter list already set!");
170     if (List.empty())
171       return;
172 
173     NumParameters = List.size();
174     ParameterList = PPAllocator.Allocate<IdentifierInfo *>(List.size());
175     std::copy(List.begin(), List.end(), ParameterList);
176   }
177 
178   /// Parameters - The list of parameters for a function-like macro.  This can
179   /// be empty, for, e.g. "#define X()".
180   using param_iterator = IdentifierInfo *const *;
param_empty()181   bool param_empty() const { return NumParameters == 0; }
param_begin()182   param_iterator param_begin() const { return ParameterList; }
param_end()183   param_iterator param_end() const { return ParameterList + NumParameters; }
getNumParams()184   unsigned getNumParams() const { return NumParameters; }
params()185   ArrayRef<const IdentifierInfo *> params() const {
186     return ArrayRef<const IdentifierInfo *>(ParameterList, NumParameters);
187   }
188 
189   /// Return the parameter number of the specified identifier,
190   /// or -1 if the identifier is not a formal parameter identifier.
getParameterNum(const IdentifierInfo * Arg)191   int getParameterNum(const IdentifierInfo *Arg) const {
192     for (param_iterator I = param_begin(), E = param_end(); I != E; ++I)
193       if (*I == Arg)
194         return I - param_begin();
195     return -1;
196   }
197 
198   /// Function/Object-likeness.  Keep track of whether this macro has formal
199   /// parameters.
setIsFunctionLike()200   void setIsFunctionLike() { IsFunctionLike = true; }
isFunctionLike()201   bool isFunctionLike() const { return IsFunctionLike; }
isObjectLike()202   bool isObjectLike() const { return !IsFunctionLike; }
203 
204   /// Varargs querying methods.  This can only be set for function-like macros.
setIsC99Varargs()205   void setIsC99Varargs() { IsC99Varargs = true; }
setIsGNUVarargs()206   void setIsGNUVarargs() { IsGNUVarargs = true; }
isC99Varargs()207   bool isC99Varargs() const { return IsC99Varargs; }
isGNUVarargs()208   bool isGNUVarargs() const { return IsGNUVarargs; }
isVariadic()209   bool isVariadic() const { return IsC99Varargs | IsGNUVarargs; }
210 
211   /// Return true if this macro requires processing before expansion.
212   ///
213   /// This is true only for builtin macro, such as \__LINE__, whose values
214   /// are not given by fixed textual expansions.  Regular predefined macros
215   /// from the "<built-in>" buffer are not reported as builtins by this
216   /// function.
isBuiltinMacro()217   bool isBuiltinMacro() const { return IsBuiltinMacro; }
218 
hasCommaPasting()219   bool hasCommaPasting() const { return HasCommaPasting; }
setHasCommaPasting()220   void setHasCommaPasting() { HasCommaPasting = true; }
221 
222   /// Return false if this macro is defined in the main file and has
223   /// not yet been used.
isUsed()224   bool isUsed() const { return IsUsed; }
225 
226   /// Return true if this macro can be redefined without warning.
isAllowRedefinitionsWithoutWarning()227   bool isAllowRedefinitionsWithoutWarning() const {
228     return IsAllowRedefinitionsWithoutWarning;
229   }
230 
231   /// Return true if we should emit a warning if the macro is unused.
isWarnIfUnused()232   bool isWarnIfUnused() const { return IsWarnIfUnused; }
233 
234   /// Return the number of tokens that this macro expands to.
getNumTokens()235   unsigned getNumTokens() const { return NumReplacementTokens; }
236 
getReplacementToken(unsigned Tok)237   const Token &getReplacementToken(unsigned Tok) const {
238     assert(Tok < NumReplacementTokens && "Invalid token #");
239     return ReplacementTokens[Tok];
240   }
241 
242   using const_tokens_iterator = const Token *;
243 
tokens_begin()244   const_tokens_iterator tokens_begin() const { return ReplacementTokens; }
tokens_end()245   const_tokens_iterator tokens_end() const {
246     return ReplacementTokens + NumReplacementTokens;
247   }
tokens_empty()248   bool tokens_empty() const { return NumReplacementTokens == 0; }
tokens()249   ArrayRef<Token> tokens() const {
250     return llvm::ArrayRef(ReplacementTokens, NumReplacementTokens);
251   }
252 
253   llvm::MutableArrayRef<Token>
allocateTokens(unsigned NumTokens,llvm::BumpPtrAllocator & PPAllocator)254   allocateTokens(unsigned NumTokens, llvm::BumpPtrAllocator &PPAllocator) {
255     assert(ReplacementTokens == nullptr && NumReplacementTokens == 0 &&
256            "Token list already allocated!");
257     NumReplacementTokens = NumTokens;
258     Token *NewReplacementTokens = PPAllocator.Allocate<Token>(NumTokens);
259     ReplacementTokens = NewReplacementTokens;
260     return llvm::MutableArrayRef(NewReplacementTokens, NumTokens);
261   }
262 
setTokens(ArrayRef<Token> Tokens,llvm::BumpPtrAllocator & PPAllocator)263   void setTokens(ArrayRef<Token> Tokens, llvm::BumpPtrAllocator &PPAllocator) {
264     assert(
265         !IsDefinitionLengthCached &&
266         "Changing replacement tokens after definition length got calculated");
267     assert(ReplacementTokens == nullptr && NumReplacementTokens == 0 &&
268            "Token list already set!");
269     if (Tokens.empty())
270       return;
271 
272     NumReplacementTokens = Tokens.size();
273     Token *NewReplacementTokens = PPAllocator.Allocate<Token>(Tokens.size());
274     std::copy(Tokens.begin(), Tokens.end(), NewReplacementTokens);
275     ReplacementTokens = NewReplacementTokens;
276   }
277 
278   /// Return true if this macro is enabled.
279   ///
280   /// In other words, that we are not currently in an expansion of this macro.
isEnabled()281   bool isEnabled() const { return !IsDisabled; }
282 
EnableMacro()283   void EnableMacro() {
284     assert(IsDisabled && "Cannot enable an already-enabled macro!");
285     IsDisabled = false;
286   }
287 
DisableMacro()288   void DisableMacro() {
289     assert(!IsDisabled && "Cannot disable an already-disabled macro!");
290     IsDisabled = true;
291   }
292 
293   /// Determine whether this macro was used for a header guard.
isUsedForHeaderGuard()294   bool isUsedForHeaderGuard() const { return UsedForHeaderGuard; }
295 
setUsedForHeaderGuard(bool Val)296   void setUsedForHeaderGuard(bool Val) { UsedForHeaderGuard = Val; }
297 
298   void dump() const;
299 
300 private:
301   friend class Preprocessor;
302 
303   unsigned getDefinitionLengthSlow(const SourceManager &SM) const;
304 };
305 
306 /// Encapsulates changes to the "macros namespace" (the location where
307 /// the macro name became active, the location where it was undefined, etc.).
308 ///
309 /// MacroDirectives, associated with an identifier, are used to model the macro
310 /// history. Usually a macro definition (MacroInfo) is where a macro name
311 /// becomes active (MacroDirective) but #pragma push_macro / pop_macro can
312 /// create additional DefMacroDirectives for the same MacroInfo.
313 class MacroDirective {
314 public:
315   enum Kind {
316     MD_Define,
317     MD_Undefine,
318     MD_Visibility
319   };
320 
321 protected:
322   /// Previous macro directive for the same identifier, or nullptr.
323   MacroDirective *Previous = nullptr;
324 
325   SourceLocation Loc;
326 
327   /// MacroDirective kind.
328   unsigned MDKind : 2;
329 
330   /// True if the macro directive was loaded from a PCH file.
331   unsigned IsFromPCH : 1;
332 
333   // Used by VisibilityMacroDirective ----------------------------------------//
334 
335   /// Whether the macro has public visibility (when described in a
336   /// module).
337   unsigned IsPublic : 1;
338 
MacroDirective(Kind K,SourceLocation Loc)339   MacroDirective(Kind K, SourceLocation Loc)
340       : Loc(Loc), MDKind(K), IsFromPCH(false), IsPublic(true) {}
341 
342 public:
getKind()343   Kind getKind() const { return Kind(MDKind); }
344 
getLocation()345   SourceLocation getLocation() const { return Loc; }
346 
347   /// Set previous definition of the macro with the same name.
setPrevious(MacroDirective * Prev)348   void setPrevious(MacroDirective *Prev) { Previous = Prev; }
349 
350   /// Get previous definition of the macro with the same name.
getPrevious()351   const MacroDirective *getPrevious() const { return Previous; }
352 
353   /// Get previous definition of the macro with the same name.
getPrevious()354   MacroDirective *getPrevious() { return Previous; }
355 
356   /// Return true if the macro directive was loaded from a PCH file.
isFromPCH()357   bool isFromPCH() const { return IsFromPCH; }
358 
setIsFromPCH()359   void setIsFromPCH() { IsFromPCH = true; }
360 
361   class DefInfo {
362     DefMacroDirective *DefDirective = nullptr;
363     SourceLocation UndefLoc;
364     bool IsPublic = true;
365 
366   public:
367     DefInfo() = default;
DefInfo(DefMacroDirective * DefDirective,SourceLocation UndefLoc,bool isPublic)368     DefInfo(DefMacroDirective *DefDirective, SourceLocation UndefLoc,
369             bool isPublic)
370         : DefDirective(DefDirective), UndefLoc(UndefLoc), IsPublic(isPublic) {}
371 
getDirective()372     const DefMacroDirective *getDirective() const { return DefDirective; }
getDirective()373     DefMacroDirective *getDirective() { return DefDirective; }
374 
375     inline SourceLocation getLocation() const;
376     inline MacroInfo *getMacroInfo();
377 
getMacroInfo()378     const MacroInfo *getMacroInfo() const {
379       return const_cast<DefInfo *>(this)->getMacroInfo();
380     }
381 
getUndefLocation()382     SourceLocation getUndefLocation() const { return UndefLoc; }
isUndefined()383     bool isUndefined() const { return UndefLoc.isValid(); }
384 
isPublic()385     bool isPublic() const { return IsPublic; }
386 
isValid()387     bool isValid() const { return DefDirective != nullptr; }
isInvalid()388     bool isInvalid() const { return !isValid(); }
389 
390     explicit operator bool() const { return isValid(); }
391 
392     inline DefInfo getPreviousDefinition();
393 
getPreviousDefinition()394     const DefInfo getPreviousDefinition() const {
395       return const_cast<DefInfo *>(this)->getPreviousDefinition();
396     }
397   };
398 
399   /// Traverses the macro directives history and returns the next
400   /// macro definition directive along with info about its undefined location
401   /// (if there is one) and if it is public or private.
402   DefInfo getDefinition();
getDefinition()403   const DefInfo getDefinition() const {
404     return const_cast<MacroDirective *>(this)->getDefinition();
405   }
406 
isDefined()407   bool isDefined() const {
408     if (const DefInfo Def = getDefinition())
409       return !Def.isUndefined();
410     return false;
411   }
412 
getMacroInfo()413   const MacroInfo *getMacroInfo() const {
414     return getDefinition().getMacroInfo();
415   }
getMacroInfo()416   MacroInfo *getMacroInfo() { return getDefinition().getMacroInfo(); }
417 
418   /// Find macro definition active in the specified source location. If
419   /// this macro was not defined there, return NULL.
420   const DefInfo findDirectiveAtLoc(SourceLocation L,
421                                    const SourceManager &SM) const;
422 
423   void dump() const;
424 
classof(const MacroDirective *)425   static bool classof(const MacroDirective *) { return true; }
426 };
427 
428 /// A directive for a defined macro or a macro imported from a module.
429 class DefMacroDirective : public MacroDirective {
430   MacroInfo *Info;
431 
432 public:
DefMacroDirective(MacroInfo * MI,SourceLocation Loc)433   DefMacroDirective(MacroInfo *MI, SourceLocation Loc)
434       : MacroDirective(MD_Define, Loc), Info(MI) {
435     assert(MI && "MacroInfo is null");
436   }
DefMacroDirective(MacroInfo * MI)437   explicit DefMacroDirective(MacroInfo *MI)
438       : DefMacroDirective(MI, MI->getDefinitionLoc()) {}
439 
440   /// The data for the macro definition.
getInfo()441   const MacroInfo *getInfo() const { return Info; }
getInfo()442   MacroInfo *getInfo() { return Info; }
443 
classof(const MacroDirective * MD)444   static bool classof(const MacroDirective *MD) {
445     return MD->getKind() == MD_Define;
446   }
447 
classof(const DefMacroDirective *)448   static bool classof(const DefMacroDirective *) { return true; }
449 };
450 
451 /// A directive for an undefined macro.
452 class UndefMacroDirective : public MacroDirective {
453 public:
UndefMacroDirective(SourceLocation UndefLoc)454   explicit UndefMacroDirective(SourceLocation UndefLoc)
455       : MacroDirective(MD_Undefine, UndefLoc) {
456     assert(UndefLoc.isValid() && "Invalid UndefLoc!");
457   }
458 
classof(const MacroDirective * MD)459   static bool classof(const MacroDirective *MD) {
460     return MD->getKind() == MD_Undefine;
461   }
462 
classof(const UndefMacroDirective *)463   static bool classof(const UndefMacroDirective *) { return true; }
464 };
465 
466 /// A directive for setting the module visibility of a macro.
467 class VisibilityMacroDirective : public MacroDirective {
468 public:
VisibilityMacroDirective(SourceLocation Loc,bool Public)469   explicit VisibilityMacroDirective(SourceLocation Loc, bool Public)
470       : MacroDirective(MD_Visibility, Loc) {
471     IsPublic = Public;
472   }
473 
474   /// Determine whether this macro is part of the public API of its
475   /// module.
isPublic()476   bool isPublic() const { return IsPublic; }
477 
classof(const MacroDirective * MD)478   static bool classof(const MacroDirective *MD) {
479     return MD->getKind() == MD_Visibility;
480   }
481 
classof(const VisibilityMacroDirective *)482   static bool classof(const VisibilityMacroDirective *) { return true; }
483 };
484 
getLocation()485 inline SourceLocation MacroDirective::DefInfo::getLocation() const {
486   if (isInvalid())
487     return {};
488   return DefDirective->getLocation();
489 }
490 
getMacroInfo()491 inline MacroInfo *MacroDirective::DefInfo::getMacroInfo() {
492   if (isInvalid())
493     return nullptr;
494   return DefDirective->getInfo();
495 }
496 
497 inline MacroDirective::DefInfo
getPreviousDefinition()498 MacroDirective::DefInfo::getPreviousDefinition() {
499   if (isInvalid() || DefDirective->getPrevious() == nullptr)
500     return {};
501   return DefDirective->getPrevious()->getDefinition();
502 }
503 
504 /// Represents a macro directive exported by a module.
505 ///
506 /// There's an instance of this class for every macro #define or #undef that is
507 /// the final directive for a macro name within a module. These entities also
508 /// represent the macro override graph.
509 ///
510 /// These are stored in a FoldingSet in the preprocessor.
511 class ModuleMacro : public llvm::FoldingSetNode {
512   friend class Preprocessor;
513 
514   /// The name defined by the macro.
515   IdentifierInfo *II;
516 
517   /// The body of the #define, or nullptr if this is a #undef.
518   MacroInfo *Macro;
519 
520   /// The module that exports this macro.
521   Module *OwningModule;
522 
523   /// The number of module macros that override this one.
524   unsigned NumOverriddenBy = 0;
525 
526   /// The number of modules whose macros are directly overridden by this one.
527   unsigned NumOverrides;
528 
ModuleMacro(Module * OwningModule,IdentifierInfo * II,MacroInfo * Macro,ArrayRef<ModuleMacro * > Overrides)529   ModuleMacro(Module *OwningModule, IdentifierInfo *II, MacroInfo *Macro,
530               ArrayRef<ModuleMacro *> Overrides)
531       : II(II), Macro(Macro), OwningModule(OwningModule),
532         NumOverrides(Overrides.size()) {
533     std::copy(Overrides.begin(), Overrides.end(),
534               reinterpret_cast<ModuleMacro **>(this + 1));
535   }
536 
537 public:
538   static ModuleMacro *create(Preprocessor &PP, Module *OwningModule,
539                              IdentifierInfo *II, MacroInfo *Macro,
540                              ArrayRef<ModuleMacro *> Overrides);
541 
Profile(llvm::FoldingSetNodeID & ID)542   void Profile(llvm::FoldingSetNodeID &ID) const {
543     return Profile(ID, OwningModule, II);
544   }
545 
Profile(llvm::FoldingSetNodeID & ID,Module * OwningModule,const IdentifierInfo * II)546   static void Profile(llvm::FoldingSetNodeID &ID, Module *OwningModule,
547                       const IdentifierInfo *II) {
548     ID.AddPointer(OwningModule);
549     ID.AddPointer(II);
550   }
551 
552   /// Get the name of the macro.
getName()553   IdentifierInfo *getName() const { return II; }
554 
555   /// Get the ID of the module that exports this macro.
getOwningModule()556   Module *getOwningModule() const { return OwningModule; }
557 
558   /// Get definition for this exported #define, or nullptr if this
559   /// represents a #undef.
getMacroInfo()560   MacroInfo *getMacroInfo() const { return Macro; }
561 
562   /// Iterators over the overridden module IDs.
563   /// \{
564   using overrides_iterator = ModuleMacro *const *;
565 
overrides_begin()566   overrides_iterator overrides_begin() const {
567     return reinterpret_cast<overrides_iterator>(this + 1);
568   }
569 
overrides_end()570   overrides_iterator overrides_end() const {
571     return overrides_begin() + NumOverrides;
572   }
573 
overrides()574   ArrayRef<ModuleMacro *> overrides() const {
575     return llvm::ArrayRef(overrides_begin(), overrides_end());
576   }
577   /// \}
578 
579   /// Get the number of macros that override this one.
getNumOverridingMacros()580   unsigned getNumOverridingMacros() const { return NumOverriddenBy; }
581 };
582 
583 /// A description of the current definition of a macro.
584 ///
585 /// The definition of a macro comprises a set of (at least one) defining
586 /// entities, which are either local MacroDirectives or imported ModuleMacros.
587 class MacroDefinition {
588   llvm::PointerIntPair<DefMacroDirective *, 1, bool> LatestLocalAndAmbiguous;
589   ArrayRef<ModuleMacro *> ModuleMacros;
590 
591 public:
592   MacroDefinition() = default;
MacroDefinition(DefMacroDirective * MD,ArrayRef<ModuleMacro * > MMs,bool IsAmbiguous)593   MacroDefinition(DefMacroDirective *MD, ArrayRef<ModuleMacro *> MMs,
594                   bool IsAmbiguous)
595       : LatestLocalAndAmbiguous(MD, IsAmbiguous), ModuleMacros(MMs) {}
596 
597   /// Determine whether there is a definition of this macro.
598   explicit operator bool() const {
599     return getLocalDirective() || !ModuleMacros.empty();
600   }
601 
602   /// Get the MacroInfo that should be used for this definition.
getMacroInfo()603   MacroInfo *getMacroInfo() const {
604     if (!ModuleMacros.empty())
605       return ModuleMacros.back()->getMacroInfo();
606     if (auto *MD = getLocalDirective())
607       return MD->getMacroInfo();
608     return nullptr;
609   }
610 
611   /// \c true if the definition is ambiguous, \c false otherwise.
isAmbiguous()612   bool isAmbiguous() const { return LatestLocalAndAmbiguous.getInt(); }
613 
614   /// Get the latest non-imported, non-\#undef'd macro definition
615   /// for this macro.
getLocalDirective()616   DefMacroDirective *getLocalDirective() const {
617     return LatestLocalAndAmbiguous.getPointer();
618   }
619 
620   /// Get the active module macros for this macro.
getModuleMacros()621   ArrayRef<ModuleMacro *> getModuleMacros() const { return ModuleMacros; }
622 
forAllDefinitions(Fn F)623   template <typename Fn> void forAllDefinitions(Fn F) const {
624     if (auto *MD = getLocalDirective())
625       F(MD->getMacroInfo());
626     for (auto *MM : getModuleMacros())
627       F(MM->getMacroInfo());
628   }
629 };
630 
631 } // namespace clang
632 
633 #endif // LLVM_CLANG_LEX_MACROINFO_H
634