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 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