PPCallbacksTracker.h

Go to the documentation of this file.

//===--- PPCallbacksTracker.h - Preprocessor tracking -----------*- C++ -*-===//
//
// 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
/// Classes and definitions for preprocessor tracking.
///
/// The core definition is the PPCallbacksTracker class, derived from Clang's
/// PPCallbacks class from the Lex library, which overrides all the callbacks
/// and collects information about each callback call, saving it in a
/// data structure built up of CallbackCall and Argument objects, which
/// record the preprocessor callback name and arguments in high-level string
/// form for later inspection.
///
//===----------------------------------------------------------------------===//
 
#ifndef PPTRACE_PPCALLBACKSTRACKER_H
#define PPTRACE_PPCALLBACKSTRACKER_H
 
#include "clang/Lex/PPCallbacks.h"
#include "clang/Lex/Preprocessor.h"
#include "clang/Basic/SourceManager.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/SmallSet.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/GlobPattern.h"
#include <string>
#include <vector>
 
namespace clang {
namespace pp_trace {
 
// This struct represents one callback function argument by name and value.
struct Argument {
  std::string Name;
  std::string Value;
};
 
/// This class represents one callback call by name and an array
///   of arguments.
class CallbackCall {
public:
  CallbackCall(llvm::StringRef Name) : Name(Name) {}
  CallbackCall() = default;
 
  std::string Name;
  std::vector<Argument> Arguments;
};
 
using FilterType = std::vector<std::pair<llvm::GlobPattern, bool>>;
 
/// This class overrides the PPCallbacks class for tracking preprocessor
///   activity by means of its callback functions.
///
/// This object is given a vector for storing the trace information, built up
/// of CallbackCall and subordinate Argument objects for representing the
/// callback calls and their arguments.  It's a reference so the vector can
/// exist beyond the lifetime of this object, because it's deleted by the
/// preprocessor automatically in its destructor.
///
/// This class supports a mechanism for inhibiting trace output for
/// specific callbacks by name, for the purpose of eliminating output for
/// callbacks of no interest that might clutter the output.
///
/// Following the constructor and destructor function declarations, the
/// overridden callback functions are defined.  The remaining functions are
/// helpers for recording the trace data, to reduce the coupling between it
/// and the recorded data structure.
class PPCallbacksTracker : public PPCallbacks {
public:
  /// Note that all of the arguments are references, and owned
  /// by the caller.
  /// \param Filters - List of (Glob,Enabled) pairs used to filter callbacks.
  /// \param CallbackCalls - Trace buffer.
  /// \param PP - The preprocessor.  Needed for getting some argument strings.
  PPCallbacksTracker(const FilterType &Filters,
                     std::vector<CallbackCall> &CallbackCalls,
                     Preprocessor &PP);
 
  ~PPCallbacksTracker() override;
 
  // Overridden callback functions.
 
