File Manager

003 File Manager

Current Path: /usr/src/contrib/llvm-project/lldb/source/Plugins/ExpressionParser/Clang

usr / src / contrib / llvm-project / lldb / source / Plugins / ExpressionParser / Clang /

📁 ..
📄 ASTResultSynthesizer.cpp(14.35 KB)
📄 ASTResultSynthesizer.h(6.39 KB)
📄 ASTStructExtractor.cpp(5.17 KB)
📄 ASTStructExtractor.h(5.19 KB)
📄 ASTUtils.cpp(906 B)
📄 ASTUtils.h(18.41 KB)
📄 ClangASTImporter.cpp(41.82 KB)
📄 ClangASTImporter.h(11.08 KB)
📄 ClangASTMetadata.cpp(986 B)
📄 ClangASTMetadata.h(2.94 KB)
📄 ClangASTSource.cpp(55.96 KB)
📄 ClangASTSource.h(13.72 KB)
📄 ClangDeclVendor.cpp(1.16 KB)
📄 ClangDeclVendor.h(1.27 KB)
📄 ClangDiagnostic.h(1.54 KB)
📄 ClangExpressionDeclMap.cpp(64.5 KB)
📄 ClangExpressionDeclMap.h(23.21 KB)
📄 ClangExpressionHelper.h(1.9 KB)
📄 ClangExpressionParser.cpp(55.41 KB)
📄 ClangExpressionParser.h(6.72 KB)
📄 ClangExpressionSourceCode.cpp(15.9 KB)
📄 ClangExpressionSourceCode.h(3.72 KB)
📄 ClangExpressionVariable.cpp(2.19 KB)
📄 ClangExpressionVariable.h(6.92 KB)
📄 ClangExternalASTSourceCallbacks.cpp(3.14 KB)
📄 ClangExternalASTSourceCallbacks.h(2.44 KB)
📄 ClangFunctionCaller.cpp(7.66 KB)
📄 ClangFunctionCaller.h(5.76 KB)
📄 ClangHost.cpp(6.28 KB)
📄 ClangHost.h(742 B)
📄 ClangModulesDeclVendor.cpp(25.16 KB)
📄 ClangModulesDeclVendor.h(4.31 KB)
📄 ClangPersistentVariables.cpp(4.14 KB)
📄 ClangPersistentVariables.h(3.85 KB)
📄 ClangUserExpression.cpp(32.03 KB)
📄 ClangUserExpression.h(9.76 KB)
📄 ClangUtil.cpp(2.4 KB)
📄 ClangUtil.h(1.69 KB)
📄 ClangUtilityFunction.cpp(5.1 KB)
📄 ClangUtilityFunction.h(3.73 KB)
📄 CppModuleConfiguration.cpp(2.94 KB)
📄 CppModuleConfiguration.h(3.06 KB)
📄 CxxModuleHandler.cpp(9.8 KB)
📄 CxxModuleHandler.h(2.76 KB)
📄 IRDynamicChecks.cpp(17.29 KB)
📄 IRDynamicChecks.h(4 KB)
📄 IRForTarget.cpp(63.93 KB)
📄 IRForTarget.h(18.24 KB)
📄 ModuleDependencyCollector.h(1.37 KB)
📄 NameSearchContext.cpp(5.92 KB)
📄 NameSearchContext.h(4.57 KB)

Editing: IRDynamicChecks.h

//===-- IRDynamicChecks.h ---------------------------------------*- 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
//
//===----------------------------------------------------------------------===//

#ifndef LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_IRDYNAMICCHECKS_H
#define LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_IRDYNAMICCHECKS_H

#include "lldb/Expression/DynamicCheckerFunctions.h"
#include "lldb/lldb-types.h"
#include "llvm/Pass.h"

namespace llvm {
class BasicBlock;
class Module;
}

namespace lldb_private {

class ExecutionContext;
class Stream;

class ClangDynamicCheckerFunctions
    : public lldb_private::DynamicCheckerFunctions {
public:
  /// Constructor
  ClangDynamicCheckerFunctions();

/// Destructor
  virtual ~ClangDynamicCheckerFunctions();

static bool classof(const DynamicCheckerFunctions *checker_funcs) {
    return checker_funcs->GetKind() == DCF_Clang;
  }

/// Install the utility functions into a process.  This binds the instance
  /// of DynamicCheckerFunctions to that process.
  ///
  /// \param[in] diagnostic_manager
  ///     A diagnostic manager to report errors to.
  ///
  /// \param[in] exe_ctx
  ///     The execution context to install the functions into.
  ///
  /// \return
  ///     True on success; false on failure, or if the functions have
  ///     already been installed.
  bool Install(DiagnosticManager &diagnostic_manager,
               ExecutionContext &exe_ctx) override;

bool DoCheckersExplainStop(lldb::addr_t addr, Stream &message) override;

std::shared_ptr<UtilityFunction> m_valid_pointer_check;
  std::shared_ptr<UtilityFunction> m_objc_object_check;
};

/// \class IRDynamicChecks IRDynamicChecks.h
/// "lldb/Expression/IRDynamicChecks.h" Adds dynamic checks to a user-entered
/// expression to reduce its likelihood of crashing
///
/// When an IR function is executed in the target process, it may cause
/// crashes or hangs by dereferencing NULL pointers, trying to call
/// Objective-C methods on objects that do not respond to them, and so forth.
///
/// IRDynamicChecks adds calls to the functions in DynamicCheckerFunctions to
/// appropriate locations in an expression's IR.
class IRDynamicChecks : public llvm::ModulePass {
public:
  /// Constructor
  ///
  /// \param[in] checker_functions
  ///     The checker functions for the target process.
  ///
  /// \param[in] func_name
  ///     The name of the function to prepare for execution in the target.
  IRDynamicChecks(ClangDynamicCheckerFunctions &checker_functions,
                  const char *func_name = "$__lldb_expr");

/// Destructor
  ~IRDynamicChecks() override;

/// Run this IR transformer on a single module
  ///
  /// \param[in] M
  ///     The module to run on.  This module is searched for the function
  ///     $__lldb_expr, and that function is passed to the passes one by
  ///     one.
  ///
  /// \return
  ///     True on success; false otherwise
  bool runOnModule(llvm::Module &M) override;

/// Interface stub
  void assignPassManager(
      llvm::PMStack &PMS,
      llvm::PassManagerType T = llvm::PMT_ModulePassManager) override;

/// Returns PMT_ModulePassManager
  llvm::PassManagerType getPotentialPassManagerType() const override;

private:
  /// A basic block-level pass to find all pointer dereferences and
  /// validate them before use.

/// The top-level pass implementation
  ///
  /// \param[in] M
  ///     The module currently being processed.
  ///
  /// \param[in] BB
  ///     The basic block currently being processed.
  ///
  /// \return
  ///     True on success; false otherwise
  bool FindDataLoads(llvm::Module &M, llvm::BasicBlock &BB);

std::string m_func_name; ///< The name of the function to add checks to
  ClangDynamicCheckerFunctions
      &m_checker_functions; ///< The checker functions for the process
};

} // namespace lldb_private

#endif // LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_IRDYNAMICCHECKS_H

003 File Manager

Editing: IRDynamicChecks.h

Upload File

Create Folder