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