blob: a59a8278682b23a25f7344020ef1e12d144b247c [file] [log] [blame]
//===--- PPCallbacksTracker.cpp - Preprocessor tracker -*--*---------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
///
/// \file
/// Implementations for preprocessor tracking.
///
/// See the header for details.
///
//===----------------------------------------------------------------------===//
#include "PPCallbacksTracker.h"
#include "clang/Basic/FileManager.h"
#include "clang/Lex/MacroArgs.h"
#include "llvm/Support/raw_ostream.h"
namespace clang {
namespace pp_trace {
// Get a "file:line:column" source location string.
static std::string getSourceLocationString(Preprocessor &PP,
SourceLocation Loc) {
if (Loc.isInvalid())
return std::string("(none)");
if (Loc.isFileID()) {
PresumedLoc PLoc = PP.getSourceManager().getPresumedLoc(Loc);
if (PLoc.isInvalid()) {
return std::string("(invalid)");
}
std::string Str;
llvm::raw_string_ostream SS(Str);
// The macro expansion and spelling pos is identical for file locs.
SS << "\"" << PLoc.getFilename() << ':' << PLoc.getLine() << ':'
<< PLoc.getColumn() << "\"";
std::string Result = SS.str();
// YAML treats backslash as escape, so use forward slashes.
std::replace(Result.begin(), Result.end(), '\\', '/');
return Result;
}
return std::string("(nonfile)");
}
// Enum string tables.
// FileChangeReason strings.
static const char *const FileChangeReasonStrings[] = {
"EnterFile", "ExitFile", "SystemHeaderPragma", "RenameFile"
};
// CharacteristicKind strings.
static const char *const CharacteristicKindStrings[] = { "C_User", "C_System",
"C_ExternCSystem" };
// MacroDirective::Kind strings.
static const char *const MacroDirectiveKindStrings[] = {
"MD_Define","MD_Undefine", "MD_Visibility"
};
// PragmaIntroducerKind strings.
static const char *const PragmaIntroducerKindStrings[] = { "PIK_HashPragma",
"PIK__Pragma",
"PIK___pragma" };
// PragmaMessageKind strings.
static const char *const PragmaMessageKindStrings[] = {
"PMK_Message", "PMK_Warning", "PMK_Error"
};
// PragmaWarningSpecifier strings.
static const char *const PragmaWarningSpecifierStrings[] = {
"PWS_Default", "PWS_Disable", "PWS_Error", "PWS_Once", "PWS_Suppress",
"PWS_Level1", "PWS_Level2", "PWS_Level3", "PWS_Level4",
};
// ConditionValueKind strings.
static const char *const ConditionValueKindStrings[] = {
"CVK_NotEvaluated", "CVK_False", "CVK_True"
};
// Mapping strings.
static const char *const MappingStrings[] = { "0", "MAP_IGNORE",
"MAP_REMARK", "MAP_WARNING",
"MAP_ERROR", "MAP_FATAL" };
// PPCallbacksTracker functions.
PPCallbacksTracker::PPCallbacksTracker(const FilterType &Filters,
std::vector<CallbackCall> &CallbackCalls,
Preprocessor &PP)
: CallbackCalls(CallbackCalls), Filters(Filters), PP(PP) {}
PPCallbacksTracker::~PPCallbacksTracker() {}
// Callback functions.
// Callback invoked whenever a source file is entered or exited.
void PPCallbacksTracker::FileChanged(SourceLocation Loc,
PPCallbacks::FileChangeReason Reason,
SrcMgr::CharacteristicKind FileType,
FileID PrevFID) {
beginCallback("FileChanged");
appendArgument("Loc", Loc);
appendArgument("Reason", Reason, FileChangeReasonStrings);
appendArgument("FileType", FileType, CharacteristicKindStrings);
appendArgument("PrevFID", PrevFID);
}
// Callback invoked whenever a source file is skipped as the result
// of header guard optimization.
void PPCallbacksTracker::FileSkipped(const FileEntryRef &SkippedFile,
const Token &FilenameTok,
SrcMgr::CharacteristicKind FileType) {
beginCallback("FileSkipped");
appendArgument("ParentFile", SkippedFile);
appendArgument("FilenameTok", FilenameTok);
appendArgument("FileType", FileType, CharacteristicKindStrings);
}
// Callback invoked whenever an inclusion directive of
// any kind (#include, #import, etc.) has been processed, regardless
// of whether the inclusion will actually result in an inclusion.
void PPCallbacksTracker::InclusionDirective(
SourceLocation HashLoc, const Token &IncludeTok, llvm::StringRef FileName,
bool IsAngled, CharSourceRange FilenameRange, OptionalFileEntryRef File,
llvm::StringRef SearchPath, llvm::StringRef RelativePath,
const Module *Imported, SrcMgr::CharacteristicKind FileType) {
beginCallback("InclusionDirective");
appendArgument("HashLoc", HashLoc);
appendArgument("IncludeTok", IncludeTok);
appendFilePathArgument("FileName", FileName);
appendArgument("IsAngled", IsAngled);
appendArgument("FilenameRange", FilenameRange);
appendArgument("File", File);
appendFilePathArgument("SearchPath", SearchPath);
appendFilePathArgument("RelativePath", RelativePath);
appendArgument("Imported", Imported);
}
// Callback invoked whenever there was an explicit module-import
// syntax.
void PPCallbacksTracker::moduleImport(SourceLocation ImportLoc,
ModuleIdPath Path,
const Module *Imported) {
beginCallback("moduleImport");
appendArgument("ImportLoc", ImportLoc);
appendArgument("Path", Path);
appendArgument("Imported", Imported);
}
// Callback invoked when the end of the main file is reached.
// No subsequent callbacks will be made.
void PPCallbacksTracker::EndOfMainFile() { beginCallback("EndOfMainFile"); }
// Callback invoked when a #ident or #sccs directive is read.
void PPCallbacksTracker::Ident(SourceLocation Loc, llvm::StringRef Str) {
beginCallback("Ident");
appendArgument("Loc", Loc);
appendArgument("Str", Str);
}
// Callback invoked when start reading any pragma directive.
void PPCallbacksTracker::PragmaDirective(SourceLocation Loc,
PragmaIntroducerKind Introducer) {
beginCallback("PragmaDirective");
appendArgument("Loc", Loc);
appendArgument("Introducer", Introducer, PragmaIntroducerKindStrings);
}
// Callback invoked when a #pragma comment directive is read.
void PPCallbacksTracker::PragmaComment(SourceLocation Loc,
const IdentifierInfo *Kind,
llvm::StringRef Str) {
beginCallback("PragmaComment");
appendArgument("Loc", Loc);
appendArgument("Kind", Kind);
appendArgument("Str", Str);
}
// Callback invoked when a #pragma detect_mismatch directive is
// read.
void PPCallbacksTracker::PragmaDetectMismatch(SourceLocation Loc,
llvm::StringRef Name,
llvm::StringRef Value) {
beginCallback("PragmaDetectMismatch");
appendArgument("Loc", Loc);
appendArgument("Name", Name);
appendArgument("Value", Value);
}
// Callback invoked when a #pragma clang __debug directive is read.
void PPCallbacksTracker::PragmaDebug(SourceLocation Loc,
llvm::StringRef DebugType) {
beginCallback("PragmaDebug");
appendArgument("Loc", Loc);
appendArgument("DebugType", DebugType);
}
// Callback invoked when a #pragma message directive is read.
void PPCallbacksTracker::PragmaMessage(SourceLocation Loc,
llvm::StringRef Namespace,
PPCallbacks::PragmaMessageKind Kind,
llvm::StringRef Str) {
beginCallback("PragmaMessage");
appendArgument("Loc", Loc);
appendArgument("Namespace", Namespace);
appendArgument("Kind", Kind, PragmaMessageKindStrings);
appendArgument("Str", Str);
}
// Callback invoked when a #pragma gcc diagnostic push directive
// is read.
void PPCallbacksTracker::PragmaDiagnosticPush(SourceLocation Loc,
llvm::StringRef Namespace) {
beginCallback("PragmaDiagnosticPush");
appendArgument("Loc", Loc);
appendArgument("Namespace", Namespace);
}
// Callback invoked when a #pragma gcc diagnostic pop directive
// is read.
void PPCallbacksTracker::PragmaDiagnosticPop(SourceLocation Loc,
llvm::StringRef Namespace) {
beginCallback("PragmaDiagnosticPop");
appendArgument("Loc", Loc);
appendArgument("Namespace", Namespace);
}
// Callback invoked when a #pragma gcc diagnostic directive is read.
void PPCallbacksTracker::PragmaDiagnostic(SourceLocation Loc,
llvm::StringRef Namespace,
diag::Severity Mapping,
llvm::StringRef Str) {
beginCallback("PragmaDiagnostic");
appendArgument("Loc", Loc);
appendArgument("Namespace", Namespace);
appendArgument("Mapping", (unsigned)Mapping, MappingStrings);
appendArgument("Str", Str);
}
// Called when an OpenCL extension is either disabled or
// enabled with a pragma.
void PPCallbacksTracker::PragmaOpenCLExtension(SourceLocation NameLoc,
const IdentifierInfo *Name,
SourceLocation StateLoc,
unsigned State) {
beginCallback("PragmaOpenCLExtension");
appendArgument("NameLoc", NameLoc);
appendArgument("Name", Name);
appendArgument("StateLoc", StateLoc);
appendArgument("State", (int)State);
}
// Callback invoked when a #pragma warning directive is read.
void PPCallbacksTracker::PragmaWarning(SourceLocation Loc,
PragmaWarningSpecifier WarningSpec,
llvm::ArrayRef<int> Ids) {
beginCallback("PragmaWarning");
appendArgument("Loc", Loc);
appendArgument("WarningSpec", WarningSpec, PragmaWarningSpecifierStrings);
std::string Str;
llvm::raw_string_ostream SS(Str);
SS << "[";
for (int i = 0, e = Ids.size(); i != e; ++i) {
if (i)
SS << ", ";
SS << Ids[i];
}
SS << "]";
appendArgument("Ids", SS.str());
}
// Callback invoked when a #pragma warning(push) directive is read.
void PPCallbacksTracker::PragmaWarningPush(SourceLocation Loc, int Level) {
beginCallback("PragmaWarningPush");
appendArgument("Loc", Loc);
appendArgument("Level", Level);
}
// Callback invoked when a #pragma warning(pop) directive is read.
void PPCallbacksTracker::PragmaWarningPop(SourceLocation Loc) {
beginCallback("PragmaWarningPop");
appendArgument("Loc", Loc);
}
// Callback invoked when a #pragma execution_character_set(push) directive
// is read.
void PPCallbacksTracker::PragmaExecCharsetPush(SourceLocation Loc,
StringRef Str) {
beginCallback("PragmaExecCharsetPush");
appendArgument("Loc", Loc);
appendArgument("Charset", Str);
}
// Callback invoked when a #pragma execution_character_set(pop) directive
// is read.
void PPCallbacksTracker::PragmaExecCharsetPop(SourceLocation Loc) {
beginCallback("PragmaExecCharsetPop");
appendArgument("Loc", Loc);
}
// Called by Preprocessor::HandleMacroExpandedIdentifier when a
// macro invocation is found.
void PPCallbacksTracker::MacroExpands(const Token &MacroNameTok,
const MacroDefinition &MacroDefinition,
SourceRange Range,
const MacroArgs *Args) {
beginCallback("MacroExpands");
appendArgument("MacroNameTok", MacroNameTok);
appendArgument("MacroDefinition", MacroDefinition);
appendArgument("Range", Range);
appendArgument("Args", Args);
}
// Hook called whenever a macro definition is seen.
void PPCallbacksTracker::MacroDefined(const Token &MacroNameTok,
const MacroDirective *MacroDirective) {
beginCallback("MacroDefined");
appendArgument("MacroNameTok", MacroNameTok);
appendArgument("MacroDirective", MacroDirective);
}
// Hook called whenever a macro #undef is seen.
void PPCallbacksTracker::MacroUndefined(const Token &MacroNameTok,
const MacroDefinition &MacroDefinition,
const MacroDirective *Undef) {
beginCallback("MacroUndefined");
appendArgument("MacroNameTok", MacroNameTok);
appendArgument("MacroDefinition", MacroDefinition);
}
// Hook called whenever the 'defined' operator is seen.
void PPCallbacksTracker::Defined(const Token &MacroNameTok,
const MacroDefinition &MacroDefinition,
SourceRange Range) {
beginCallback("Defined");
appendArgument("MacroNameTok", MacroNameTok);
appendArgument("MacroDefinition", MacroDefinition);
appendArgument("Range", Range);
}
// Hook called when a source range is skipped.
void PPCallbacksTracker::SourceRangeSkipped(SourceRange Range,
SourceLocation EndifLoc) {
beginCallback("SourceRangeSkipped");
appendArgument("Range", SourceRange(Range.getBegin(), EndifLoc));
}
// Hook called whenever an #if is seen.
void PPCallbacksTracker::If(SourceLocation Loc, SourceRange ConditionRange,
ConditionValueKind ConditionValue) {
beginCallback("If");
appendArgument("Loc", Loc);
appendArgument("ConditionRange", ConditionRange);
appendArgument("ConditionValue", ConditionValue, ConditionValueKindStrings);
}
// Hook called whenever an #elif is seen.
void PPCallbacksTracker::Elif(SourceLocation Loc, SourceRange ConditionRange,
ConditionValueKind ConditionValue,
SourceLocation IfLoc) {
beginCallback("Elif");
appendArgument("Loc", Loc);
appendArgument("ConditionRange", ConditionRange);
appendArgument("ConditionValue", ConditionValue, ConditionValueKindStrings);
appendArgument("IfLoc", IfLoc);
}
// Hook called whenever an #ifdef is seen.
void PPCallbacksTracker::Ifdef(SourceLocation Loc, const Token &MacroNameTok,
const MacroDefinition &MacroDefinition) {
beginCallback("Ifdef");
appendArgument("Loc", Loc);
appendArgument("MacroNameTok", MacroNameTok);
appendArgument("MacroDefinition", MacroDefinition);
}
// Hook called whenever an #ifndef is seen.
void PPCallbacksTracker::Ifndef(SourceLocation Loc, const Token &MacroNameTok,
const MacroDefinition &MacroDefinition) {
beginCallback("Ifndef");
appendArgument("Loc", Loc);
appendArgument("MacroNameTok", MacroNameTok);
appendArgument("MacroDefinition", MacroDefinition);
}
// Hook called whenever an #else is seen.
void PPCallbacksTracker::Else(SourceLocation Loc, SourceLocation IfLoc) {
beginCallback("Else");
appendArgument("Loc", Loc);
appendArgument("IfLoc", IfLoc);
}
// Hook called whenever an #endif is seen.
void PPCallbacksTracker::Endif(SourceLocation Loc, SourceLocation IfLoc) {
beginCallback("Endif");
appendArgument("Loc", Loc);
appendArgument("IfLoc", IfLoc);
}
// Helper functions.
// Start a new callback.
void PPCallbacksTracker::beginCallback(const char *Name) {
auto R = CallbackIsEnabled.try_emplace(Name, false);
if (R.second) {
llvm::StringRef N(Name);
for (const std::pair<llvm::GlobPattern, bool> &Filter : Filters)
if (Filter.first.match(N))
R.first->second = Filter.second;
}
DisableTrace = !R.first->second;
if (DisableTrace)
return;
CallbackCalls.push_back(CallbackCall(Name));
}
// Append a bool argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name, bool Value) {
appendArgument(Name, (Value ? "true" : "false"));
}
// Append an int argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name, int Value) {
std::string Str;
llvm::raw_string_ostream SS(Str);
SS << Value;
appendArgument(Name, SS.str());
}
// Append a string argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name, const char *Value) {
if (DisableTrace)
return;
CallbackCalls.back().Arguments.push_back(Argument{Name, Value});
}
// Append a string object argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name,
llvm::StringRef Value) {
appendArgument(Name, Value.str());
}
// Append a string object argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name,
const std::string &Value) {
appendArgument(Name, Value.c_str());
}
// Append a token argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name, const Token &Value) {
appendArgument(Name, PP.getSpelling(Value));
}
// Append an enum argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name, int Value,
const char *const Strings[]) {
appendArgument(Name, Strings[Value]);
}
// Append a FileID argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name, FileID Value) {
if (Value.isInvalid()) {
appendArgument(Name, "(invalid)");
return;
}
OptionalFileEntryRef FileEntry =
PP.getSourceManager().getFileEntryRefForID(Value);
if (!FileEntry) {
appendArgument(Name, "(getFileEntryForID failed)");
return;
}
appendFilePathArgument(Name, FileEntry->getName());
}
// Append a FileEntry argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name,
OptionalFileEntryRef Value) {
if (!Value) {
appendArgument(Name, "(null)");
return;
}
appendArgument(Name, *Value);
}
void PPCallbacksTracker::appendArgument(const char *Name, FileEntryRef Value) {
appendFilePathArgument(Name, Value.getName());
}
// Append a SourceLocation argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name,
SourceLocation Value) {
if (Value.isInvalid()) {
appendArgument(Name, "(invalid)");
return;
}
appendArgument(Name, getSourceLocationString(PP, Value).c_str());
}
// Append a SourceRange argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name, SourceRange Value) {
if (DisableTrace)
return;
if (Value.isInvalid()) {
appendArgument(Name, "(invalid)");
return;
}
std::string Str;
llvm::raw_string_ostream SS(Str);
SS << "[" << getSourceLocationString(PP, Value.getBegin()) << ", "
<< getSourceLocationString(PP, Value.getEnd()) << "]";
appendArgument(Name, SS.str());
}
// Append a CharSourceRange argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name,
CharSourceRange Value) {
if (Value.isInvalid()) {
appendArgument(Name, "(invalid)");
return;
}
appendArgument(Name, getSourceString(Value).str().c_str());
}
// Append a SourceLocation argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name, ModuleIdPath Value) {
if (DisableTrace)
return;
std::string Str;
llvm::raw_string_ostream SS(Str);
SS << "[";
for (int I = 0, E = Value.size(); I != E; ++I) {
if (I)
SS << ", ";
SS << "{"
<< "Name: " << Value[I].first->getName() << ", "
<< "Loc: " << getSourceLocationString(PP, Value[I].second) << "}";
}
SS << "]";
appendArgument(Name, SS.str());
}
// Append an IdentifierInfo argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name,
const IdentifierInfo *Value) {
if (!Value) {
appendArgument(Name, "(null)");
return;
}
appendArgument(Name, Value->getName().str().c_str());
}
// Append a MacroDirective argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name,
const MacroDirective *Value) {
if (!Value) {
appendArgument(Name, "(null)");
return;
}
appendArgument(Name, MacroDirectiveKindStrings[Value->getKind()]);
}
// Append a MacroDefinition argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name,
const MacroDefinition &Value) {
std::string Str;
llvm::raw_string_ostream SS(Str);
SS << "[";
bool Any = false;
if (Value.getLocalDirective()) {
SS << "(local)";
Any = true;
}
for (auto *MM : Value.getModuleMacros()) {
if (Any) SS << ", ";
SS << MM->getOwningModule()->getFullModuleName();
}
SS << "]";
appendArgument(Name, SS.str());
}
// Append a MacroArgs argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name,
const MacroArgs *Value) {
if (!Value) {
appendArgument(Name, "(null)");
return;
}
std::string Str;
llvm::raw_string_ostream SS(Str);
SS << "[";
// Each argument is a series of contiguous Tokens, terminated by a eof.
// Go through each argument printing tokens until we reach eof.
for (unsigned I = 0; I < Value->getNumMacroArguments(); ++I) {
const Token *Current = Value->getUnexpArgument(I);
if (I)
SS << ", ";
bool First = true;
while (Current->isNot(tok::eof)) {
if (!First)
SS << " ";
// We need to be careful here because the arguments might not be legal in
// YAML, so we use the token name for anything but identifiers and
// numeric literals.
if (Current->isAnyIdentifier() || Current->is(tok::numeric_constant)) {
SS << PP.getSpelling(*Current);
} else {
SS << "<" << Current->getName() << ">";
}
++Current;
First = false;
}
}
SS << "]";
appendArgument(Name, SS.str());
}
// Append a Module argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name, const Module *Value) {
if (!Value) {
appendArgument(Name, "(null)");
return;
}
appendArgument(Name, Value->Name.c_str());
}
// Append a double-quoted argument to the top trace item.
void PPCallbacksTracker::appendQuotedArgument(const char *Name,
const std::string &Value) {
std::string Str;
llvm::raw_string_ostream SS(Str);
SS << "\"" << Value << "\"";
appendArgument(Name, SS.str());
}
// Append a double-quoted file path argument to the top trace item.
void PPCallbacksTracker::appendFilePathArgument(const char *Name,
llvm::StringRef Value) {
std::string Path(Value);
// YAML treats backslash as escape, so use forward slashes.
std::replace(Path.begin(), Path.end(), '\\', '/');
appendQuotedArgument(Name, Path);
}
// Get the raw source string of the range.
llvm::StringRef PPCallbacksTracker::getSourceString(CharSourceRange Range) {
const char *B = PP.getSourceManager().getCharacterData(Range.getBegin());
const char *E = PP.getSourceManager().getCharacterData(Range.getEnd());
return llvm::StringRef(B, E - B);
}
} // namespace pp_trace
} // namespace clang