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
28 using namespace lldb_private;
29
30 char ClangUtilityFunction::ID;
31
ClangUtilityFunction(ExecutionContextScope & exe_scope,std::string text,std::string name,bool enable_debugging)32 ClangUtilityFunction::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("lldb", "expr", temp_fd, 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(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.
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
63 ClangUtilityFunction::~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.
Install(DiagnosticManager & diagnostic_manager,ExecutionContext & exe_ctx)75 bool ClangUtilityFunction::Install(DiagnosticManager &diagnostic_manager,
76 ExecutionContext &exe_ctx) {
77 if (m_jit_start_addr != LLDB_INVALID_ADDRESS) {
78 diagnostic_manager.PutString(eDiagnosticSeverityWarning,
79 "already installed");
80 return false;
81 }
82
83 ////////////////////////////////////
84 // Set up the target and compiler
85 //
86
87 Target *target = exe_ctx.GetTargetPtr();
88
89 if (!target) {
90 diagnostic_manager.PutString(eDiagnosticSeverityError, "invalid target");
91 return false;
92 }
93
94 Process *process = exe_ctx.GetProcessPtr();
95
96 if (!process) {
97 diagnostic_manager.PutString(eDiagnosticSeverityError, "invalid process");
98 return false;
99 }
100
101 // Since we might need to call allocate memory and maybe call code to make
102 // the caller, we need to be stopped.
103 if (process->GetState() != lldb::eStateStopped) {
104 diagnostic_manager.PutString(eDiagnosticSeverityError, "process running");
105 return false;
106 }
107 //////////////////////////
108 // Parse the expression
109 //
110
111 bool keep_result_in_memory = false;
112
113 ResetDeclMap(exe_ctx, keep_result_in_memory);
114
115 if (!DeclMap()->WillParse(exe_ctx, nullptr)) {
116 diagnostic_manager.PutString(
117 eDiagnosticSeverityError,
118 "current process state is unsuitable for expression parsing");
119 return false;
120 }
121
122 const bool generate_debug_info = true;
123 ClangExpressionParser parser(exe_ctx.GetBestExecutionContextScope(), *this,
124 generate_debug_info);
125
126 unsigned num_errors = parser.Parse(diagnostic_manager);
127
128 if (num_errors) {
129 ResetDeclMap();
130
131 return false;
132 }
133
134 //////////////////////////////////
135 // JIT the output of the parser
136 //
137
138 bool can_interpret = false; // should stay that way
139
140 Status jit_error = parser.PrepareForExecution(
141 m_jit_start_addr, m_jit_end_addr, m_execution_unit_sp, exe_ctx,
142 can_interpret, eExecutionPolicyAlways);
143
144 if (m_jit_start_addr != LLDB_INVALID_ADDRESS) {
145 m_jit_process_wp = process->shared_from_this();
146 if (parser.GetGenerateDebugInfo()) {
147 lldb::ModuleSP jit_module_sp(m_execution_unit_sp->GetJITModule());
148
149 if (jit_module_sp) {
150 ConstString const_func_name(FunctionName());
151 FileSpec jit_file;
152 jit_file.SetFilename(const_func_name);
153 jit_module_sp->SetFileSpecAndObjectName(jit_file, ConstString());
154 m_jit_module_wp = jit_module_sp;
155 target->GetImages().Append(jit_module_sp);
156 }
157 }
158 }
159
160 DeclMap()->DidParse();
161
162 ResetDeclMap();
163
164 if (jit_error.Success()) {
165 return true;
166 } else {
167 const char *error_cstr = jit_error.AsCString();
168 if (error_cstr && error_cstr[0]) {
169 diagnostic_manager.Printf(eDiagnosticSeverityError, "%s", error_cstr);
170 } else {
171 diagnostic_manager.PutString(eDiagnosticSeverityError,
172 "expression can't be interpreted or run");
173 }
174 return false;
175 }
176 }
177
178 char ClangUtilityFunction::ClangUtilityFunctionHelper::ID;
179
ResetDeclMap(ExecutionContext & exe_ctx,bool keep_result_in_memory)180 void ClangUtilityFunction::ClangUtilityFunctionHelper::ResetDeclMap(
181 ExecutionContext &exe_ctx, bool keep_result_in_memory) {
182 std::shared_ptr<ClangASTImporter> ast_importer;
183 auto *state = exe_ctx.GetTargetSP()->GetPersistentExpressionStateForLanguage(
184 lldb::eLanguageTypeC);
185 if (state) {
186 auto *persistent_vars = llvm::cast<ClangPersistentVariables>(state);
187 ast_importer = persistent_vars->GetClangASTImporter();
188 }
189 m_expr_decl_map_up = std::make_unique<ClangExpressionDeclMap>(
190 keep_result_in_memory, nullptr, exe_ctx.GetTargetSP(), ast_importer,
191 nullptr);
192 }
193