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
MacroInfo(SourceLocation DefLoc)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
getDefinitionLengthSlow(const SourceManager & SM) const57 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.
isIdenticalTo(const MacroInfo & Other,Preprocessor & PP,bool Syntactically) const94 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
dump() const152 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
getDefinition()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
findDirectiveAtLoc(SourceLocation L,const SourceManager & SM) const220 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
dump() const233 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
create(Preprocessor & PP,Module * OwningModule,const IdentifierInfo * II,MacroInfo * Macro,ArrayRef<ModuleMacro * > Overrides)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