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 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 36 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. 72 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 129 LLVM_DUMP_METHOD 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 bool First = true; 158 for (const Token &Tok : ReplacementTokens) { 159 // Leading space is semantically meaningful in a macro definition, 160 // so preserve it in the dump output. 161 if (First || Tok.hasLeadingSpace()) 162 Out << " "; 163 First = false; 164 165 if (const char *Punc = tok::getPunctuatorSpelling(Tok.getKind())) 166 Out << Punc; 167 else if (Tok.isLiteral() && Tok.getLiteralData()) 168 Out << StringRef(Tok.getLiteralData(), Tok.getLength()); 169 else if (auto *II = Tok.getIdentifierInfo()) 170 Out << II->getName(); 171 else 172 Out << Tok.getName(); 173 } 174 } 175 176 MacroDirective::DefInfo MacroDirective::getDefinition() { 177 MacroDirective *MD = this; 178 SourceLocation UndefLoc; 179 Optional<bool> isPublic; 180 for (; MD; MD = MD->getPrevious()) { 181 if (DefMacroDirective *DefMD = dyn_cast<DefMacroDirective>(MD)) 182 return DefInfo(DefMD, UndefLoc, 183 !isPublic.hasValue() || isPublic.getValue()); 184 185 if (UndefMacroDirective *UndefMD = dyn_cast<UndefMacroDirective>(MD)) { 186 UndefLoc = UndefMD->getLocation(); 187 continue; 188 } 189 190 VisibilityMacroDirective *VisMD = cast<VisibilityMacroDirective>(MD); 191 if (!isPublic.hasValue()) 192 isPublic = VisMD->isPublic(); 193 } 194 195 return DefInfo(nullptr, UndefLoc, 196 !isPublic.hasValue() || isPublic.getValue()); 197 } 198 199 const MacroDirective::DefInfo 200 MacroDirective::findDirectiveAtLoc(SourceLocation L, SourceManager &SM) const { 201 assert(L.isValid() && "SourceLocation is invalid."); 202 for (DefInfo Def = getDefinition(); Def; Def = Def.getPreviousDefinition()) { 203 if (Def.getLocation().isInvalid() || // For macros defined on the command line. 204 SM.isBeforeInTranslationUnit(Def.getLocation(), L)) 205 return (!Def.isUndefined() || 206 SM.isBeforeInTranslationUnit(L, Def.getUndefLocation())) 207 ? Def : DefInfo(); 208 } 209 return DefInfo(); 210 } 211 212 LLVM_DUMP_METHOD void MacroDirective::dump() const { 213 llvm::raw_ostream &Out = llvm::errs(); 214 215 switch (getKind()) { 216 case MD_Define: Out << "DefMacroDirective"; break; 217 case MD_Undefine: Out << "UndefMacroDirective"; break; 218 case MD_Visibility: Out << "VisibilityMacroDirective"; break; 219 } 220 Out << " " << this; 221 // FIXME: Dump SourceLocation. 222 if (auto *Prev = getPrevious()) 223 Out << " prev " << Prev; 224 if (IsFromPCH) Out << " from_pch"; 225 226 if (isa<VisibilityMacroDirective>(this)) 227 Out << (IsPublic ? " public" : " 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 238 ModuleMacro *ModuleMacro::create(Preprocessor &PP, Module *OwningModule, 239 IdentifierInfo *II, MacroInfo *Macro, 240 ArrayRef<ModuleMacro *> Overrides) { 241 void *Mem = PP.getPreprocessorAllocator().Allocate( 242 sizeof(ModuleMacro) + sizeof(ModuleMacro *) * Overrides.size(), 243 llvm::alignOf<ModuleMacro>()); 244 return new (Mem) ModuleMacro(OwningModule, II, Macro, Overrides); 245 } 246
