contrib/llvm-project/lldb/source/Expression/FunctionCaller.cpp

   1 //===-- FunctionCaller.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
  10 #include "lldb/Expression/FunctionCaller.h"
  11 #include "lldb/Core/Module.h"
  12 #include "lldb/Core/ValueObject.h"
  13 #include "lldb/Core/ValueObjectList.h"
  14 #include "lldb/Expression/DiagnosticManager.h"
  15 #include "lldb/Expression/IRExecutionUnit.h"
  16 #include "lldb/Interpreter/CommandReturnObject.h"
  17 #include "lldb/Symbol/Function.h"
  18 #include "lldb/Symbol/Type.h"
  19 #include "lldb/Target/ExecutionContext.h"
  20 #include "lldb/Target/Process.h"
  21 #include "lldb/Target/RegisterContext.h"
  22 #include "lldb/Target/Target.h"
  23 #include "lldb/Target/Thread.h"
  24 #include "lldb/Target/ThreadPlan.h"
  25 #include "lldb/Target/ThreadPlanCallFunction.h"
  26 #include "lldb/Utility/DataExtractor.h"
  27 #include "lldb/Utility/Log.h"
  28 #include "lldb/Utility/State.h"
  29
  30 using namespace lldb_private;
  31
  32 char FunctionCaller::ID;
  33
  34 // FunctionCaller constructor
  35 FunctionCaller::FunctionCaller(ExecutionContextScope &exe_scope,
  36                                const CompilerType &return_type,
  37                                const Address &functionAddress,
  38                                const ValueList &arg_value_list,
  39                                const char *name)
  40     : Expression(exe_scope), m_execution_unit_sp(), m_parser(),
  41       m_jit_module_wp(), m_name(name ? name : "<unknown>"),
  42       m_function_ptr(nullptr), m_function_addr(functionAddress),
  43       m_function_return_type(return_type),
  44       m_wrapper_function_name("__lldb_caller_function"),
  45       m_wrapper_struct_name("__lldb_caller_struct"), m_wrapper_args_addrs(),
  46       m_struct_valid(false), m_arg_values(arg_value_list), m_compiled(false),
  47       m_JITted(false) {
  48   m_jit_process_wp = lldb::ProcessWP(exe_scope.CalculateProcess());
  49   // Can't make a FunctionCaller without a process.
  50   assert(m_jit_process_wp.lock());
  51 }
  52
  53 // Destructor
  54 FunctionCaller::~FunctionCaller() {
  55   lldb::ProcessSP process_sp(m_jit_process_wp.lock());
  56   if (process_sp) {
  57     lldb::ModuleSP jit_module_sp(m_jit_module_wp.lock());
  58     if (jit_module_sp)
  59       process_sp->GetTarget().GetImages().Remove(jit_module_sp);
  60   }
  61 }
  62
  63 bool FunctionCaller::WriteFunctionWrapper(
  64     ExecutionContext &exe_ctx, DiagnosticManager &diagnostic_manager) {
  65   Process *process = exe_ctx.GetProcessPtr();
  66
  67   if (!process)
  68     return false;
  69
  70   lldb::ProcessSP jit_process_sp(m_jit_process_wp.lock());
  71
  72   if (process != jit_process_sp.get())
  73     return false;
  74
  75   if (!m_compiled)
  76     return false;
  77
  78   if (m_JITted)
  79     return true;
  80
  81   bool can_interpret = false; // should stay that way
  82
  83   Status jit_error(m_parser->PrepareForExecution(
  84       m_jit_start_addr, m_jit_end_addr, m_execution_unit_sp, exe_ctx,
  85       can_interpret, eExecutionPolicyAlways));
  86
  87   if (!jit_error.Success()) {
  88     diagnostic_manager.Printf(eDiagnosticSeverityError,
  89                               "Error in PrepareForExecution: %s.",
  90                               jit_error.AsCString());
  91     return false;
  92   }
  93
  94   if (m_parser->GetGenerateDebugInfo()) {
  95     lldb::ModuleSP jit_module_sp(m_execution_unit_sp->GetJITModule());
  96
  97     if (jit_module_sp) {
  98       ConstString const_func_name(FunctionName());
  99       FileSpec jit_file;
 100       jit_file.GetFilename() = const_func_name;
 101       jit_module_sp->SetFileSpecAndObjectName(jit_file, ConstString());
 102       m_jit_module_wp = jit_module_sp;
 103       process->GetTarget().GetImages().Append(jit_module_sp,
 104                                               true /* notify */);
 105     }
 106   }
 107   if (process && m_jit_start_addr)
 108     m_jit_process_wp = process->shared_from_this();
 109
 110   m_JITted = true;
 111
 112   return true;
 113 }
 114
 115 bool FunctionCaller::WriteFunctionArguments(
 116     ExecutionContext &exe_ctx, lldb::addr_t &args_addr_ref,
 117     DiagnosticManager &diagnostic_manager) {
 118   return WriteFunctionArguments(exe_ctx, args_addr_ref, m_arg_values,
 119                                 diagnostic_manager);
 120 }
 121
 122 // FIXME: Assure that the ValueList we were passed in is consistent with the one
 123 // that defined this function.
 124
 125 bool FunctionCaller::WriteFunctionArguments(
 126     ExecutionContext &exe_ctx, lldb::addr_t &args_addr_ref,
 127     ValueList &arg_values, DiagnosticManager &diagnostic_manager) {
 128   // All the information to reconstruct the struct is provided by the
 129   // StructExtractor.
 130   if (!m_struct_valid) {
 131     diagnostic_manager.PutString(eDiagnosticSeverityError,
 132                                  "Argument information was not correctly "
 133                                  "parsed, so the function cannot be called.");
 134     return false;
 135   }
 136
 137   Status error;
 138   lldb::ExpressionResults return_value = lldb::eExpressionSetupError;
 139
 140   Process *process = exe_ctx.GetProcessPtr();
 141
 142   if (process == nullptr)
 143     return return_value;
 144
 145   lldb::ProcessSP jit_process_sp(m_jit_process_wp.lock());
 146
 147   if (process != jit_process_sp.get())
 148     return false;
 149
 150   if (args_addr_ref == LLDB_INVALID_ADDRESS) {
 151     args_addr_ref = process->AllocateMemory(
 152         m_struct_size, lldb::ePermissionsReadable | lldb::ePermissionsWritable,
 153         error);
 154     if (args_addr_ref == LLDB_INVALID_ADDRESS)
 155       return false;
 156     m_wrapper_args_addrs.push_back(args_addr_ref);
 157   } else {
 158     // Make sure this is an address that we've already handed out.
 159     if (find(m_wrapper_args_addrs.begin(), m_wrapper_args_addrs.end(),
 160              args_addr_ref) == m_wrapper_args_addrs.end()) {
 161       return false;
 162     }
 163   }
 164
 165   // TODO: verify fun_addr needs to be a callable address
 166   Scalar fun_addr(
 167       m_function_addr.GetCallableLoadAddress(exe_ctx.GetTargetPtr()));
 168   uint64_t first_offset = m_member_offsets[0];
 169   process->WriteScalarToMemory(args_addr_ref + first_offset, fun_addr,
 170                                process->GetAddressByteSize(), error);
 171
 172   // FIXME: We will need to extend this for Variadic functions.
 173
 174   Status value_error;
 175
 176   size_t num_args = arg_values.GetSize();
 177   if (num_args != m_arg_values.GetSize()) {
 178     diagnostic_manager.Printf(
 179         eDiagnosticSeverityError,
 180         "Wrong number of arguments - was: %" PRIu64 " should be: %" PRIu64 "",
 181         (uint64_t)num_args, (uint64_t)m_arg_values.GetSize());
 182     return false;
 183   }
 184
 185   for (size_t i = 0; i < num_args; i++) {
 186     // FIXME: We should sanity check sizes.
 187
 188     uint64_t offset = m_member_offsets[i + 1]; // Clang sizes are in bytes.
 189     Value *arg_value = arg_values.GetValueAtIndex(i);
 190
 191     // FIXME: For now just do scalars:
 192
 193     // Special case: if it's a pointer, don't do anything (the ABI supports
 194     // passing cstrings)
 195
 196     if (arg_value->GetValueType() == Value::eValueTypeHostAddress &&
 197         arg_value->GetContextType() == Value::eContextTypeInvalid &&
 198         arg_value->GetCompilerType().IsPointerType())
 199       continue;
 200
 201     const Scalar &arg_scalar = arg_value->ResolveValue(&exe_ctx);
 202
 203     if (!process->WriteScalarToMemory(args_addr_ref + offset, arg_scalar,
 204                                       arg_scalar.GetByteSize(), error))
 205       return false;
 206   }
 207
 208   return true;
 209 }
 210
 211 bool FunctionCaller::InsertFunction(ExecutionContext &exe_ctx,
 212                                     lldb::addr_t &args_addr_ref,
 213                                     DiagnosticManager &diagnostic_manager) {
 214   if (CompileFunction(exe_ctx.GetThreadSP(), diagnostic_manager) != 0)
 215     return false;
 216   if (!WriteFunctionWrapper(exe_ctx, diagnostic_manager))
 217     return false;
 218   if (!WriteFunctionArguments(exe_ctx, args_addr_ref, diagnostic_manager))
 219     return false;
 220
 221   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 222   LLDB_LOGF(log, "Call Address: 0x%" PRIx64 " Struct Address: 0x%" PRIx64 ".\n",
 223             m_jit_start_addr, args_addr_ref);
 224
 225   return true;
 226 }
 227
 228 lldb::ThreadPlanSP FunctionCaller::GetThreadPlanToCallFunction(
 229     ExecutionContext &exe_ctx, lldb::addr_t args_addr,
 230     const EvaluateExpressionOptions &options,
 231     DiagnosticManager &diagnostic_manager) {
 232   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EXPRESSIONS |
 233                                                   LIBLLDB_LOG_STEP));
 234
 235   LLDB_LOGF(log,
 236             "-- [FunctionCaller::GetThreadPlanToCallFunction] Creating "
 237             "thread plan to call function \"%s\" --",
 238             m_name.c_str());
 239
 240   // FIXME: Use the errors Stream for better error reporting.
 241   Thread *thread = exe_ctx.GetThreadPtr();
 242   if (thread == nullptr) {
 243     diagnostic_manager.PutString(
 244         eDiagnosticSeverityError,
 245         "Can't call a function without a valid thread.");
 246     return nullptr;
 247   }
 248
 249   // Okay, now run the function:
 250
 251   Address wrapper_address(m_jit_start_addr);
 252
 253   lldb::addr_t args = {args_addr};
 254
 255   lldb::ThreadPlanSP new_plan_sp(new ThreadPlanCallFunction(
 256       *thread, wrapper_address, CompilerType(), args, options));
 257   new_plan_sp->SetIsMasterPlan(true);
 258   new_plan_sp->SetOkayToDiscard(false);
 259   return new_plan_sp;
 260 }
 261
 262 bool FunctionCaller::FetchFunctionResults(ExecutionContext &exe_ctx,
 263                                           lldb::addr_t args_addr,
 264                                           Value &ret_value) {
 265   // Read the return value - it is the last field in the struct:
 266   // FIXME: How does clang tell us there's no return value?  We need to handle
 267   // that case.
 268   // FIXME: Create our ThreadPlanCallFunction with the return CompilerType, and
 269   // then use GetReturnValueObject
 270   // to fetch the value.  That way we can fetch any values we need.
 271
 272   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EXPRESSIONS |
 273                                                   LIBLLDB_LOG_STEP));
 274
 275   LLDB_LOGF(log,
 276             "-- [FunctionCaller::FetchFunctionResults] Fetching function "
 277             "results for \"%s\"--",
 278             m_name.c_str());
 279
 280   Process *process = exe_ctx.GetProcessPtr();
 281
 282   if (process == nullptr)
 283     return false;
 284
 285   lldb::ProcessSP jit_process_sp(m_jit_process_wp.lock());
 286
 287   if (process != jit_process_sp.get())
 288     return false;
 289
 290   Status error;
 291   ret_value.GetScalar() = process->ReadUnsignedIntegerFromMemory(
 292       args_addr + m_return_offset, m_return_size, 0, error);
 293
 294   if (error.Fail())
 295     return false;
 296
 297   ret_value.SetCompilerType(m_function_return_type);
 298   ret_value.SetValueType(Value::eValueTypeScalar);
 299   return true;
 300 }
 301
 302 void FunctionCaller::DeallocateFunctionResults(ExecutionContext &exe_ctx,
 303                                                lldb::addr_t args_addr) {
 304   std::list<lldb::addr_t>::iterator pos;
 305   pos = std::find(m_wrapper_args_addrs.begin(), m_wrapper_args_addrs.end(),
 306                   args_addr);
 307   if (pos != m_wrapper_args_addrs.end())
 308     m_wrapper_args_addrs.erase(pos);
 309
 310   exe_ctx.GetProcessRef().DeallocateMemory(args_addr);
 311 }
 312
 313 lldb::ExpressionResults FunctionCaller::ExecuteFunction(
 314     ExecutionContext &exe_ctx, lldb::addr_t *args_addr_ptr,
 315     const EvaluateExpressionOptions &options,
 316     DiagnosticManager &diagnostic_manager, Value &results) {
 317   lldb::ExpressionResults return_value = lldb::eExpressionSetupError;
 318
 319   // FunctionCaller::ExecuteFunction execution is always just to get the
 320   // result. Do make sure we ignore breakpoints, unwind on error, and don't try
 321   // to debug it.
 322   EvaluateExpressionOptions real_options = options;
 323   real_options.SetDebug(false);
 324   real_options.SetUnwindOnError(true);
 325   real_options.SetIgnoreBreakpoints(true);
 326
 327   lldb::addr_t args_addr;
 328
 329   if (args_addr_ptr != nullptr)
 330     args_addr = *args_addr_ptr;
 331   else
 332     args_addr = LLDB_INVALID_ADDRESS;
 333
 334   if (CompileFunction(exe_ctx.GetThreadSP(), diagnostic_manager) != 0)
 335     return lldb::eExpressionSetupError;
 336
 337   if (args_addr == LLDB_INVALID_ADDRESS) {
 338     if (!InsertFunction(exe_ctx, args_addr, diagnostic_manager))
 339       return lldb::eExpressionSetupError;
 340   }
 341
 342   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EXPRESSIONS |
 343                                                   LIBLLDB_LOG_STEP));
 344
 345   LLDB_LOGF(log,
 346             "== [FunctionCaller::ExecuteFunction] Executing function \"%s\" ==",
 347             m_name.c_str());
 348
 349   lldb::ThreadPlanSP call_plan_sp = GetThreadPlanToCallFunction(
 350       exe_ctx, args_addr, real_options, diagnostic_manager);
 351   if (!call_plan_sp)
 352     return lldb::eExpressionSetupError;
 353
 354   // We need to make sure we record the fact that we are running an expression
 355   // here otherwise this fact will fail to be recorded when fetching an
 356   // Objective-C object description
 357   if (exe_ctx.GetProcessPtr())
 358     exe_ctx.GetProcessPtr()->SetRunningUserExpression(true);
 359
 360   return_value = exe_ctx.GetProcessRef().RunThreadPlan(
 361       exe_ctx, call_plan_sp, real_options, diagnostic_manager);
 362
 363   if (log) {
 364     if (return_value != lldb::eExpressionCompleted) {
 365       LLDB_LOGF(log,
 366                 "== [FunctionCaller::ExecuteFunction] Execution of \"%s\" "
 367                 "completed abnormally: %s ==",
 368                 m_name.c_str(),
 369                 Process::ExecutionResultAsCString(return_value));
 370     } else {
 371       LLDB_LOGF(log,
 372                 "== [FunctionCaller::ExecuteFunction] Execution of \"%s\" "
 373                 "completed normally ==",
 374                 m_name.c_str());
 375     }
 376   }
 377
 378   if (exe_ctx.GetProcessPtr())
 379     exe_ctx.GetProcessPtr()->SetRunningUserExpression(false);
 380
 381   if (args_addr_ptr != nullptr)
 382     *args_addr_ptr = args_addr;
 383
 384   if (return_value != lldb::eExpressionCompleted)
 385     return return_value;
 386
 387   FetchFunctionResults(exe_ctx, args_addr, results);
 388
 389   if (args_addr_ptr == nullptr)
 390     DeallocateFunctionResults(exe_ctx, args_addr);
 391
 392   return lldb::eExpressionCompleted;
 393 }