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
9#include "ClangUtilityFunction.h"
10#include "ClangExpressionDeclMap.h"
11#include "ClangExpressionParser.h"
12#include "ClangExpressionSourceCode.h"
13#include "ClangPersistentVariables.h"
14
15#include <cstdio>
16#include <sys/types.h>
17
18
19#include "lldb/Core/Module.h"
20#include "lldb/Expression/IRExecutionUnit.h"
21#include "lldb/Host/Host.h"
22#include "lldb/Target/ExecutionContext.h"
23#include "lldb/Target/Target.h"
24#include "lldb/Utility/ConstString.h"
25#include "lldb/Utility/Log.h"
26#include "lldb/Utility/Stream.h"
27
28using namespace lldb_private;
29
30char ClangUtilityFunction::ID;
31
32ClangUtilityFunction::ClangUtilityFunction(ExecutionContextScope &exe_scope,
33 std::string text, std::string name,
34 bool enable_debugging)
35 : UtilityFunction(
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(Prefix: "lldb", Suffix: "expr", ResultFD&: temp_fd, ResultPath&: result_path);
46 if (temp_fd != -1) {
47 lldb_private::NativeFile file(temp_fd, File::eOpenOptionWriteOnly, true);
48 text = "#line 1 \"" + std::string(result_path) + "\"\n" + text;
49 size_t bytes_written = text.size();
50 file.Write(buf: text.c_str(), num_bytes&: 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.
54 m_function_text =
55 std::string(ClangExpressionSourceCode::g_expression_prefix) + text +
56 std::string(ClangExpressionSourceCode::g_expression_suffix);
57 }
58 file.Close();
59 }
60 }
61}
62
63ClangUtilityFunction::~ClangUtilityFunction() = default;
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.
75bool ClangUtilityFunction::Install(DiagnosticManager &diagnostic_manager,
76 ExecutionContext &exe_ctx) {
77 if (m_jit_start_addr != LLDB_INVALID_ADDRESS) {
78 diagnostic_manager.PutString(severity: lldb::eSeverityWarning, str: "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(severity: lldb::eSeverityError, str: "invalid target");
90 return false;
91 }
92
93 Process *process = exe_ctx.GetProcessPtr();
94
95 if (!process) {
96 diagnostic_manager.PutString(severity: lldb::eSeverityError, str: "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(severity: lldb::eSeverityError, str: "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, materializer: nullptr)) {
115 diagnostic_manager.PutString(
116 severity: lldb::eSeverityError,
117 str: "current process state is unsuitable for expression parsing");
118 return false;
119 }
120
121 const bool generate_debug_info = true;
122 ClangExpressionParser parser(exe_ctx.GetBestExecutionContextScope(), *this,
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(
140 func_addr&: m_jit_start_addr, func_end&: m_jit_end_addr, execution_unit_sp&: m_execution_unit_sp, exe_ctx,
141 can_interpret, execution_policy: eExecutionPolicyAlways);
142
143 if (m_jit_start_addr != LLDB_INVALID_ADDRESS) {
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(file: jit_file, object_name: ConstString());
153 m_jit_module_wp = jit_module_sp;
154 target->GetImages().Append(module_sp: 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(severity: lldb::eSeverityError, format: "%s", error_cstr);
169 } else {
170 diagnostic_manager.PutString(severity: lldb::eSeverityError,
171 str: "expression can't be interpreted or run");
172 }
173 return false;
174 }
175}
176
177char ClangUtilityFunction::ClangUtilityFunctionHelper::ID;
178
179void ClangUtilityFunction::ClangUtilityFunctionHelper::ResetDeclMap(
180 ExecutionContext &exe_ctx, bool keep_result_in_memory) {
181 std::shared_ptr<ClangASTImporter> ast_importer;
182 auto *state = exe_ctx.GetTargetSP()->GetPersistentExpressionStateForLanguage(
183 language: lldb::eLanguageTypeC);
184 if (state) {
185 auto *persistent_vars = llvm::cast<ClangPersistentVariables>(Val: state);
186 ast_importer = persistent_vars->GetClangASTImporter();
187 }
188 m_expr_decl_map_up = std::make_unique<ClangExpressionDeclMap>(
189 args&: keep_result_in_memory, args: nullptr, args: exe_ctx.GetTargetSP(), args&: ast_importer,
190 args: nullptr);
191}
192

source code of lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.cpp