contrib/llvm/tools/clang/include/clang/Lex/MacroInfo.h

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