242 lines · c
1//===--- PPCallbacksTracker.h - Preprocessor tracking -----------*- C++ -*-===//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-exception6//7//===----------------------------------------------------------------------===//8///9/// \file10/// Classes and definitions for preprocessor tracking.11///12/// The core definition is the PPCallbacksTracker class, derived from Clang's13/// PPCallbacks class from the Lex library, which overrides all the callbacks14/// and collects information about each callback call, saving it in a15/// data structure built up of CallbackCall and Argument objects, which16/// record the preprocessor callback name and arguments in high-level string17/// form for later inspection.18///19//===----------------------------------------------------------------------===//20 21#ifndef PPTRACE_PPCALLBACKSTRACKER_H22#define PPTRACE_PPCALLBACKSTRACKER_H23 24#include "clang/Lex/PPCallbacks.h"25#include "clang/Lex/Preprocessor.h"26#include "clang/Basic/SourceManager.h"27#include "llvm/ADT/ArrayRef.h"28#include "llvm/ADT/SmallSet.h"29#include "llvm/ADT/StringMap.h"30#include "llvm/ADT/StringRef.h"31#include "llvm/Support/GlobPattern.h"32#include <string>33#include <vector>34 35namespace clang {36namespace pp_trace {37 38// This struct represents one callback function argument by name and value.39struct Argument {40 std::string Name;41 std::string Value;42};43 44/// This class represents one callback call by name and an array45/// of arguments.46class CallbackCall {47public:48 CallbackCall(llvm::StringRef Name) : Name(Name) {}49 CallbackCall() = default;50 51 std::string Name;52 std::vector<Argument> Arguments;53};54 55using FilterType = std::vector<std::pair<llvm::GlobPattern, bool>>;56 57/// This class overrides the PPCallbacks class for tracking preprocessor58/// activity by means of its callback functions.59///60/// This object is given a vector for storing the trace information, built up61/// of CallbackCall and subordinate Argument objects for representing the62/// callback calls and their arguments. It's a reference so the vector can63/// exist beyond the lifetime of this object, because it's deleted by the64/// preprocessor automatically in its destructor.65///66/// This class supports a mechanism for inhibiting trace output for67/// specific callbacks by name, for the purpose of eliminating output for68/// callbacks of no interest that might clutter the output.69///70/// Following the constructor and destructor function declarations, the71/// overridden callback functions are defined. The remaining functions are72/// helpers for recording the trace data, to reduce the coupling between it73/// and the recorded data structure.74class PPCallbacksTracker : public PPCallbacks {75public:76 /// Note that all of the arguments are references, and owned77 /// by the caller.78 /// \param Filters - List of (Glob,Enabled) pairs used to filter callbacks.79 /// \param CallbackCalls - Trace buffer.80 /// \param PP - The preprocessor. Needed for getting some argument strings.81 PPCallbacksTracker(const FilterType &Filters,82 std::vector<CallbackCall> &CallbackCalls,83 Preprocessor &PP);84 85 ~PPCallbacksTracker() override;86 87 // Overridden callback functions.88 89 void FileChanged(SourceLocation Loc, PPCallbacks::FileChangeReason Reason,90 SrcMgr::CharacteristicKind FileType,91 FileID PrevFID = FileID()) override;92 void FileSkipped(const FileEntryRef &SkippedFile, const Token &FilenameTok,93 SrcMgr::CharacteristicKind FileType) override;94 void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,95 llvm::StringRef FileName, bool IsAngled,96 CharSourceRange FilenameRange,97 OptionalFileEntryRef File, llvm::StringRef SearchPath,98 llvm::StringRef RelativePath,99 const Module *SuggestedModule, bool ModuleImported,100 SrcMgr::CharacteristicKind FileType) override;101 void moduleImport(SourceLocation ImportLoc, ModuleIdPath Path,102 const Module *Imported) override;103 void EndOfMainFile() override;104 void Ident(SourceLocation Loc, llvm::StringRef str) override;105 void PragmaDirective(SourceLocation Loc,106 PragmaIntroducerKind Introducer) override;107 void PragmaComment(SourceLocation Loc, const IdentifierInfo *Kind,108 llvm::StringRef Str) override;109 void PragmaDetectMismatch(SourceLocation Loc, llvm::StringRef Name,110 llvm::StringRef Value) override;111 void PragmaDebug(SourceLocation Loc, llvm::StringRef DebugType) override;112 void PragmaMessage(SourceLocation Loc, llvm::StringRef Namespace,113 PPCallbacks::PragmaMessageKind Kind,114 llvm::StringRef Str) override;115 void PragmaDiagnosticPush(SourceLocation Loc,116 llvm::StringRef Namespace) override;117 void PragmaDiagnosticPop(SourceLocation Loc,118 llvm::StringRef Namespace) override;119 void PragmaDiagnostic(SourceLocation Loc, llvm::StringRef Namespace,120 diag::Severity mapping, llvm::StringRef Str) override;121 void PragmaOpenCLExtension(SourceLocation NameLoc, const IdentifierInfo *Name,122 SourceLocation StateLoc, unsigned State) override;123 void PragmaWarning(SourceLocation Loc, PragmaWarningSpecifier WarningSpec,124 llvm::ArrayRef<int> Ids) override;125 void PragmaWarningPush(SourceLocation Loc, int Level) override;126 void PragmaWarningPop(SourceLocation Loc) override;127 void PragmaExecCharsetPush(SourceLocation Loc, StringRef Str) override;128 void PragmaExecCharsetPop(SourceLocation Loc) override;129 void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,130 SourceRange Range, const MacroArgs *Args) override;131 void MacroDefined(const Token &MacroNameTok,132 const MacroDirective *MD) override;133 void MacroUndefined(const Token &MacroNameTok, const MacroDefinition &MD,134 const MacroDirective *Undef) override;135 void Defined(const Token &MacroNameTok, const MacroDefinition &MD,136 SourceRange Range) override;137 void SourceRangeSkipped(SourceRange Range, SourceLocation EndifLoc) override;138 void If(SourceLocation Loc, SourceRange ConditionRange,139 ConditionValueKind ConditionValue) override;140 void Elif(SourceLocation Loc, SourceRange ConditionRange,141 ConditionValueKind ConditionValue, SourceLocation IfLoc) override;142 void Ifdef(SourceLocation Loc, const Token &MacroNameTok,143 const MacroDefinition &MD) override;144 void Ifndef(SourceLocation Loc, const Token &MacroNameTok,145 const MacroDefinition &MD) override;146 void Else(SourceLocation Loc, SourceLocation IfLoc) override;147 void Endif(SourceLocation Loc, SourceLocation IfLoc) override;148 149 // Helper functions.150 151 /// Start a new callback.152 void beginCallback(const char *Name);153 154 /// Append a string to the top trace item.155 void append(const char *Str);156 157 /// Append a bool argument to the top trace item.158 void appendArgument(const char *Name, bool Value);159 160 /// Append an int argument to the top trace item.161 void appendArgument(const char *Name, int Value);162 163 /// Append a string argument to the top trace item.164 void appendArgument(const char *Name, const char *Value);165 166 /// Append a string reference object argument to the top trace item.167 void appendArgument(const char *Name, llvm::StringRef Value);168 169 /// Append a string object argument to the top trace item.170 void appendArgument(const char *Name, const std::string &Value);171 172 /// Append a token argument to the top trace item.173 void appendArgument(const char *Name, const Token &Value);174 175 /// Append an enum argument to the top trace item.176 void appendArgument(const char *Name, int Value, const char *const Strings[]);177 178 /// Append a FileID argument to the top trace item.179 void appendArgument(const char *Name, FileID Value);180 181 /// Append a FileEntryRef argument to the top trace item.182 void appendArgument(const char *Name, OptionalFileEntryRef Value);183 void appendArgument(const char *Name, FileEntryRef Value);184 185 /// Append a SourceLocation argument to the top trace item.186 void appendArgument(const char *Name, SourceLocation Value);187 188 /// Append a SourceRange argument to the top trace item.189 void appendArgument(const char *Name, SourceRange Value);190 191 /// Append a CharSourceRange argument to the top trace item.192 void appendArgument(const char *Name, CharSourceRange Value);193 194 /// Append a ModuleIdPath argument to the top trace item.195 void appendArgument(const char *Name, ModuleIdPath Value);196 197 /// Append an IdentifierInfo argument to the top trace item.198 void appendArgument(const char *Name, const IdentifierInfo *Value);199 200 /// Append a MacroDirective argument to the top trace item.201 void appendArgument(const char *Name, const MacroDirective *Value);202 203 /// Append a MacroDefinition argument to the top trace item.204 void appendArgument(const char *Name, const MacroDefinition &Value);205 206 /// Append a MacroArgs argument to the top trace item.207 void appendArgument(const char *Name, const MacroArgs *Value);208 209 /// Append a Module argument to the top trace item.210 void appendArgument(const char *Name, const Module *Value);211 212 /// Append a double-quoted argument to the top trace item.213 void appendQuotedArgument(const char *Name, const std::string &Value);214 215 /// Append a double-quoted file path argument to the top trace item.216 void appendFilePathArgument(const char *Name, llvm::StringRef Value);217 218 /// Get the raw source string of the range.219 llvm::StringRef getSourceString(CharSourceRange Range);220 221 /// Callback trace information.222 /// We use a reference so the trace will be preserved for the caller223 /// after this object is destructed.224 std::vector<CallbackCall> &CallbackCalls;225 226 // List of (Glob,Enabled) pairs used to filter callbacks.227 const FilterType &Filters;228 229 // Whether a callback should be printed.230 llvm::StringMap<bool> CallbackIsEnabled;231 232 /// Inhibit trace while this is set.233 bool DisableTrace;234 235 Preprocessor &PP;236};237 238} // namespace pp_trace239} // namespace clang240 241#endif // PPTRACE_PPCALLBACKSTRACKER_H242