1 //===-- UserExpression.cpp ---------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include <stdio.h> 11 #if HAVE_SYS_TYPES_H 12 # include <sys/types.h> 13 #endif 14 15 #include <cstdlib> 16 #include <string> 17 #include <map> 18 19 #include "lldb/Core/ConstString.h" 20 #include "lldb/Core/Log.h" 21 #include "lldb/Core/Module.h" 22 #include "lldb/Core/StreamFile.h" 23 #include "lldb/Core/StreamString.h" 24 #include "lldb/Core/ValueObjectConstResult.h" 25 #include "lldb/Expression/ExpressionSourceCode.h" 26 #include "lldb/Expression/IRExecutionUnit.h" 27 #include "lldb/Expression/IRInterpreter.h" 28 #include "lldb/Expression/Materializer.h" 29 #include "lldb/Expression/UserExpression.h" 30 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h" 31 #include "lldb/Host/HostInfo.h" 32 #include "lldb/Symbol/Block.h" 33 #include "lldb/Symbol/Function.h" 34 #include "lldb/Symbol/ObjectFile.h" 35 #include "lldb/Symbol/SymbolVendor.h" 36 #include "lldb/Symbol/Type.h" 37 #include "lldb/Symbol/TypeSystem.h" 38 #include "lldb/Symbol/VariableList.h" 39 #include "lldb/Target/ExecutionContext.h" 40 #include "lldb/Target/Process.h" 41 #include "lldb/Target/StackFrame.h" 42 #include "lldb/Target/Target.h" 43 #include "lldb/Target/ThreadPlan.h" 44 #include "lldb/Target/ThreadPlanCallUserExpression.h" 45 46 using namespace lldb_private; 47 48 UserExpression::UserExpression (ExecutionContextScope &exe_scope, 49 const char *expr, 50 const char *expr_prefix, 51 lldb::LanguageType language, 52 ResultType desired_type) : 53 Expression (exe_scope), 54 m_stack_frame_bottom (LLDB_INVALID_ADDRESS), 55 m_stack_frame_top (LLDB_INVALID_ADDRESS), 56 m_expr_text (expr), 57 m_expr_prefix (expr_prefix ? expr_prefix : ""), 58 m_language (language), 59 m_transformed_text (), 60 m_desired_type (desired_type), 61 m_execution_unit_sp(), 62 m_materializer_ap(), 63 m_jit_module_wp(), 64 m_enforce_valid_object (true), 65 m_in_cplusplus_method (false), 66 m_in_objectivec_method (false), 67 m_in_static_method(false), 68 m_needs_object_ptr (false), 69 m_const_object (false), 70 m_target (NULL), 71 m_can_interpret (false), 72 m_materialized_address (LLDB_INVALID_ADDRESS) 73 { 74 } 75 76 UserExpression::~UserExpression () 77 { 78 if (m_target) 79 { 80 lldb::ModuleSP jit_module_sp (m_jit_module_wp.lock()); 81 if (jit_module_sp) 82 m_target->GetImages().Remove(jit_module_sp); 83 } 84 } 85 86 void 87 UserExpression::InstallContext (ExecutionContext &exe_ctx) 88 { 89 m_jit_process_wp = exe_ctx.GetProcessSP(); 90 91 lldb::StackFrameSP frame_sp = exe_ctx.GetFrameSP(); 92 93 if (frame_sp) 94 m_address = frame_sp->GetFrameCodeAddress(); 95 } 96 97 bool 98 UserExpression::LockAndCheckContext (ExecutionContext &exe_ctx, 99 lldb::TargetSP &target_sp, 100 lldb::ProcessSP &process_sp, 101 lldb::StackFrameSP &frame_sp) 102 { 103 lldb::ProcessSP expected_process_sp = m_jit_process_wp.lock(); 104 process_sp = exe_ctx.GetProcessSP(); 105 106 if (process_sp != expected_process_sp) 107 return false; 108 109 process_sp = exe_ctx.GetProcessSP(); 110 target_sp = exe_ctx.GetTargetSP(); 111 frame_sp = exe_ctx.GetFrameSP(); 112 113 if (m_address.IsValid()) 114 { 115 if (!frame_sp) 116 return false; 117 else 118 return (0 == Address::CompareLoadAddress(m_address, frame_sp->GetFrameCodeAddress(), target_sp.get())); 119 } 120 121 return true; 122 } 123 124 bool 125 UserExpression::MatchesContext (ExecutionContext &exe_ctx) 126 { 127 lldb::TargetSP target_sp; 128 lldb::ProcessSP process_sp; 129 lldb::StackFrameSP frame_sp; 130 131 return LockAndCheckContext(exe_ctx, target_sp, process_sp, frame_sp); 132 } 133 134 lldb::addr_t 135 UserExpression::GetObjectPointer (lldb::StackFrameSP frame_sp, 136 ConstString &object_name, 137 Error &err) 138 { 139 err.Clear(); 140 141 if (!frame_sp) 142 { 143 err.SetErrorStringWithFormat("Couldn't load '%s' because the context is incomplete", object_name.AsCString()); 144 return LLDB_INVALID_ADDRESS; 145 } 146 147 lldb::VariableSP var_sp; 148 lldb::ValueObjectSP valobj_sp; 149 150 valobj_sp = frame_sp->GetValueForVariableExpressionPath(object_name.AsCString(), 151 lldb::eNoDynamicValues, 152 StackFrame::eExpressionPathOptionCheckPtrVsMember | 153 StackFrame::eExpressionPathOptionsNoFragileObjcIvar | 154 StackFrame::eExpressionPathOptionsNoSyntheticChildren | 155 StackFrame::eExpressionPathOptionsNoSyntheticArrayRange, 156 var_sp, 157 err); 158 159 if (!err.Success() || !valobj_sp.get()) 160 return LLDB_INVALID_ADDRESS; 161 162 lldb::addr_t ret = valobj_sp->GetValueAsUnsigned(LLDB_INVALID_ADDRESS); 163 164 if (ret == LLDB_INVALID_ADDRESS) 165 { 166 err.SetErrorStringWithFormat("Couldn't load '%s' because its value couldn't be evaluated", object_name.AsCString()); 167 return LLDB_INVALID_ADDRESS; 168 } 169 170 return ret; 171 } 172 173 bool 174 UserExpression::PrepareToExecuteJITExpression (Stream &error_stream, 175 ExecutionContext &exe_ctx, 176 lldb::addr_t &struct_address) 177 { 178 lldb::TargetSP target; 179 lldb::ProcessSP process; 180 lldb::StackFrameSP frame; 181 182 if (!LockAndCheckContext(exe_ctx, 183 target, 184 process, 185 frame)) 186 { 187 error_stream.Printf("The context has changed before we could JIT the expression!\n"); 188 return false; 189 } 190 191 if (m_jit_start_addr != LLDB_INVALID_ADDRESS || m_can_interpret) 192 { 193 if (m_materialized_address == LLDB_INVALID_ADDRESS) 194 { 195 Error alloc_error; 196 197 IRMemoryMap::AllocationPolicy policy = m_can_interpret ? IRMemoryMap::eAllocationPolicyHostOnly : IRMemoryMap::eAllocationPolicyMirror; 198 199 m_materialized_address = m_execution_unit_sp->Malloc(m_materializer_ap->GetStructByteSize(), 200 m_materializer_ap->GetStructAlignment(), 201 lldb::ePermissionsReadable | lldb::ePermissionsWritable, 202 policy, 203 alloc_error); 204 205 if (!alloc_error.Success()) 206 { 207 error_stream.Printf("Couldn't allocate space for materialized struct: %s\n", alloc_error.AsCString()); 208 return false; 209 } 210 } 211 212 struct_address = m_materialized_address; 213 214 if (m_can_interpret && m_stack_frame_bottom == LLDB_INVALID_ADDRESS) 215 { 216 Error alloc_error; 217 218 const size_t stack_frame_size = 512 * 1024; 219 220 m_stack_frame_bottom = m_execution_unit_sp->Malloc(stack_frame_size, 221 8, 222 lldb::ePermissionsReadable | lldb::ePermissionsWritable, 223 IRMemoryMap::eAllocationPolicyHostOnly, 224 alloc_error); 225 226 m_stack_frame_top = m_stack_frame_bottom + stack_frame_size; 227 228 if (!alloc_error.Success()) 229 { 230 error_stream.Printf("Couldn't allocate space for the stack frame: %s\n", alloc_error.AsCString()); 231 return false; 232 } 233 } 234 235 Error materialize_error; 236 237 m_dematerializer_sp = m_materializer_ap->Materialize(frame, *m_execution_unit_sp, struct_address, materialize_error); 238 239 if (!materialize_error.Success()) 240 { 241 error_stream.Printf("Couldn't materialize: %s\n", materialize_error.AsCString()); 242 return false; 243 } 244 } 245 return true; 246 } 247 248 bool 249 UserExpression::FinalizeJITExecution (Stream &error_stream, 250 ExecutionContext &exe_ctx, 251 lldb::ExpressionVariableSP &result, 252 lldb::addr_t function_stack_bottom, 253 lldb::addr_t function_stack_top) 254 { 255 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 256 257 if (log) 258 log->Printf("-- [UserExpression::FinalizeJITExecution] Dematerializing after execution --"); 259 260 if (!m_dematerializer_sp) 261 { 262 error_stream.Printf ("Couldn't apply expression side effects : no dematerializer is present"); 263 return false; 264 } 265 266 Error dematerialize_error; 267 268 m_dematerializer_sp->Dematerialize(dematerialize_error, function_stack_bottom, function_stack_top); 269 270 if (!dematerialize_error.Success()) 271 { 272 error_stream.Printf ("Couldn't apply expression side effects : %s\n", dematerialize_error.AsCString("unknown error")); 273 return false; 274 } 275 276 result = GetResultAfterDematerialization(exe_ctx.GetBestExecutionContextScope()); 277 278 if (result) 279 result->TransferAddress(); 280 281 m_dematerializer_sp.reset(); 282 283 return true; 284 } 285 286 lldb::ExpressionResults 287 UserExpression::Execute (Stream &error_stream, 288 ExecutionContext &exe_ctx, 289 const EvaluateExpressionOptions& options, 290 lldb::UserExpressionSP &shared_ptr_to_me, 291 lldb::ExpressionVariableSP &result) 292 { 293 // The expression log is quite verbose, and if you're just tracking the execution of the 294 // expression, it's quite convenient to have these logs come out with the STEP log as well. 295 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EXPRESSIONS | LIBLLDB_LOG_STEP)); 296 297 if (m_jit_start_addr != LLDB_INVALID_ADDRESS || m_can_interpret) 298 { 299 lldb::addr_t struct_address = LLDB_INVALID_ADDRESS; 300 301 if (!PrepareToExecuteJITExpression (error_stream, exe_ctx, struct_address)) 302 { 303 error_stream.Printf("Errored out in %s, couldn't PrepareToExecuteJITExpression", __FUNCTION__); 304 return lldb::eExpressionSetupError; 305 } 306 307 lldb::addr_t function_stack_bottom = LLDB_INVALID_ADDRESS; 308 lldb::addr_t function_stack_top = LLDB_INVALID_ADDRESS; 309 310 if (m_can_interpret) 311 { 312 llvm::Module *module = m_execution_unit_sp->GetModule(); 313 llvm::Function *function = m_execution_unit_sp->GetFunction(); 314 315 if (!module || !function) 316 { 317 error_stream.Printf("Supposed to interpret, but nothing is there"); 318 return lldb::eExpressionSetupError; 319 } 320 321 Error interpreter_error; 322 323 std::vector<lldb::addr_t> args; 324 325 if (!AddInitialArguments(exe_ctx, args, error_stream)) 326 { 327 error_stream.Printf ("Errored out in %s, couldn't AddInitialArguments", __FUNCTION__); 328 return lldb::eExpressionSetupError; 329 } 330 331 args.push_back(struct_address); 332 333 function_stack_bottom = m_stack_frame_bottom; 334 function_stack_top = m_stack_frame_top; 335 336 IRInterpreter::Interpret (*module, 337 *function, 338 args, 339 *m_execution_unit_sp.get(), 340 interpreter_error, 341 function_stack_bottom, 342 function_stack_top, 343 exe_ctx); 344 345 if (!interpreter_error.Success()) 346 { 347 error_stream.Printf("Supposed to interpret, but failed: %s", interpreter_error.AsCString()); 348 return lldb::eExpressionDiscarded; 349 } 350 } 351 else 352 { 353 if (!exe_ctx.HasThreadScope()) 354 { 355 error_stream.Printf("UserExpression::Execute called with no thread selected."); 356 return lldb::eExpressionSetupError; 357 } 358 359 Address wrapper_address (m_jit_start_addr); 360 361 std::vector<lldb::addr_t> args; 362 363 if (!AddInitialArguments(exe_ctx, args, error_stream)) 364 { 365 error_stream.Printf ("Errored out in %s, couldn't AddInitialArguments", __FUNCTION__); 366 return lldb::eExpressionSetupError; 367 } 368 369 args.push_back(struct_address); 370 371 lldb::ThreadPlanSP call_plan_sp(new ThreadPlanCallUserExpression (exe_ctx.GetThreadRef(), 372 wrapper_address, 373 args, 374 options, 375 shared_ptr_to_me)); 376 377 if (!call_plan_sp || !call_plan_sp->ValidatePlan (&error_stream)) 378 return lldb::eExpressionSetupError; 379 380 ThreadPlanCallUserExpression *user_expression_plan = static_cast<ThreadPlanCallUserExpression *>(call_plan_sp.get()); 381 382 lldb::addr_t function_stack_pointer = user_expression_plan->GetFunctionStackPointer(); 383 384 function_stack_bottom = function_stack_pointer - HostInfo::GetPageSize(); 385 function_stack_top = function_stack_pointer; 386 387 if (log) 388 log->Printf("-- [UserExpression::Execute] Execution of expression begins --"); 389 390 if (exe_ctx.GetProcessPtr()) 391 exe_ctx.GetProcessPtr()->SetRunningUserExpression(true); 392 393 lldb::ExpressionResults execution_result = exe_ctx.GetProcessRef().RunThreadPlan (exe_ctx, 394 call_plan_sp, 395 options, 396 error_stream); 397 398 if (exe_ctx.GetProcessPtr()) 399 exe_ctx.GetProcessPtr()->SetRunningUserExpression(false); 400 401 if (log) 402 log->Printf("-- [UserExpression::Execute] Execution of expression completed --"); 403 404 if (execution_result == lldb::eExpressionInterrupted || execution_result == lldb::eExpressionHitBreakpoint) 405 { 406 const char *error_desc = NULL; 407 408 if (call_plan_sp) 409 { 410 lldb::StopInfoSP real_stop_info_sp = call_plan_sp->GetRealStopInfo(); 411 if (real_stop_info_sp) 412 error_desc = real_stop_info_sp->GetDescription(); 413 } 414 if (error_desc) 415 error_stream.Printf ("Execution was interrupted, reason: %s.", error_desc); 416 else 417 error_stream.PutCString ("Execution was interrupted."); 418 419 if ((execution_result == lldb::eExpressionInterrupted && options.DoesUnwindOnError()) 420 || (execution_result == lldb::eExpressionHitBreakpoint && options.DoesIgnoreBreakpoints())) 421 error_stream.PutCString ("\nThe process has been returned to the state before expression evaluation."); 422 else 423 { 424 if (execution_result == lldb::eExpressionHitBreakpoint) 425 user_expression_plan->TransferExpressionOwnership(); 426 error_stream.PutCString ("\nThe process has been left at the point where it was interrupted, " 427 "use \"thread return -x\" to return to the state before expression evaluation."); 428 } 429 430 return execution_result; 431 } 432 else if (execution_result == lldb::eExpressionStoppedForDebug) 433 { 434 error_stream.PutCString ("Execution was halted at the first instruction of the expression " 435 "function because \"debug\" was requested.\n" 436 "Use \"thread return -x\" to return to the state before expression evaluation."); 437 return execution_result; 438 } 439 else if (execution_result != lldb::eExpressionCompleted) 440 { 441 error_stream.Printf ("Couldn't execute function; result was %s\n", Process::ExecutionResultAsCString (execution_result)); 442 return execution_result; 443 } 444 } 445 446 if (FinalizeJITExecution (error_stream, exe_ctx, result, function_stack_bottom, function_stack_top)) 447 { 448 return lldb::eExpressionCompleted; 449 } 450 else 451 { 452 return lldb::eExpressionResultUnavailable; 453 } 454 } 455 else 456 { 457 error_stream.Printf("Expression can't be run, because there is no JIT compiled function"); 458 return lldb::eExpressionSetupError; 459 } 460 } 461 462 lldb::ExpressionResults 463 UserExpression::Evaluate (ExecutionContext &exe_ctx, 464 const EvaluateExpressionOptions& options, 465 const char *expr_cstr, 466 const char *expr_prefix, 467 lldb::ValueObjectSP &result_valobj_sp, 468 Error &error) 469 { 470 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EXPRESSIONS | LIBLLDB_LOG_STEP)); 471 472 lldb_private::ExecutionPolicy execution_policy = options.GetExecutionPolicy(); 473 const lldb::LanguageType language = options.GetLanguage(); 474 const ResultType desired_type = options.DoesCoerceToId() ? UserExpression::eResultTypeId : UserExpression::eResultTypeAny; 475 lldb::ExpressionResults execution_results = lldb::eExpressionSetupError; 476 477 Target *target = exe_ctx.GetTargetPtr(); 478 if (!target) 479 { 480 if (log) 481 log->Printf("== [UserExpression::Evaluate] Passed a NULL target, can't run expressions."); 482 return lldb::eExpressionSetupError; 483 } 484 485 Process *process = exe_ctx.GetProcessPtr(); 486 487 if (process == NULL || process->GetState() != lldb::eStateStopped) 488 { 489 if (execution_policy == eExecutionPolicyAlways) 490 { 491 if (log) 492 log->Printf("== [UserExpression::Evaluate] Expression may not run, but is not constant =="); 493 494 error.SetErrorString ("expression needed to run but couldn't"); 495 496 return execution_results; 497 } 498 } 499 500 if (process == NULL || !process->CanJIT()) 501 execution_policy = eExecutionPolicyNever; 502 503 const char *full_prefix = NULL; 504 const char *option_prefix = options.GetPrefix(); 505 std::string full_prefix_storage; 506 if (expr_prefix && option_prefix) 507 { 508 full_prefix_storage.assign(expr_prefix); 509 full_prefix_storage.append(option_prefix); 510 if (!full_prefix_storage.empty()) 511 full_prefix = full_prefix_storage.c_str(); 512 } 513 else if (expr_prefix) 514 full_prefix = expr_prefix; 515 else 516 full_prefix = option_prefix; 517 518 lldb::UserExpressionSP user_expression_sp(target->GetUserExpressionForLanguage (expr_cstr, 519 full_prefix, 520 language, 521 desired_type, 522 error)); 523 if (error.Fail()) 524 { 525 if (log) 526 log->Printf ("== [UserExpression::Evaluate] Getting expression: %s ==", error.AsCString()); 527 return lldb::eExpressionSetupError; 528 } 529 530 StreamString error_stream; 531 532 if (log) 533 log->Printf("== [UserExpression::Evaluate] Parsing expression %s ==", expr_cstr); 534 535 const bool keep_expression_in_memory = true; 536 const bool generate_debug_info = options.GetGenerateDebugInfo(); 537 538 if (options.InvokeCancelCallback (lldb::eExpressionEvaluationParse)) 539 { 540 error.SetErrorString ("expression interrupted by callback before parse"); 541 result_valobj_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(), error); 542 return lldb::eExpressionInterrupted; 543 } 544 545 if (!user_expression_sp->Parse (error_stream, 546 exe_ctx, 547 execution_policy, 548 keep_expression_in_memory, 549 generate_debug_info)) 550 { 551 execution_results = lldb::eExpressionParseError; 552 if (error_stream.GetString().empty()) 553 error.SetExpressionError (execution_results, "expression failed to parse, unknown error"); 554 else 555 error.SetExpressionError (execution_results, error_stream.GetString().c_str()); 556 } 557 else 558 { 559 lldb::ExpressionVariableSP expr_result; 560 561 if (execution_policy == eExecutionPolicyNever && 562 !user_expression_sp->CanInterpret()) 563 { 564 if (log) 565 log->Printf("== [UserExpression::Evaluate] Expression may not run, but is not constant =="); 566 567 if (error_stream.GetString().empty()) 568 error.SetExpressionError (lldb::eExpressionSetupError, "expression needed to run but couldn't"); 569 } 570 else 571 { 572 if (options.InvokeCancelCallback (lldb::eExpressionEvaluationExecution)) 573 { 574 error.SetExpressionError (lldb::eExpressionInterrupted, "expression interrupted by callback before execution"); 575 result_valobj_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(), error); 576 return lldb::eExpressionInterrupted; 577 } 578 579 error_stream.GetString().clear(); 580 581 if (log) 582 log->Printf("== [UserExpression::Evaluate] Executing expression =="); 583 584 execution_results = user_expression_sp->Execute (error_stream, 585 exe_ctx, 586 options, 587 user_expression_sp, 588 expr_result); 589 590 if (options.GetResultIsInternal() && expr_result && process) 591 { 592 process->GetTarget().GetPersistentExpressionStateForLanguage(language)->RemovePersistentVariable (expr_result); 593 } 594 595 if (execution_results != lldb::eExpressionCompleted) 596 { 597 if (log) 598 log->Printf("== [UserExpression::Evaluate] Execution completed abnormally =="); 599 600 if (error_stream.GetString().empty()) 601 error.SetExpressionError (execution_results, "expression failed to execute, unknown error"); 602 else 603 error.SetExpressionError (execution_results, error_stream.GetString().c_str()); 604 } 605 else 606 { 607 if (expr_result) 608 { 609 result_valobj_sp = expr_result->GetValueObject(); 610 611 if (log) 612 log->Printf("== [UserExpression::Evaluate] Execution completed normally with result %s ==", 613 result_valobj_sp->GetValueAsCString()); 614 } 615 else 616 { 617 if (log) 618 log->Printf("== [UserExpression::Evaluate] Execution completed normally with no result =="); 619 620 error.SetError(UserExpression::kNoResult, lldb::eErrorTypeGeneric); 621 } 622 } 623 } 624 } 625 626 if (options.InvokeCancelCallback(lldb::eExpressionEvaluationComplete)) 627 { 628 error.SetExpressionError (lldb::eExpressionInterrupted, "expression interrupted by callback after complete"); 629 return lldb::eExpressionInterrupted; 630 } 631 632 if (result_valobj_sp.get() == NULL) 633 { 634 result_valobj_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(), error); 635 } 636 637 return execution_results; 638 } 639