lib/Lex/MacroInfo.cpp

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