blob: f31c03cfb9efa5ce70400d7e3775e5a9bfbdb226 [file] [log] [blame]
//===-- IRDynamicChecks.h ---------------------------------------------*- C++
//-*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_IRDynamicChecks_h_
#define liblldb_IRDynamicChecks_h_
#include "lldb/lldb-types.h"
#include "llvm/Pass.h"
namespace llvm {
class BasicBlock;
class CallInst;
class Constant;
class Function;
class Instruction;
class Module;
class DataLayout;
class Value;
}
namespace lldb_private {
class ClangExpressionDeclMap;
class ExecutionContext;
class Stream;
//----------------------------------------------------------------------
/// @class DynamicCheckerFunctions IRDynamicChecks.h
/// "lldb/Expression/IRDynamicChecks.h" Encapsulates dynamic check functions
/// used by expressions.
///
/// Each of the utility functions encapsulated in this class is responsible
/// for validating some data that an expression is about to use. Examples
/// are:
///
/// a = *b; // check that b is a valid pointer [b init]; // check that b
/// is a valid object to send "init" to
///
/// The class installs each checker function into the target process and makes
/// it available to IRDynamicChecks to use.
//----------------------------------------------------------------------
class DynamicCheckerFunctions {
public:
//------------------------------------------------------------------
/// Constructor
//------------------------------------------------------------------
DynamicCheckerFunctions();
//------------------------------------------------------------------
/// Destructor
//------------------------------------------------------------------
~DynamicCheckerFunctions();
//------------------------------------------------------------------
/// 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);
bool DoCheckersExplainStop(lldb::addr_t addr, Stream &message);
std::unique_ptr<UtilityFunction> m_valid_pointer_check;
std::unique_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.
///
/// @param[in] decl_map
/// The mapping used to look up entities in the target process. In
/// this case, used to find objc_msgSend
//------------------------------------------------------------------
IRDynamicChecks(DynamicCheckerFunctions &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
DynamicCheckerFunctions
&m_checker_functions; ///< The checker functions for the process
};
} // namespace lldb_private
#endif // liblldb_IRDynamicChecks_h_