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