  void FileChanged(SourceLocation Loc, PPCallbacks::FileChangeReason Reason,
                   SrcMgr::CharacteristicKind FileType,
                   FileID PrevFID = FileID()) override;
  void FileSkipped(const FileEntryRef &SkippedFile, const Token &FilenameTok,
                   SrcMgr::CharacteristicKind FileType) override;
  void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                          llvm::StringRef FileName, bool IsAngled,
                          CharSourceRange FilenameRange,
                          OptionalFileEntryRef File, llvm::StringRef SearchPath,
                          llvm::StringRef RelativePath,
                          const Module *SuggestedModule, bool ModuleImported,
                          SrcMgr::CharacteristicKind FileType) override;
  void moduleImport(SourceLocation ImportLoc, ModuleIdPath Path,
                    const Module *Imported) override;
  void EndOfMainFile() override;
  void Ident(SourceLocation Loc, llvm::StringRef str) override;
  void PragmaDirective(SourceLocation Loc,
                       PragmaIntroducerKind Introducer) override;
  void PragmaComment(SourceLocation Loc, const IdentifierInfo *Kind,
                     llvm::StringRef Str) override;
  void PragmaDetectMismatch(SourceLocation Loc, llvm::StringRef Name,
                            llvm::StringRef Value) override;
  void PragmaDebug(SourceLocation Loc, llvm::StringRef DebugType) override;
  void PragmaMessage(SourceLocation Loc, llvm::StringRef Namespace,
                     PPCallbacks::PragmaMessageKind Kind,
                     llvm::StringRef Str) override;
  void PragmaDiagnosticPush(SourceLocation Loc,
                            llvm::StringRef Namespace) override;
  void PragmaDiagnosticPop(SourceLocation Loc,
                           llvm::StringRef Namespace) override;
  void PragmaDiagnostic(SourceLocation Loc, llvm::StringRef Namespace,
                        diag::Severity mapping, llvm::StringRef Str) override;
  void PragmaOpenCLExtension(SourceLocation NameLoc, const IdentifierInfo *Name,
                             SourceLocation StateLoc, unsigned State) override;
  void PragmaWarning(SourceLocation Loc, PragmaWarningSpecifier WarningSpec,
                     llvm::ArrayRef<int> Ids) override;
  void PragmaWarningPush(SourceLocation Loc, int Level) override;
  void PragmaWarningPop(SourceLocation Loc) override;
  void PragmaExecCharsetPush(SourceLocation Loc, StringRef Str) override;
  void PragmaExecCharsetPop(SourceLocation Loc) override;
  void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
                    SourceRange Range, const MacroArgs *Args) override;
  void MacroDefined(const Token &MacroNameTok,
                    const MacroDirective *MD) override;
  void MacroUndefined(const Token &MacroNameTok, const MacroDefinition &MD,
                      const MacroDirective *Undef) override;
  void Defined(const Token &MacroNameTok, const MacroDefinition &MD,
               SourceRange Range) override;
  void SourceRangeSkipped(SourceRange Range, SourceLocation EndifLoc) override;
  void If(SourceLocation Loc, SourceRange ConditionRange,
          ConditionValueKind ConditionValue) override;
  void Elif(SourceLocation Loc, SourceRange ConditionRange,
            ConditionValueKind ConditionValue, SourceLocation IfLoc) override;
  void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
             const MacroDefinition &MD) override;
  void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
              const MacroDefinition &MD) override;
  void Else(SourceLocation Loc, SourceLocation IfLoc) override;
  void Endif(SourceLocation Loc, SourceLocation IfLoc) override;
 
  // Helper functions.
 
  /// Start a new callback.
  void beginCallback(const char *Name);
 
  /// Append a string to the top trace item.
  void append(const char *Str);
 
  /// Append a bool argument to the top trace item.
  void appendArgument(const char *Name, bool Value);
 
  /// Append an int argument to the top trace item.
  void appendArgument(const char *Name, int Value);
 
  /// Append a string argument to the top trace item.
  void appendArgument(const char *Name, const char *Value);
 
  /// Append a string reference object argument to the top trace item.
  void appendArgument(const char *Name, llvm::StringRef Value);
 
  /// Append a string object argument to the top trace item.
  void appendArgument(const char *Name, const std::string &Value);
 
  /// Append a token argument to the top trace item.
  void appendArgument(const char *Name, const Token &Value);
 
  /// Append an enum argument to the top trace item.
  void appendArgument(const char *Name, int Value, const char *const Strings[]);
 
  /// Append a FileID argument to the top trace item.
  void appendArgument(const char *Name, FileID Value);
 
  /// Append a FileEntryRef argument to the top trace item.
  void appendArgument(const char *Name, OptionalFileEntryRef Value);
  void appendArgument(const char *Name, FileEntryRef Value);
 
  /// Append a SourceLocation argument to the top trace item.
  void appendArgument(const char *Name, SourceLocation Value);
 
  /// Append a SourceRange argument to the top trace item.
  void appendArgument(const char *Name, SourceRange Value);
 
  /// Append a CharSourceRange argument to the top trace item.
  void appendArgument(const char *Name, CharSourceRange Value);
 
  /// Append a ModuleIdPath argument to the top trace item.
  void appendArgument(const char *Name, ModuleIdPath Value);
 
  /// Append an IdentifierInfo argument to the top trace item.
  void appendArgument(const char *Name, const IdentifierInfo *Value);
 
  /// Append a MacroDirective argument to the top trace item.
  void appendArgument(const char *Name, const MacroDirective *Value);
 
  /// Append a MacroDefinition argument to the top trace item.
  void appendArgument(const char *Name, const MacroDefinition &Value);
 
  /// Append a MacroArgs argument to the top trace item.
  void appendArgument(const char *Name, const MacroArgs *Value);
 
  /// Append a Module argument to the top trace item.
  void appendArgument(const char *Name, const Module *Value);
 
  /// Append a double-quoted argument to the top trace item.
  void appendQuotedArgument(const char *Name, const std::string &Value);
 
  /// Append a double-quoted file path argument to the top trace item.
  void appendFilePathArgument(const char *Name, llvm::StringRef Value);
 
  /// Get the raw source string of the range.
  llvm::StringRef getSourceString(CharSourceRange Range);
 
  /// Callback trace information.
  /// We use a reference so the trace will be preserved for the caller
  /// after this object is destructed.
  std::vector<CallbackCall> &CallbackCalls;
 
  // List of (Glob,Enabled) pairs used to filter callbacks.
  const FilterType &Filters;
 
  // Whether a callback should be printed.
  llvm::StringMap<bool> CallbackIsEnabled;
 
  /// Inhibit trace while this is set.
  bool DisableTrace;
 
  Preprocessor &PP;
};
 
} // namespace pp_trace
} // namespace clang
 
#endif // PPTRACE_PPCALLBACKSTRACKER_H