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