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