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/Core/StreamFile.h"
21 #include "lldb/Expression/IRExecutionUnit.h"
22 #include "lldb/Host/Host.h"
23 #include "lldb/Target/ExecutionContext.h"
24 #include "lldb/Target/Target.h"
25 #include "lldb/Utility/ConstString.h"
26 #include "lldb/Utility/Log.h"
27 #include "lldb/Utility/Stream.h"
28 
29 using namespace lldb_private;
30 
31 char ClangUtilityFunction::ID;
32 
33 ClangUtilityFunction::ClangUtilityFunction(ExecutionContextScope &exe_scope,
34                                            std::string text, std::string name,
35                                            bool enable_debugging)
36     : UtilityFunction(
37           exe_scope,
38           std::string(ClangExpressionSourceCode::g_expression_prefix) + text +
39               std::string(ClangExpressionSourceCode::g_expression_suffix),
40           std::move(name), enable_debugging) {
41   // Write the source code to a file so that LLDB's source manager can display
42   // it when debugging the code.
43   if (enable_debugging) {
44     int temp_fd = -1;
45     llvm::SmallString<128> result_path;
46     llvm::sys::fs::createTemporaryFile("lldb", "expr", temp_fd, result_path);
47     if (temp_fd != -1) {
48       lldb_private::NativeFile file(temp_fd, File::eOpenOptionWriteOnly, true);
49       text = "#line 1 \"" + std::string(result_path) + "\"\n" + text;
50       size_t bytes_written = text.size();
51       file.Write(text.c_str(), bytes_written);
52       if (bytes_written == text.size()) {
53         // If we successfully wrote the source to a temporary file, replace the
54         // function text with the next text containing the line directive.
55         m_function_text =
56             std::string(ClangExpressionSourceCode::g_expression_prefix) + text +
57             std::string(ClangExpressionSourceCode::g_expression_suffix);
58       }
59       file.Close();
60     }
61   }
62 }
63 
64 ClangUtilityFunction::~ClangUtilityFunction() = default;
65 
66 /// Install the utility function into a process
67 ///
68 /// \param[in] diagnostic_manager
69 ///     A diagnostic manager to report errors and warnings to.
70 ///
71 /// \param[in] exe_ctx
72 ///     The execution context to install the utility function to.
73 ///
74 /// \return
75 ///     True on success (no errors); false otherwise.
76 bool ClangUtilityFunction::Install(DiagnosticManager &diagnostic_manager,
77                                    ExecutionContext &exe_ctx) {
78   if (m_jit_start_addr != LLDB_INVALID_ADDRESS) {
79     diagnostic_manager.PutString(eDiagnosticSeverityWarning,
80                                  "already installed");
81     return false;
82   }
83 
84   ////////////////////////////////////
85   // Set up the target and compiler
86   //
87 
88   Target *target = exe_ctx.GetTargetPtr();
89 
90   if (!target) {
91     diagnostic_manager.PutString(eDiagnosticSeverityError, "invalid target");
92     return false;
93   }
94 
95   Process *process = exe_ctx.GetProcessPtr();
96 
97   if (!process) {
98     diagnostic_manager.PutString(eDiagnosticSeverityError, "invalid process");
99     return false;
100   }
101 
102   //////////////////////////
103   // Parse the expression
104   //
105 
106   bool keep_result_in_memory = false;
107 
108   ResetDeclMap(exe_ctx, keep_result_in_memory);
109 
110   if (!DeclMap()->WillParse(exe_ctx, nullptr)) {
111     diagnostic_manager.PutString(
112         eDiagnosticSeverityError,
113         "current process state is unsuitable for expression parsing");
114     return false;
115   }
116 
117   const bool generate_debug_info = true;
118   ClangExpressionParser parser(exe_ctx.GetBestExecutionContextScope(), *this,
119                                generate_debug_info);
120 
121   unsigned num_errors = parser.Parse(diagnostic_manager);
122 
123   if (num_errors) {
124     ResetDeclMap();
125 
126     return false;
127   }
128 
129   //////////////////////////////////
130   // JIT the output of the parser
131   //
132 
133   bool can_interpret = false; // should stay that way
134 
135   Status jit_error = parser.PrepareForExecution(
136       m_jit_start_addr, m_jit_end_addr, m_execution_unit_sp, exe_ctx,
137       can_interpret, eExecutionPolicyAlways);
138 
139   if (m_jit_start_addr != LLDB_INVALID_ADDRESS) {
140     m_jit_process_wp = process->shared_from_this();
141     if (parser.GetGenerateDebugInfo()) {
142       lldb::ModuleSP jit_module_sp(m_execution_unit_sp->GetJITModule());
143 
144       if (jit_module_sp) {
145         ConstString const_func_name(FunctionName());
146         FileSpec jit_file;
147         jit_file.GetFilename() = const_func_name;
148         jit_module_sp->SetFileSpecAndObjectName(jit_file, ConstString());
149         m_jit_module_wp = jit_module_sp;
150         target->GetImages().Append(jit_module_sp);
151       }
152     }
153   }
154 
155   DeclMap()->DidParse();
156 
157   ResetDeclMap();
158 
159   if (jit_error.Success()) {
160     return true;
161   } else {
162     const char *error_cstr = jit_error.AsCString();
163     if (error_cstr && error_cstr[0]) {
164       diagnostic_manager.Printf(eDiagnosticSeverityError, "%s", error_cstr);
165     } else {
166       diagnostic_manager.PutString(eDiagnosticSeverityError,
167                                    "expression can't be interpreted or run");
168     }
169     return false;
170   }
171 }
172 
173 void ClangUtilityFunction::ClangUtilityFunctionHelper::ResetDeclMap(
174     ExecutionContext &exe_ctx, bool keep_result_in_memory) {
175   std::shared_ptr<ClangASTImporter> ast_importer;
176   auto *state = exe_ctx.GetTargetSP()->GetPersistentExpressionStateForLanguage(
177       lldb::eLanguageTypeC);
178   if (state) {
179     auto *persistent_vars = llvm::cast<ClangPersistentVariables>(state);
180     ast_importer = persistent_vars->GetClangASTImporter();
181   }
182   m_expr_decl_map_up = std::make_unique<ClangExpressionDeclMap>(
183       keep_result_in_memory, nullptr, exe_ctx.GetTargetSP(), ast_importer,
184       nullptr);
185 }
186