llvm-project

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
                                 const 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
}
267