blob: 5b9c8007ab76333d70242a42ca3e6b83c3f83329 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
//===-- 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 liblldb_IRDynamicChecks_h_
#define liblldb_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 // liblldb_IRDynamicChecks_h_
|
