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 "lldb/Host/Config.h"
10
11 #include "ClangUtilityFunction.h"
12 #include "ClangExpressionDeclMap.h"
13 #include "ClangExpressionParser.h"
14 #include "ClangExpressionSourceCode.h"
15 #include "ClangPersistentVariables.h"
16
17 #include <cstdio>
18 #if HAVE_SYS_TYPES_H
19 #include <sys/types.h>
20 #endif
21
22
23 #include "lldb/Core/Module.h"
24 #include "lldb/Core/StreamFile.h"
25 #include "lldb/Expression/IRExecutionUnit.h"
26 #include "lldb/Host/Host.h"
27 #include "lldb/Target/ExecutionContext.h"
28 #include "lldb/Target/Target.h"
29 #include "lldb/Utility/ConstString.h"
30 #include "lldb/Utility/Log.h"
31 #include "lldb/Utility/Stream.h"
32
33 using namespace lldb_private;
34
35 char ClangUtilityFunction::ID;
36
ClangUtilityFunction(ExecutionContextScope & exe_scope,std::string text,std::string name,bool enable_debugging)37 ClangUtilityFunction::ClangUtilityFunction(ExecutionContextScope &exe_scope,
38 std::string text, std::string name,
39 bool enable_debugging)
40 : UtilityFunction(
41 exe_scope,
42 std::string(ClangExpressionSourceCode::g_expression_prefix) + text +
43 std::string(ClangExpressionSourceCode::g_expression_suffix),
44 std::move(name), enable_debugging) {
45 // Write the source code to a file so that LLDB's source manager can display
46 // it when debugging the code.
47 if (enable_debugging) {
48 int temp_fd = -1;
49 llvm::SmallString<128> result_path;
50 llvm::sys::fs::createTemporaryFile("lldb", "expr", temp_fd, result_path);
51 if (temp_fd != -1) {
52 lldb_private::NativeFile file(temp_fd, File::eOpenOptionWrite, true);
53 text = "#line 1 \"" + std::string(result_path) + "\"\n" + text;
54 size_t bytes_written = text.size();
55 file.Write(text.c_str(), bytes_written);
56 if (bytes_written == text.size()) {
57 // If we successfully wrote the source to a temporary file, replace the
58 // function text with the next text containing the line directive.
59 m_function_text =
60 std::string(ClangExpressionSourceCode::g_expression_prefix) + text +
61 std::string(ClangExpressionSourceCode::g_expression_suffix);
62 }
63 file.Close();
64 }
65 }
66 }
67
68 ClangUtilityFunction::~ClangUtilityFunction() = default;
69
70 /// Install the utility function into a process
71 ///
72 /// \param[in] diagnostic_manager
73 /// A diagnostic manager to report errors and warnings to.
74 ///
75 /// \param[in] exe_ctx
76 /// The execution context to install the utility function to.
77 ///
78 /// \return
79 /// True on success (no errors); false otherwise.
Install(DiagnosticManager & diagnostic_manager,ExecutionContext & exe_ctx)80 bool ClangUtilityFunction::Install(DiagnosticManager &diagnostic_manager,
81 ExecutionContext &exe_ctx) {
82 if (m_jit_start_addr != LLDB_INVALID_ADDRESS) {
83 diagnostic_manager.PutString(eDiagnosticSeverityWarning,
84 "already installed");
85 return false;
86 }
87
88 ////////////////////////////////////
89 // Set up the target and compiler
90 //
91
92 Target *target = exe_ctx.GetTargetPtr();
93
94 if (!target) {
95 diagnostic_manager.PutString(eDiagnosticSeverityError, "invalid target");
96 return false;
97 }
98
99 Process *process = exe_ctx.GetProcessPtr();
100
101 if (!process) {
102 diagnostic_manager.PutString(eDiagnosticSeverityError, "invalid process");
103 return false;
104 }
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(
116 eDiagnosticSeverityError,
117 "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 m_jit_start_addr, m_jit_end_addr, m_execution_unit_sp, exe_ctx,
141 can_interpret, 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.GetFilename() = 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(eDiagnosticSeverityError, "%s", error_cstr);
169 } else {
170 diagnostic_manager.PutString(eDiagnosticSeverityError,
171 "expression can't be interpreted or run");
172 }
173 return false;
174 }
175 }
176
ResetDeclMap(ExecutionContext & exe_ctx,bool keep_result_in_memory)177 void ClangUtilityFunction::ClangUtilityFunctionHelper::ResetDeclMap(
178 ExecutionContext &exe_ctx, bool keep_result_in_memory) {
179 std::shared_ptr<ClangASTImporter> ast_importer;
180 auto *state = exe_ctx.GetTargetSP()->GetPersistentExpressionStateForLanguage(
181 lldb::eLanguageTypeC);
182 if (state) {
183 auto *persistent_vars = llvm::cast<ClangPersistentVariables>(state);
184 ast_importer = persistent_vars->GetClangASTImporter();
185 }
186 m_expr_decl_map_up = std::make_unique<ClangExpressionDeclMap>(
187 keep_result_in_memory, nullptr, exe_ctx.GetTargetSP(), ast_importer,
188 nullptr);
189 }
190