1//===-- IRDynamicChecks.h ---------------------------------------*- 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-exception 6// 7//===----------------------------------------------------------------------===// 8 9#ifndef liblldb_IRDynamicChecks_h_ 10#define liblldb_IRDynamicChecks_h_ 11 12#include "lldb/Expression/DynamicCheckerFunctions.h" 13#include "lldb/lldb-types.h" 14#include "llvm/Pass.h" 15 16namespace llvm { 17class BasicBlock; 18class Module; 19} 20 21namespace lldb_private { 22 23class ExecutionContext; 24class Stream; 25 26class ClangDynamicCheckerFunctions 27 : public lldb_private::DynamicCheckerFunctions { 28public: 29 /// Constructor 30 ClangDynamicCheckerFunctions(); 31 32 /// Destructor 33 virtual ~ClangDynamicCheckerFunctions(); 34 35 static bool classof(const DynamicCheckerFunctions *checker_funcs) { 36 return checker_funcs->GetKind() == DCF_Clang; 37 } 38 39 /// Install the utility functions into a process. This binds the instance 40 /// of DynamicCheckerFunctions to that process. 41 /// 42 /// \param[in] diagnostic_manager 43 /// A diagnostic manager to report errors to. 44 /// 45 /// \param[in] exe_ctx 46 /// The execution context to install the functions into. 47 /// 48 /// \return 49 /// True on success; false on failure, or if the functions have 50 /// already been installed. 51 bool Install(DiagnosticManager &diagnostic_manager, 52 ExecutionContext &exe_ctx) override; 53 54 bool DoCheckersExplainStop(lldb::addr_t addr, Stream &message) override; 55 56 std::shared_ptr<UtilityFunction> m_valid_pointer_check; 57 std::shared_ptr<UtilityFunction> m_objc_object_check; 58}; 59 60/// \class IRDynamicChecks IRDynamicChecks.h 61/// "lldb/Expression/IRDynamicChecks.h" Adds dynamic checks to a user-entered 62/// expression to reduce its likelihood of crashing 63/// 64/// When an IR function is executed in the target process, it may cause 65/// crashes or hangs by dereferencing NULL pointers, trying to call 66/// Objective-C methods on objects that do not respond to them, and so forth. 67/// 68/// IRDynamicChecks adds calls to the functions in DynamicCheckerFunctions to 69/// appropriate locations in an expression's IR. 70class IRDynamicChecks : public llvm::ModulePass { 71public: 72 /// Constructor 73 /// 74 /// \param[in] checker_functions 75 /// The checker functions for the target process. 76 /// 77 /// \param[in] func_name 78 /// The name of the function to prepare for execution in the target. 79 IRDynamicChecks(ClangDynamicCheckerFunctions &checker_functions, 80 const char *func_name = "$__lldb_expr"); 81 82 /// Destructor 83 ~IRDynamicChecks() override; 84 85 /// Run this IR transformer on a single module 86 /// 87 /// \param[in] M 88 /// The module to run on. This module is searched for the function 89 /// $__lldb_expr, and that function is passed to the passes one by 90 /// one. 91 /// 92 /// \return 93 /// True on success; false otherwise 94 bool runOnModule(llvm::Module &M) override; 95 96 /// Interface stub 97 void assignPassManager( 98 llvm::PMStack &PMS, 99 llvm::PassManagerType T = llvm::PMT_ModulePassManager) override; 100 101 /// Returns PMT_ModulePassManager 102 llvm::PassManagerType getPotentialPassManagerType() const override; 103 104private: 105 /// A basic block-level pass to find all pointer dereferences and 106 /// validate them before use. 107 108 /// The top-level pass implementation 109 /// 110 /// \param[in] M 111 /// The module currently being processed. 112 /// 113 /// \param[in] BB 114 /// The basic block currently being processed. 115 /// 116 /// \return 117 /// True on success; false otherwise 118 bool FindDataLoads(llvm::Module &M, llvm::BasicBlock &BB); 119 120 std::string m_func_name; ///< The name of the function to add checks to 121 ClangDynamicCheckerFunctions 122 &m_checker_functions; ///< The checker functions for the process 123}; 124 125} // namespace lldb_private 126 127#endif // liblldb_IRDynamicChecks_h_ 128