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 
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   constexpr static bool AsExpected = true;
38 };
39 template <> class MacroInfoSizeChecker<8> {
40 public:
41   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 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   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.value());
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                                  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