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"
16 using namespace clang;
17
MacroInfo(SourceLocation DefLoc)18 MacroInfo::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
getDefinitionLengthSlow(SourceManager & SM) const36 unsigned 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.
isIdenticalTo(const MacroInfo & Other,Preprocessor & PP,bool Syntactically) const72 bool 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
dump() const129 void 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 for (const Token &Tok : ReplacementTokens) {
158 Out << " ";
159 if (const char *Punc = tok::getPunctuatorSpelling(Tok.getKind()))
160 Out << Punc;
161 else if (const char *Kwd = tok::getKeywordSpelling(Tok.getKind()))
162 Out << Kwd;
163 else if (Tok.is(tok::identifier))
164 Out << Tok.getIdentifierInfo()->getName();
165 else if (Tok.isLiteral() && Tok.getLiteralData())
166 Out << StringRef(Tok.getLiteralData(), Tok.getLength());
167 else
168 Out << Tok.getName();
169 }
170 }
171
getDefinition()172 MacroDirective::DefInfo MacroDirective::getDefinition() {
173 MacroDirective *MD = this;
174 SourceLocation UndefLoc;
175 Optional<bool> isPublic;
176 for (; MD; MD = MD->getPrevious()) {
177 if (DefMacroDirective *DefMD = dyn_cast<DefMacroDirective>(MD))
178 return DefInfo(DefMD, UndefLoc,
179 !isPublic.hasValue() || isPublic.getValue());
180
181 if (UndefMacroDirective *UndefMD = dyn_cast<UndefMacroDirective>(MD)) {
182 UndefLoc = UndefMD->getLocation();
183 continue;
184 }
185
186 VisibilityMacroDirective *VisMD = cast<VisibilityMacroDirective>(MD);
187 if (!isPublic.hasValue())
188 isPublic = VisMD->isPublic();
189 }
190
191 return DefInfo(nullptr, UndefLoc,
192 !isPublic.hasValue() || isPublic.getValue());
193 }
194
195 const MacroDirective::DefInfo
findDirectiveAtLoc(SourceLocation L,SourceManager & SM) const196 MacroDirective::findDirectiveAtLoc(SourceLocation L, SourceManager &SM) const {
197 assert(L.isValid() && "SourceLocation is invalid.");
198 for (DefInfo Def = getDefinition(); Def; Def = Def.getPreviousDefinition()) {
199 if (Def.getLocation().isInvalid() || // For macros defined on the command line.
200 SM.isBeforeInTranslationUnit(Def.getLocation(), L))
201 return (!Def.isUndefined() ||
202 SM.isBeforeInTranslationUnit(L, Def.getUndefLocation()))
203 ? Def : DefInfo();
204 }
205 return DefInfo();
206 }
207
dump() const208 void MacroDirective::dump() const {
209 llvm::raw_ostream &Out = llvm::errs();
210
211 switch (getKind()) {
212 case MD_Define: Out << "DefMacroDirective"; break;
213 case MD_Undefine: Out << "UndefMacroDirective"; break;
214 case MD_Visibility: Out << "VisibilityMacroDirective"; break;
215 }
216 Out << " " << this;
217 // FIXME: Dump SourceLocation.
218 if (auto *Prev = getPrevious())
219 Out << " prev " << Prev;
220 if (IsFromPCH) Out << " from_pch";
221 if (IsImported) Out << " imported";
222 if (IsAmbiguous) Out << " ambiguous";
223
224 if (IsPublic)
225 Out << " public";
226 else if (isa<VisibilityMacroDirective>(this))
227 Out << " 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