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

   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
  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.
  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
 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 }