LLDB mainline
ClangUtilityFunction.cpp
Go to the documentation of this file.
1//===-- ClangUtilityFunction.cpp ------------------------------------------===//
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
14
15#include <cstdio>
16#include <sys/types.h>
17
18
19#include "lldb/Core/Module.h"
21#include "lldb/Host/Host.h"
23#include "lldb/Target/Target.h"
25#include "lldb/Utility/Log.h"
26#include "lldb/Utility/Stream.h"
27
28using namespace lldb_private;
29
31
33 std::string text, std::string name,
34 bool enable_debugging)
36 exe_scope,
37 std::string(ClangExpressionSourceCode::g_expression_prefix) + text +
38 std::string(ClangExpressionSourceCode::g_expression_suffix),
39 std::move(name), enable_debugging) {
40 // Write the source code to a file so that LLDB's source manager can display
41 // it when debugging the code.
42 if (enable_debugging) {
43 int temp_fd = -1;
44 llvm::SmallString<128> result_path;
45 llvm::sys::fs::createTemporaryFile("lldb", "expr", temp_fd, result_path);
46 if (temp_fd != -1) {
48 text = "#line 1 \"" + std::string(result_path) + "\"\n" + text;
49 size_t bytes_written = text.size();
50 file.Write(text.c_str(), bytes_written);
51 if (bytes_written == text.size()) {
52 // If we successfully wrote the source to a temporary file, replace the
53 // function text with the next text containing the line directive.
57 }
58 file.Close();
59 }
60 }
61}
62
64
65/// Install the utility function into a process
66///
67/// \param[in] diagnostic_manager
68/// A diagnostic manager to report errors and warnings to.
69///
70/// \param[in] exe_ctx
71/// The execution context to install the utility function to.
72///
73/// \return
74/// True on success (no errors); false otherwise.
76 ExecutionContext &exe_ctx) {
78 diagnostic_manager.PutString(lldb::eSeverityWarning, "already installed");
79 return false;
80 }
81
82 ////////////////////////////////////
83 // Set up the target and compiler
84 //
85
86 Target *target = exe_ctx.GetTargetPtr();
87
88 if (!target) {
89 diagnostic_manager.PutString(lldb::eSeverityError, "invalid target");
90 return false;
91 }
92
93 Process *process = exe_ctx.GetProcessPtr();
94
95 if (!process) {
96 diagnostic_manager.PutString(lldb::eSeverityError, "invalid process");
97 return false;
98 }
99
100 // Since we might need to call allocate memory and maybe call code to make
101 // the caller, we need to be stopped.
102 if (process->GetState() != lldb::eStateStopped) {
103 diagnostic_manager.PutString(lldb::eSeverityError, "process running");
104 return false;
105 }
106 //////////////////////////
107 // Parse the expression
108 //
109
110 bool keep_result_in_memory = false;
111
112 ResetDeclMap(exe_ctx, keep_result_in_memory);
113
114 if (!DeclMap()->WillParse(exe_ctx, nullptr)) {
115 diagnostic_manager.PutString(
117 "current process state is unsuitable for expression parsing");
118 return false;
119 }
120
121 const bool generate_debug_info = true;
123 generate_debug_info);
124
125 unsigned num_errors = parser.Parse(diagnostic_manager);
126
127 if (num_errors) {
128 ResetDeclMap();
129
130 return false;
131 }
132
133 //////////////////////////////////
134 // JIT the output of the parser
135 //
136
137 bool can_interpret = false; // should stay that way
138
139 Status jit_error = parser.PrepareForExecution(
141 can_interpret, eExecutionPolicyAlways);
142
144 m_jit_process_wp = process->shared_from_this();
145 if (parser.GetGenerateDebugInfo()) {
146 lldb::ModuleSP jit_module_sp(m_execution_unit_sp->GetJITModule());
147
148 if (jit_module_sp) {
149 ConstString const_func_name(FunctionName());
150 FileSpec jit_file;
151 jit_file.SetFilename(const_func_name);
152 jit_module_sp->SetFileSpecAndObjectName(jit_file, ConstString());
153 m_jit_module_wp = jit_module_sp;
154 target->GetImages().Append(jit_module_sp);
155 }
156 }
157 }
158
159 DeclMap()->DidParse();
160
161 ResetDeclMap();
162
163 if (jit_error.Success()) {
164 return true;
165 } else {
166 const char *error_cstr = jit_error.AsCString();
167 if (error_cstr && error_cstr[0]) {
168 diagnostic_manager.Printf(lldb::eSeverityError, "%s", error_cstr);
169 } else {
170 diagnostic_manager.PutString(lldb::eSeverityError,
171 "expression can't be interpreted or run");
172 }
173 return false;
174 }
175}
176
178
180 ExecutionContext &exe_ctx, bool keep_result_in_memory) {
181 std::shared_ptr<ClangASTImporter> ast_importer;
182 auto *state = exe_ctx.GetTargetSP()->GetPersistentExpressionStateForLanguage(
184 if (state) {
185 auto *persistent_vars = llvm::cast<ClangPersistentVariables>(state);
186 ast_importer = persistent_vars->GetClangASTImporter();
187 }
188 m_expr_decl_map_up = std::make_unique<ClangExpressionDeclMap>(
189 keep_result_in_memory, nullptr, exe_ctx.GetTargetSP(), ast_importer,
190 nullptr);
191}
void DidParse()
Disable the state needed for parsing and IR transformation.
"lldb/Expression/ClangExpressionParser.h" Encapsulates an instance of Clang that can parse expression...
Status PrepareForExecution(lldb::addr_t &func_addr, lldb::addr_t &func_end, lldb::IRExecutionUnitSP &execution_unit_sp, ExecutionContext &exe_ctx, bool &can_interpret, lldb_private::ExecutionPolicy execution_policy) override
Ready an already-parsed expression for execution, possibly evaluating it statically.
unsigned Parse(DiagnosticManager &diagnostic_manager)
Parse a single expression and convert it to IR using Clang.
std::unique_ptr< ClangExpressionDeclMap > m_expr_decl_map_up
ClangExpressionDeclMap * DeclMap()
ClangUtilityFunction(ExecutionContextScope &exe_scope, std::string text, std::string name, bool enable_debugging)
Constructor.
bool Install(DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx) override
Install the utility function into a process.
A uniqued constant string class.
Definition: ConstString.h:40
size_t void PutString(lldb::Severity severity, llvm::StringRef str)
size_t Printf(lldb::Severity severity, const char *format,...) __attribute__((format(printf
"lldb/Target/ExecutionContextScope.h" Inherit from this if your object can reconstruct its execution ...
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
ExecutionContextScope * GetBestExecutionContextScope() const
const lldb::TargetSP & GetTargetSP() const
Get accessor to get the target shared pointer.
Target * GetTargetPtr() const
Returns a pointer to the target object.
Process * GetProcessPtr() const
Returns a pointer to the process object.
lldb::addr_t m_jit_end_addr
The address of the JITted function within the JIT allocation.
Definition: Expression.h:94
lldb::ProcessWP m_jit_process_wp
Expression's always have to have a target...
Definition: Expression.h:88
lldb::addr_t m_jit_start_addr
An expression might have a process, but it doesn't need to (e.g.
Definition: Expression.h:91
A file utility class.
Definition: FileSpec.h:56
void SetFilename(ConstString filename)
Filename string set accessor.
Definition: FileSpec.cpp:345
@ eOpenOptionWriteOnly
Definition: File.h:52
void Append(const lldb::ModuleSP &module_sp, bool notify=true)
Append a module to the module list.
Definition: ModuleList.cpp:247
Status Close() override
Flush any buffers and release any resources owned by the file.
Definition: File.cpp:315
Status Write(const void *buf, size_t &num_bytes) override
Write bytes from buf to a file at the current file position.
Definition: File.cpp:582
A plug-in interface definition class for debugging a process.
Definition: Process.h:341
lldb::StateType GetState()
Get accessor for the current process state.
Definition: Process.cpp:1301
An error handling class.
Definition: Status.h:44
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
Definition: Status.cpp:130
bool Success() const
Test for success condition.
Definition: Status.cpp:279
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition: Target.h:981
"lldb/Expression/UtilityFunction.h" Encapsulates a bit of source code that provides a function that i...
const char * FunctionName() override
Return the function name that should be used for executing the expression.
std::shared_ptr< IRExecutionUnit > m_execution_unit_sp
std::string m_function_text
The text of the function. Must be a well-formed translation unit.
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:82
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
@ eStateStopped
Process or thread is stopped and can be examined.
@ eLanguageTypeC
Non-standardized C, such as K&R.
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:365