diff options
Diffstat (limited to 'include/lldb/Expression/UtilityFunction.h')
| -rw-r--r-- | include/lldb/Expression/UtilityFunction.h | 162 |
1 files changed, 162 insertions, 0 deletions
diff --git a/include/lldb/Expression/UtilityFunction.h b/include/lldb/Expression/UtilityFunction.h new file mode 100644 index 0000000..bee83d8 --- /dev/null +++ b/include/lldb/Expression/UtilityFunction.h @@ -0,0 +1,162 @@ +//===-- UtilityFunction.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_UtilityFunction_h_ +#define liblldb_UtilityFunction_h_ + +// C Includes +// C++ Includes +#include <memory> +#include <string> + +// Other libraries and framework includes +// Project includes +#include "lldb/lldb-forward.h" +#include "lldb/lldb-private.h" +#include "lldb/Expression/Expression.h" + +namespace lldb_private +{ + +//---------------------------------------------------------------------- +/// @class UtilityFunction UtilityFunction.h "lldb/Expression/UtilityFunction.h" +/// @brief Encapsulates a bit of source code that provides a function that is callable +/// +/// LLDB uses expressions for various purposes, notably to call functions +/// and as a backend for the expr command. UtilityFunction encapsulates +/// a self-contained function meant to be used from other code. Utility +/// functions can perform error-checking for ClangUserExpressions, +//---------------------------------------------------------------------- +class UtilityFunction : public Expression +{ +public: + //------------------------------------------------------------------ + /// Constructor + /// + /// @param[in] text + /// The text of the function. Must be a full translation unit. + /// + /// @param[in] name + /// The name of the function, as used in the text. + //------------------------------------------------------------------ + UtilityFunction (ExecutionContextScope &exe_scope, + const char *text, + const char *name); + + ~UtilityFunction() override; + + //------------------------------------------------------------------ + /// Install the utility function into a process + /// + /// @param[in] error_stream + /// A stream to print parse errors and warnings to. + /// + /// @param[in] exe_ctx + /// The execution context to install the utility function to. + /// + /// @return + /// True on success (no errors); false otherwise. + //------------------------------------------------------------------ + virtual bool + Install (Stream &error_stream, ExecutionContext &exe_ctx) = 0; + + //------------------------------------------------------------------ + /// Check whether the given PC is inside the function + /// + /// Especially useful if the function dereferences nullptr to indicate a failed + /// assert. + /// + /// @param[in] pc + /// The program counter to check. + /// + /// @return + /// True if the program counter falls within the function's bounds; + /// false if not (or the function is not JIT compiled) + //------------------------------------------------------------------ + bool + ContainsAddress (lldb::addr_t address) + { + // nothing is both >= LLDB_INVALID_ADDRESS and < LLDB_INVALID_ADDRESS, + // so this always returns false if the function is not JIT compiled yet + return (address >= m_jit_start_addr && address < m_jit_end_addr); + } + + //------------------------------------------------------------------ + /// Return the string that the parser should parse. Must be a full + /// translation unit. + //------------------------------------------------------------------ + const char * + Text() override + { + return m_function_text.c_str(); + } + + //------------------------------------------------------------------ + /// Return the function name that should be used for executing the + /// expression. Text() should contain the definition of this + /// function. + //------------------------------------------------------------------ + const char * + FunctionName() override + { + return m_function_name.c_str(); + } + + //------------------------------------------------------------------ + /// Return the object that the parser should use when registering + /// local variables. May be nullptr if the Expression doesn't care. + //------------------------------------------------------------------ + ExpressionVariableList * + LocalVariables () + { + return nullptr; + } + + //------------------------------------------------------------------ + /// Return true if validation code should be inserted into the + /// expression. + //------------------------------------------------------------------ + bool + NeedsValidation() override + { + return false; + } + + //------------------------------------------------------------------ + /// Return true if external variables in the expression should be + /// resolved. + //------------------------------------------------------------------ + bool + NeedsVariableResolution() override + { + return false; + } + + // This makes the function caller function. + FunctionCaller * + MakeFunctionCaller(const CompilerType &return_type, const ValueList &arg_value_list, Error &error); + + // This one retrieves the function caller that is already made. If you haven't made it yet, this returns nullptr + FunctionCaller * + GetFunctionCaller() + { + return m_caller_up.get(); + } + +protected: + std::shared_ptr<IRExecutionUnit> m_execution_unit_sp; + lldb::ModuleWP m_jit_module_wp; + std::string m_function_text; ///< The text of the function. Must be a well-formed translation unit. + std::string m_function_name; ///< The name of the function. + std::unique_ptr<FunctionCaller> m_caller_up; +}; + +} // namespace lldb_private + +#endif // liblldb_UtilityFunction_h_ |
