You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
249 lines
8.5 KiB
249 lines
8.5 KiB
//===- MacroInfo.cpp - Information about #defined identifiers -------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the MacroInfo interface.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/Lex/MacroInfo.h"
|
|
#include "clang/Basic/IdentifierTable.h"
|
|
#include "clang/Basic/LLVM.h"
|
|
#include "clang/Basic/SourceLocation.h"
|
|
#include "clang/Basic/SourceManager.h"
|
|
#include "clang/Basic/TokenKinds.h"
|
|
#include "clang/Lex/Preprocessor.h"
|
|
#include "clang/Lex/Token.h"
|
|
#include "llvm/ADT/Optional.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/Support/Casting.h"
|
|
#include "llvm/Support/Compiler.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include <cassert>
|
|
#include <utility>
|
|
|
|
using namespace clang;
|
|
|
|
MacroInfo::MacroInfo(SourceLocation DefLoc)
|
|
: Location(DefLoc), IsDefinitionLengthCached(false), IsFunctionLike(false),
|
|
IsC99Varargs(false), IsGNUVarargs(false), IsBuiltinMacro(false),
|
|
HasCommaPasting(false), IsDisabled(false), IsUsed(false),
|
|
IsAllowRedefinitionsWithoutWarning(false), IsWarnIfUnused(false),
|
|
UsedForHeaderGuard(false) {}
|
|
|
|
unsigned MacroInfo::getDefinitionLengthSlow(const SourceManager &SM) const {
|
|
assert(!IsDefinitionLengthCached);
|
|
IsDefinitionLengthCached = true;
|
|
|
|
if (ReplacementTokens.empty())
|
|
return (DefinitionLength = 0);
|
|
|
|
const Token &firstToken = ReplacementTokens.front();
|
|
const Token &lastToken = ReplacementTokens.back();
|
|
SourceLocation macroStart = firstToken.getLocation();
|
|
SourceLocation macroEnd = lastToken.getLocation();
|
|
assert(macroStart.isValid() && macroEnd.isValid());
|
|
assert((macroStart.isFileID() || firstToken.is(tok::comment)) &&
|
|
"Macro defined in macro?");
|
|
assert((macroEnd.isFileID() || lastToken.is(tok::comment)) &&
|
|
"Macro defined in macro?");
|
|
std::pair<FileID, unsigned>
|
|
startInfo = SM.getDecomposedExpansionLoc(macroStart);
|
|
std::pair<FileID, unsigned>
|
|
endInfo = SM.getDecomposedExpansionLoc(macroEnd);
|
|
assert(startInfo.first == endInfo.first &&
|
|
"Macro definition spanning multiple FileIDs ?");
|
|
assert(startInfo.second <= endInfo.second);
|
|
DefinitionLength = endInfo.second - startInfo.second;
|
|
DefinitionLength += lastToken.getLength();
|
|
|
|
return DefinitionLength;
|
|
}
|
|
|
|
/// Return true if the specified macro definition is equal to
|
|
/// this macro in spelling, arguments, and whitespace.
|
|
///
|
|
/// \param Syntactically if true, the macro definitions can be identical even
|
|
/// if they use different identifiers for the function macro parameters.
|
|
/// Otherwise the comparison is lexical and this implements the rules in
|
|
/// C99 6.10.3.
|
|
bool MacroInfo::isIdenticalTo(const MacroInfo &Other, Preprocessor &PP,
|
|
bool Syntactically) const {
|
|
bool Lexically = !Syntactically;
|
|
|
|
// Check # tokens in replacement, number of args, and various flags all match.
|
|
if (ReplacementTokens.size() != Other.ReplacementTokens.size() ||
|
|
getNumParams() != Other.getNumParams() ||
|
|
isFunctionLike() != Other.isFunctionLike() ||
|
|
isC99Varargs() != Other.isC99Varargs() ||
|
|
isGNUVarargs() != Other.isGNUVarargs())
|
|
return false;
|
|
|
|
if (Lexically) {
|
|
// Check arguments.
|
|
for (param_iterator I = param_begin(), OI = Other.param_begin(),
|
|
E = param_end();
|
|
I != E; ++I, ++OI)
|
|
if (*I != *OI) return false;
|
|
}
|
|
|
|
// Check all the tokens.
|
|
for (unsigned i = 0, e = ReplacementTokens.size(); i != e; ++i) {
|
|
const Token &A = ReplacementTokens[i];
|
|
const Token &B = Other.ReplacementTokens[i];
|
|
if (A.getKind() != B.getKind())
|
|
return false;
|
|
|
|
// If this isn't the first first token, check that the whitespace and
|
|
// start-of-line characteristics match.
|
|
if (i != 0 &&
|
|
(A.isAtStartOfLine() != B.isAtStartOfLine() ||
|
|
A.hasLeadingSpace() != B.hasLeadingSpace()))
|
|
return false;
|
|
|
|
// If this is an identifier, it is easy.
|
|
if (A.getIdentifierInfo() || B.getIdentifierInfo()) {
|
|
if (A.getIdentifierInfo() == B.getIdentifierInfo())
|
|
continue;
|
|
if (Lexically)
|
|
return false;
|
|
// With syntactic equivalence the parameter names can be different as long
|
|
// as they are used in the same place.
|
|
int AArgNum = getParameterNum(A.getIdentifierInfo());
|
|
if (AArgNum == -1)
|
|
return false;
|
|
if (AArgNum != Other.getParameterNum(B.getIdentifierInfo()))
|
|
return false;
|
|
continue;
|
|
}
|
|
|
|
// Otherwise, check the spelling.
|
|
if (PP.getSpelling(A) != PP.getSpelling(B))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
LLVM_DUMP_METHOD void MacroInfo::dump() const {
|
|
llvm::raw_ostream &Out = llvm::errs();
|
|
|
|
// FIXME: Dump locations.
|
|
Out << "MacroInfo " << this;
|
|
if (IsBuiltinMacro) Out << " builtin";
|
|
if (IsDisabled) Out << " disabled";
|
|
if (IsUsed) Out << " used";
|
|
if (IsAllowRedefinitionsWithoutWarning)
|
|
Out << " allow_redefinitions_without_warning";
|
|
if (IsWarnIfUnused) Out << " warn_if_unused";
|
|
if (UsedForHeaderGuard) Out << " header_guard";
|
|
|
|
Out << "\n #define <macro>";
|
|
if (IsFunctionLike) {
|
|
Out << "(";
|
|
for (unsigned I = 0; I != NumParameters; ++I) {
|
|
if (I) Out << ", ";
|
|
Out << ParameterList[I]->getName();
|
|
}
|
|
if (IsC99Varargs || IsGNUVarargs) {
|
|
if (NumParameters && IsC99Varargs) Out << ", ";
|
|
Out << "...";
|
|
}
|
|
Out << ")";
|
|
}
|
|
|
|
bool First = true;
|
|
for (const Token &Tok : ReplacementTokens) {
|
|
// Leading space is semantically meaningful in a macro definition,
|
|
// so preserve it in the dump output.
|
|
if (First || Tok.hasLeadingSpace())
|
|
Out << " ";
|
|
First = false;
|
|
|
|
if (const char *Punc = tok::getPunctuatorSpelling(Tok.getKind()))
|
|
Out << Punc;
|
|
else if (Tok.isLiteral() && Tok.getLiteralData())
|
|
Out << StringRef(Tok.getLiteralData(), Tok.getLength());
|
|
else if (auto *II = Tok.getIdentifierInfo())
|
|
Out << II->getName();
|
|
else
|
|
Out << Tok.getName();
|
|
}
|
|
}
|
|
|
|
MacroDirective::DefInfo MacroDirective::getDefinition() {
|
|
MacroDirective *MD = this;
|
|
SourceLocation UndefLoc;
|
|
Optional<bool> isPublic;
|
|
for (; MD; MD = MD->getPrevious()) {
|
|
if (DefMacroDirective *DefMD = dyn_cast<DefMacroDirective>(MD))
|
|
return DefInfo(DefMD, UndefLoc,
|
|
!isPublic.hasValue() || isPublic.getValue());
|
|
|
|
if (UndefMacroDirective *UndefMD = dyn_cast<UndefMacroDirective>(MD)) {
|
|
UndefLoc = UndefMD->getLocation();
|
|
continue;
|
|
}
|
|
|
|
VisibilityMacroDirective *VisMD = cast<VisibilityMacroDirective>(MD);
|
|
if (!isPublic.hasValue())
|
|
isPublic = VisMD->isPublic();
|
|
}
|
|
|
|
return DefInfo(nullptr, UndefLoc,
|
|
!isPublic.hasValue() || isPublic.getValue());
|
|
}
|
|
|
|
const MacroDirective::DefInfo
|
|
MacroDirective::findDirectiveAtLoc(SourceLocation L,
|
|
const SourceManager &SM) const {
|
|
assert(L.isValid() && "SourceLocation is invalid.");
|
|
for (DefInfo Def = getDefinition(); Def; Def = Def.getPreviousDefinition()) {
|
|
if (Def.getLocation().isInvalid() || // For macros defined on the command line.
|
|
SM.isBeforeInTranslationUnit(Def.getLocation(), L))
|
|
return (!Def.isUndefined() ||
|
|
SM.isBeforeInTranslationUnit(L, Def.getUndefLocation()))
|
|
? Def : DefInfo();
|
|
}
|
|
return DefInfo();
|
|
}
|
|
|
|
LLVM_DUMP_METHOD void MacroDirective::dump() const {
|
|
llvm::raw_ostream &Out = llvm::errs();
|
|
|
|
switch (getKind()) {
|
|
case MD_Define: Out << "DefMacroDirective"; break;
|
|
case MD_Undefine: Out << "UndefMacroDirective"; break;
|
|
case MD_Visibility: Out << "VisibilityMacroDirective"; break;
|
|
}
|
|
Out << " " << this;
|
|
// FIXME: Dump SourceLocation.
|
|
if (auto *Prev = getPrevious())
|
|
Out << " prev " << Prev;
|
|
if (IsFromPCH) Out << " from_pch";
|
|
|
|
if (isa<VisibilityMacroDirective>(this))
|
|
Out << (IsPublic ? " public" : " private");
|
|
|
|
if (auto *DMD = dyn_cast<DefMacroDirective>(this)) {
|
|
if (auto *Info = DMD->getInfo()) {
|
|
Out << "\n ";
|
|
Info->dump();
|
|
}
|
|
}
|
|
Out << "\n";
|
|
}
|
|
|
|
ModuleMacro *ModuleMacro::create(Preprocessor &PP, Module *OwningModule,
|
|
IdentifierInfo *II, MacroInfo *Macro,
|
|
ArrayRef<ModuleMacro *> Overrides) {
|
|
void *Mem = PP.getPreprocessorAllocator().Allocate(
|
|
sizeof(ModuleMacro) + sizeof(ModuleMacro *) * Overrides.size(),
|
|
alignof(ModuleMacro));
|
|
return new (Mem) ModuleMacro(OwningModule, II, Macro, Overrides);
|
|
}
|