clang/lib/Lex/MacroInfo.cpp

   1 //===- MacroInfo.cpp - Information about #defined identifiers -------------===//
   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 // This file implements the MacroInfo interface.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "clang/Lex/MacroInfo.h"
  14 #include "clang/Basic/IdentifierTable.h"
  15 #include "clang/Basic/LLVM.h"
  16 #include "clang/Basic/SourceLocation.h"
  17 #include "clang/Basic/SourceManager.h"
  18 #include "clang/Basic/TokenKinds.h"
  19 #include "clang/Lex/Preprocessor.h"
  20 #include "clang/Lex/Token.h"
  21 #include "llvm/ADT/StringRef.h"
  22 #include "llvm/Support/Casting.h"
  23 #include "llvm/Support/Compiler.h"
  24 #include "llvm/Support/raw_ostream.h"
  25 #include <cassert>
  26 #include <optional>
  27 #include <utility>
  28
  29 using namespace clang;
  30
  31 namespace {
  32
  33 // MacroInfo is expected to take 40 bytes on platforms with an 8 byte pointer
  34 // and 4 byte SourceLocation.
  35 template <int> class MacroInfoSizeChecker {
  36 public:
  37   [[maybe_unused]] constexpr static bool AsExpected = true;
  38 };
  39 template <> class MacroInfoSizeChecker<8> {
  40 public:
  41   [[maybe_unused]] constexpr static bool AsExpected =
  42       sizeof(MacroInfo) == (32 + sizeof(SourceLocation) * 2);
  43 };
  44
  45 static_assert(MacroInfoSizeChecker<sizeof(void *)>::AsExpected,
  46               "Unexpected size of MacroInfo");
  47
  48 } // end namespace
  49
  50 MacroInfo::MacroInfo(SourceLocation DefLoc)
  51     : Location(DefLoc), IsDefinitionLengthCached(false), IsFunctionLike(false),
  52       IsC99Varargs(false), IsGNUVarargs(false), IsBuiltinMacro(false),
  53       HasCommaPasting(false), IsDisabled(false), IsUsed(false),
  54       IsAllowRedefinitionsWithoutWarning(false), IsWarnIfUnused(false),
  55       UsedForHeaderGuard(false) {}
  56
  57 unsigned MacroInfo::getDefinitionLengthSlow(const SourceManager &SM) const {
  58   assert(!IsDefinitionLengthCached);
  59   IsDefinitionLengthCached = true;
  60
  61   ArrayRef<Token> ReplacementTokens = tokens();
  62   if (ReplacementTokens.empty())
  63     return (DefinitionLength = 0);
  64
  65   const Token &firstToken = ReplacementTokens.front();
  66   const Token &lastToken = ReplacementTokens.back();
  67   SourceLocation macroStart = firstToken.getLocation();
  68   SourceLocation macroEnd = lastToken.getLocation();
  69   assert(macroStart.isValid() && macroEnd.isValid());
  70   assert((macroStart.isFileID() || firstToken.is(tok::comment)) &&
  71          "Macro defined in macro?");
  72   assert((macroEnd.isFileID() || lastToken.is(tok::comment)) &&
  73          "Macro defined in macro?");
  74   std::pair<FileID, unsigned>
  75       startInfo = SM.getDecomposedExpansionLoc(macroStart);
  76   std::pair<FileID, unsigned>
  77       endInfo = SM.getDecomposedExpansionLoc(macroEnd);
  78   assert(startInfo.first == endInfo.first &&
  79          "Macro definition spanning multiple FileIDs ?");
  80   assert(startInfo.second <= endInfo.second);
  81   DefinitionLength = endInfo.second - startInfo.second;
  82   DefinitionLength += lastToken.getLength();
  83
  84   return DefinitionLength;
  85 }
  86
  87 /// Return true if the specified macro definition is equal to
  88 /// this macro in spelling, arguments, and whitespace.
  89 ///
  90 /// \param Syntactically if true, the macro definitions can be identical even
  91 /// if they use different identifiers for the function macro parameters.
  92 /// Otherwise the comparison is lexical and this implements the rules in
  93 /// C99 6.10.3.
  94 bool MacroInfo::isIdenticalTo(const MacroInfo &Other, Preprocessor &PP,
  95                               bool Syntactically) const {
  96   bool Lexically = !Syntactically;
  97
  98   // Check # tokens in replacement, number of args, and various flags all match.
  99   if (getNumTokens() != Other.getNumTokens() ||
 100       getNumParams() != Other.getNumParams() ||
 101       isFunctionLike() != Other.isFunctionLike() ||
 102       isC99Varargs() != Other.isC99Varargs() ||
 103       isGNUVarargs() != Other.isGNUVarargs())
 104     return false;
 105
 106   if (Lexically) {
 107     // Check arguments.
 108     for (param_iterator I = param_begin(), OI = Other.param_begin(),
 109                         E = param_end();
 110          I != E; ++I, ++OI)
 111       if (*I != *OI) return false;
 112   }
 113
 114   // Check all the tokens.
 115   for (unsigned i = 0; i != NumReplacementTokens; ++i) {
 116     const Token &A = ReplacementTokens[i];
 117     const Token &B = Other.ReplacementTokens[i];
 118     if (A.getKind() != B.getKind())
 119       return false;
 120
 121     // If this isn't the first token, check that the whitespace and
 122     // start-of-line characteristics match.
 123     if (i != 0 &&
 124         (A.isAtStartOfLine() != B.isAtStartOfLine() ||
 125          A.hasLeadingSpace() != B.hasLeadingSpace()))
 126       return false;
 127
 128     // If this is an identifier, it is easy.
 129     if (A.getIdentifierInfo() || B.getIdentifierInfo()) {
 130       if (A.getIdentifierInfo() == B.getIdentifierInfo())
 131         continue;
 132       if (Lexically)
 133         return false;
 134       // With syntactic equivalence the parameter names can be different as long
 135       // as they are used in the same place.
 136       int AArgNum = getParameterNum(A.getIdentifierInfo());
 137       if (AArgNum == -1)
 138         return false;
 139       if (AArgNum != Other.getParameterNum(B.getIdentifierInfo()))
 140         return false;
 141       continue;
 142     }
 143
 144     // Otherwise, check the spelling.
 145     if (PP.getSpelling(A) != PP.getSpelling(B))
 146       return false;
 147   }
 148
 149   return true;
 150 }
 151
 152 LLVM_DUMP_METHOD void MacroInfo::dump() const {
 153   llvm::raw_ostream &Out = llvm::errs();
 154
 155   // FIXME: Dump locations.
 156   Out << "MacroInfo " << this;
 157   if (IsBuiltinMacro) Out << " builtin";
 158   if (IsDisabled) Out << " disabled";
 159   if (IsUsed) Out << " used";
 160   if (IsAllowRedefinitionsWithoutWarning)
 161     Out << " allow_redefinitions_without_warning";
 162   if (IsWarnIfUnused) Out << " warn_if_unused";
 163   if (UsedForHeaderGuard) Out << " header_guard";
 164
 165   Out << "\n    #define <macro>";
 166   if (IsFunctionLike) {
 167     Out << "(";
 168     for (unsigned I = 0; I != NumParameters; ++I) {
 169       if (I) Out << ", ";
 170       Out << ParameterList[I]->getName();
 171     }
 172     if (IsC99Varargs || IsGNUVarargs) {
 173       if (NumParameters && IsC99Varargs) Out << ", ";
 174       Out << "...";
 175     }
 176     Out << ")";
 177   }
 178
 179   bool First = true;
 180   for (const Token &Tok : tokens()) {
 181     // Leading space is semantically meaningful in a macro definition,
 182     // so preserve it in the dump output.
 183     if (First || Tok.hasLeadingSpace())
 184       Out << " ";
 185     First = false;
 186
 187     if (const char *Punc = tok::getPunctuatorSpelling(Tok.getKind()))
 188       Out << Punc;
 189     else if (Tok.isLiteral() && Tok.getLiteralData())
 190       Out << StringRef(Tok.getLiteralData(), Tok.getLength());
 191     else if (auto *II = Tok.getIdentifierInfo())
 192       Out << II->getName();
 193     else
 194       Out << Tok.getName();
 195   }
 196 }
 197
 198 MacroDirective::DefInfo MacroDirective::getDefinition() {
 199   MacroDirective *MD = this;
 200   SourceLocation UndefLoc;
 201   std::optional<bool> isPublic;
 202   for (; MD; MD = MD->getPrevious()) {
 203     if (DefMacroDirective *DefMD = dyn_cast<DefMacroDirective>(MD))
 204       return DefInfo(DefMD, UndefLoc, !isPublic || *isPublic);
 205
 206     if (UndefMacroDirective *UndefMD = dyn_cast<UndefMacroDirective>(MD)) {
 207       UndefLoc = UndefMD->getLocation();
 208       continue;
 209     }
 210
 211     VisibilityMacroDirective *VisMD = cast<VisibilityMacroDirective>(MD);
 212     if (!isPublic)
 213       isPublic = VisMD->isPublic();
 214   }
 215
 216   return DefInfo(nullptr, UndefLoc, !isPublic || *isPublic);
 217 }
 218
 219 const MacroDirective::DefInfo
 220 MacroDirective::findDirectiveAtLoc(SourceLocation L,
 221                                    const SourceManager &SM) const {
 222   assert(L.isValid() && "SourceLocation is invalid.");
 223   for (DefInfo Def = getDefinition(); Def; Def = Def.getPreviousDefinition()) {
 224     if (Def.getLocation().isInvalid() ||  // For macros defined on the command line.
 225         SM.isBeforeInTranslationUnit(Def.getLocation(), L))
 226       return (!Def.isUndefined() ||
 227               SM.isBeforeInTranslationUnit(L, Def.getUndefLocation()))
 228                   ? Def : DefInfo();
 229   }
 230   return DefInfo();
 231 }
 232
 233 LLVM_DUMP_METHOD void MacroDirective::dump() const {
 234   llvm::raw_ostream &Out = llvm::errs();
 235
 236   switch (getKind()) {
 237   case MD_Define: Out << "DefMacroDirective"; break;
 238   case MD_Undefine: Out << "UndefMacroDirective"; break;
 239   case MD_Visibility: Out << "VisibilityMacroDirective"; break;
 240   }
 241   Out << " " << this;
 242   // FIXME: Dump SourceLocation.
 243   if (auto *Prev = getPrevious())
 244     Out << " prev " << Prev;
 245   if (IsFromPCH) Out << " from_pch";
 246
 247   if (isa<VisibilityMacroDirective>(this))
 248     Out << (IsPublic ? " public" : " private");
 249
 250   if (auto *DMD = dyn_cast<DefMacroDirective>(this)) {
 251     if (auto *Info = DMD->getInfo()) {
 252       Out << "\n  ";
 253       Info->dump();
 254     }
 255   }
 256   Out << "\n";
 257 }
 258
 259 ModuleMacro *ModuleMacro::create(Preprocessor &PP, Module *OwningModule,
 260                                  IdentifierInfo *II, MacroInfo *Macro,
 261                                  ArrayRef<ModuleMacro *> Overrides) {
 262   void *Mem = PP.getPreprocessorAllocator().Allocate(
 263       sizeof(ModuleMacro) + sizeof(ModuleMacro *) * Overrides.size(),
 264       alignof(ModuleMacro));
 265   return new (Mem) ModuleMacro(OwningModule, II, Macro, Overrides);
 266 }