1 //===-- ClangUserExpression.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 // C Includes 11 #include <stdio.h> 12 #if HAVE_SYS_TYPES_H 13 # include <sys/types.h> 14 #endif 15 16 // C++ Includes 17 #include <cstdlib> 18 #include <string> 19 #include <map> 20 21 #include "lldb/Core/ConstString.h" 22 #include "lldb/Core/Log.h" 23 #include "lldb/Core/StreamFile.h" 24 #include "lldb/Core/StreamString.h" 25 #include "lldb/Core/ValueObjectConstResult.h" 26 #include "lldb/Expression/ASTResultSynthesizer.h" 27 #include "lldb/Expression/ClangExpressionDeclMap.h" 28 #include "lldb/Expression/ClangExpressionParser.h" 29 #include "lldb/Expression/ClangFunction.h" 30 #include "lldb/Expression/ClangUserExpression.h" 31 #include "lldb/Expression/ExpressionSourceCode.h" 32 #include "lldb/Expression/IRExecutionUnit.h" 33 #include "lldb/Expression/IRInterpreter.h" 34 #include "lldb/Expression/Materializer.h" 35 #include "lldb/Host/Host.h" 36 #include "lldb/Symbol/Block.h" 37 #include "lldb/Symbol/ClangASTContext.h" 38 #include "lldb/Symbol/Function.h" 39 #include "lldb/Symbol/Type.h" 40 #include "lldb/Symbol/ClangExternalASTSourceCommon.h" 41 #include "lldb/Symbol/VariableList.h" 42 #include "lldb/Target/ExecutionContext.h" 43 #include "lldb/Target/Process.h" 44 #include "lldb/Target/StackFrame.h" 45 #include "lldb/Target/Target.h" 46 #include "lldb/Target/ThreadPlan.h" 47 #include "lldb/Target/ThreadPlanCallUserExpression.h" 48 49 #include "clang/AST/DeclCXX.h" 50 #include "clang/AST/DeclObjC.h" 51 52 using namespace lldb_private; 53 54 ClangUserExpression::ClangUserExpression (const char *expr, 55 const char *expr_prefix, 56 lldb::LanguageType language, 57 ResultType desired_type) : 58 ClangExpression (), 59 m_stack_frame_bottom (LLDB_INVALID_ADDRESS), 60 m_stack_frame_top (LLDB_INVALID_ADDRESS), 61 m_expr_text (expr), 62 m_expr_prefix (expr_prefix ? expr_prefix : ""), 63 m_language (language), 64 m_transformed_text (), 65 m_desired_type (desired_type), 66 m_enforce_valid_object (true), 67 m_cplusplus (false), 68 m_objectivec (false), 69 m_static_method(false), 70 m_needs_object_ptr (false), 71 m_const_object (false), 72 m_target (NULL), 73 m_can_interpret (false), 74 m_materialized_address (LLDB_INVALID_ADDRESS) 75 { 76 switch (m_language) 77 { 78 case lldb::eLanguageTypeC_plus_plus: 79 m_allow_cxx = true; 80 break; 81 case lldb::eLanguageTypeObjC: 82 m_allow_objc = true; 83 break; 84 case lldb::eLanguageTypeObjC_plus_plus: 85 default: 86 m_allow_cxx = true; 87 m_allow_objc = true; 88 break; 89 } 90 } 91 92 ClangUserExpression::~ClangUserExpression () 93 { 94 } 95 96 clang::ASTConsumer * 97 ClangUserExpression::ASTTransformer (clang::ASTConsumer *passthrough) 98 { 99 ClangASTContext *clang_ast_context = m_target->GetScratchClangASTContext(); 100 101 if (!clang_ast_context) 102 return NULL; 103 104 if (!m_result_synthesizer.get()) 105 m_result_synthesizer.reset(new ASTResultSynthesizer(passthrough, 106 *m_target)); 107 108 return m_result_synthesizer.get(); 109 } 110 111 void 112 ClangUserExpression::ScanContext(ExecutionContext &exe_ctx, Error &err) 113 { 114 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 115 116 if (log) 117 log->Printf("ClangUserExpression::ScanContext()"); 118 119 m_target = exe_ctx.GetTargetPtr(); 120 121 if (!(m_allow_cxx || m_allow_objc)) 122 { 123 if (log) 124 log->Printf(" [CUE::SC] Settings inhibit C++ and Objective-C"); 125 return; 126 } 127 128 StackFrame *frame = exe_ctx.GetFramePtr(); 129 if (frame == NULL) 130 { 131 if (log) 132 log->Printf(" [CUE::SC] Null stack frame"); 133 return; 134 } 135 136 SymbolContext sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction | lldb::eSymbolContextBlock); 137 138 if (!sym_ctx.function) 139 { 140 if (log) 141 log->Printf(" [CUE::SC] Null function"); 142 return; 143 } 144 145 // Find the block that defines the function represented by "sym_ctx" 146 Block *function_block = sym_ctx.GetFunctionBlock(); 147 148 if (!function_block) 149 { 150 if (log) 151 log->Printf(" [CUE::SC] Null function block"); 152 return; 153 } 154 155 clang::DeclContext *decl_context = function_block->GetClangDeclContext(); 156 157 if (!decl_context) 158 { 159 if (log) 160 log->Printf(" [CUE::SC] Null decl context"); 161 return; 162 } 163 164 if (clang::CXXMethodDecl *method_decl = llvm::dyn_cast<clang::CXXMethodDecl>(decl_context)) 165 { 166 if (m_allow_cxx && method_decl->isInstance()) 167 { 168 if (m_enforce_valid_object) 169 { 170 lldb::VariableListSP variable_list_sp (function_block->GetBlockVariableList (true)); 171 172 const char *thisErrorString = "Stopped in a C++ method, but 'this' isn't available; pretending we are in a generic context"; 173 174 if (!variable_list_sp) 175 { 176 err.SetErrorString(thisErrorString); 177 return; 178 } 179 180 lldb::VariableSP this_var_sp (variable_list_sp->FindVariable(ConstString("this"))); 181 182 if (!this_var_sp || 183 !this_var_sp->IsInScope(frame) || 184 !this_var_sp->LocationIsValidForFrame (frame)) 185 { 186 err.SetErrorString(thisErrorString); 187 return; 188 } 189 } 190 191 m_cplusplus = true; 192 m_needs_object_ptr = true; 193 } 194 } 195 else if (clang::ObjCMethodDecl *method_decl = llvm::dyn_cast<clang::ObjCMethodDecl>(decl_context)) 196 { 197 if (m_allow_objc) 198 { 199 if (m_enforce_valid_object) 200 { 201 lldb::VariableListSP variable_list_sp (function_block->GetBlockVariableList (true)); 202 203 const char *selfErrorString = "Stopped in an Objective-C method, but 'self' isn't available; pretending we are in a generic context"; 204 205 if (!variable_list_sp) 206 { 207 err.SetErrorString(selfErrorString); 208 return; 209 } 210 211 lldb::VariableSP self_variable_sp = variable_list_sp->FindVariable(ConstString("self")); 212 213 if (!self_variable_sp || 214 !self_variable_sp->IsInScope(frame) || 215 !self_variable_sp->LocationIsValidForFrame (frame)) 216 { 217 err.SetErrorString(selfErrorString); 218 return; 219 } 220 } 221 222 m_objectivec = true; 223 m_needs_object_ptr = true; 224 225 if (!method_decl->isInstanceMethod()) 226 m_static_method = true; 227 } 228 } 229 else if (clang::FunctionDecl *function_decl = llvm::dyn_cast<clang::FunctionDecl>(decl_context)) 230 { 231 // We might also have a function that said in the debug information that it captured an 232 // object pointer. The best way to deal with getting to the ivars at present it by pretending 233 // that this is a method of a class in whatever runtime the debug info says the object pointer 234 // belongs to. Do that here. 235 236 ClangASTMetadata *metadata = ClangASTContext::GetMetadata (&decl_context->getParentASTContext(), function_decl); 237 if (metadata && metadata->HasObjectPtr()) 238 { 239 lldb::LanguageType language = metadata->GetObjectPtrLanguage(); 240 if (language == lldb::eLanguageTypeC_plus_plus) 241 { 242 if (m_enforce_valid_object) 243 { 244 lldb::VariableListSP variable_list_sp (function_block->GetBlockVariableList (true)); 245 246 const char *thisErrorString = "Stopped in a context claiming to capture a C++ object pointer, but 'this' isn't available; pretending we are in a generic context"; 247 248 if (!variable_list_sp) 249 { 250 err.SetErrorString(thisErrorString); 251 return; 252 } 253 254 lldb::VariableSP this_var_sp (variable_list_sp->FindVariable(ConstString("this"))); 255 256 if (!this_var_sp || 257 !this_var_sp->IsInScope(frame) || 258 !this_var_sp->LocationIsValidForFrame (frame)) 259 { 260 err.SetErrorString(thisErrorString); 261 return; 262 } 263 } 264 265 m_cplusplus = true; 266 m_needs_object_ptr = true; 267 } 268 else if (language == lldb::eLanguageTypeObjC) 269 { 270 if (m_enforce_valid_object) 271 { 272 lldb::VariableListSP variable_list_sp (function_block->GetBlockVariableList (true)); 273 274 const char *selfErrorString = "Stopped in a context claiming to capture an Objective-C object pointer, but 'self' isn't available; pretending we are in a generic context"; 275 276 if (!variable_list_sp) 277 { 278 err.SetErrorString(selfErrorString); 279 return; 280 } 281 282 lldb::VariableSP self_variable_sp = variable_list_sp->FindVariable(ConstString("self")); 283 284 if (!self_variable_sp || 285 !self_variable_sp->IsInScope(frame) || 286 !self_variable_sp->LocationIsValidForFrame (frame)) 287 { 288 err.SetErrorString(selfErrorString); 289 return; 290 } 291 292 Type *self_type = self_variable_sp->GetType(); 293 294 if (!self_type) 295 { 296 err.SetErrorString(selfErrorString); 297 return; 298 } 299 300 ClangASTType self_clang_type = self_type->GetClangForwardType(); 301 302 if (!self_clang_type) 303 { 304 err.SetErrorString(selfErrorString); 305 return; 306 } 307 308 if (self_clang_type.IsObjCClassType()) 309 { 310 return; 311 } 312 else if (self_clang_type.IsObjCObjectPointerType()) 313 { 314 m_objectivec = true; 315 m_needs_object_ptr = true; 316 } 317 else 318 { 319 err.SetErrorString(selfErrorString); 320 return; 321 } 322 } 323 else 324 { 325 m_objectivec = true; 326 m_needs_object_ptr = true; 327 } 328 } 329 } 330 } 331 } 332 333 void 334 ClangUserExpression::InstallContext (ExecutionContext &exe_ctx) 335 { 336 m_process_wp = exe_ctx.GetProcessSP(); 337 338 lldb::StackFrameSP frame_sp = exe_ctx.GetFrameSP(); 339 340 if (frame_sp) 341 m_address = frame_sp->GetFrameCodeAddress(); 342 } 343 344 bool 345 ClangUserExpression::LockAndCheckContext (ExecutionContext &exe_ctx, 346 lldb::TargetSP &target_sp, 347 lldb::ProcessSP &process_sp, 348 lldb::StackFrameSP &frame_sp) 349 { 350 lldb::ProcessSP expected_process_sp = m_process_wp.lock(); 351 process_sp = exe_ctx.GetProcessSP(); 352 353 if (process_sp != expected_process_sp) 354 return false; 355 356 process_sp = exe_ctx.GetProcessSP(); 357 target_sp = exe_ctx.GetTargetSP(); 358 frame_sp = exe_ctx.GetFrameSP(); 359 360 if (m_address.IsValid()) 361 { 362 if (!frame_sp) 363 return false; 364 else 365 return (0 == Address::CompareLoadAddress(m_address, frame_sp->GetFrameCodeAddress(), target_sp.get())); 366 } 367 368 return true; 369 } 370 371 bool 372 ClangUserExpression::MatchesContext (ExecutionContext &exe_ctx) 373 { 374 lldb::TargetSP target_sp; 375 lldb::ProcessSP process_sp; 376 lldb::StackFrameSP frame_sp; 377 378 return LockAndCheckContext(exe_ctx, target_sp, process_sp, frame_sp); 379 } 380 381 // This is a really nasty hack, meant to fix Objective-C expressions of the form 382 // (int)[myArray count]. Right now, because the type information for count is 383 // not available, [myArray count] returns id, which can't be directly cast to 384 // int without causing a clang error. 385 static void 386 ApplyObjcCastHack(std::string &expr) 387 { 388 #define OBJC_CAST_HACK_FROM "(int)[" 389 #define OBJC_CAST_HACK_TO "(int)(long long)[" 390 391 size_t from_offset; 392 393 while ((from_offset = expr.find(OBJC_CAST_HACK_FROM)) != expr.npos) 394 expr.replace(from_offset, sizeof(OBJC_CAST_HACK_FROM) - 1, OBJC_CAST_HACK_TO); 395 396 #undef OBJC_CAST_HACK_TO 397 #undef OBJC_CAST_HACK_FROM 398 } 399 400 // Another hack, meant to allow use of unichar despite it not being available in 401 // the type information. Although we could special-case it in type lookup, 402 // hopefully we'll figure out a way to #include the same environment as is 403 // present in the original source file rather than try to hack specific type 404 // definitions in as needed. 405 static void 406 ApplyUnicharHack(std::string &expr) 407 { 408 #define UNICHAR_HACK_FROM "unichar" 409 #define UNICHAR_HACK_TO "unsigned short" 410 411 size_t from_offset; 412 413 while ((from_offset = expr.find(UNICHAR_HACK_FROM)) != expr.npos) 414 expr.replace(from_offset, sizeof(UNICHAR_HACK_FROM) - 1, UNICHAR_HACK_TO); 415 416 #undef UNICHAR_HACK_TO 417 #undef UNICHAR_HACK_FROM 418 } 419 420 bool 421 ClangUserExpression::Parse (Stream &error_stream, 422 ExecutionContext &exe_ctx, 423 lldb_private::ExecutionPolicy execution_policy, 424 bool keep_result_in_memory) 425 { 426 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 427 428 Error err; 429 430 InstallContext(exe_ctx); 431 432 ScanContext(exe_ctx, err); 433 434 if (!err.Success()) 435 { 436 error_stream.Printf("warning: %s\n", err.AsCString()); 437 } 438 439 StreamString m_transformed_stream; 440 441 //////////////////////////////////// 442 // Generate the expression 443 // 444 445 ApplyObjcCastHack(m_expr_text); 446 //ApplyUnicharHack(m_expr_text); 447 448 std::unique_ptr<ExpressionSourceCode> source_code (ExpressionSourceCode::CreateWrapped(m_expr_prefix.c_str(), m_expr_text.c_str())); 449 450 lldb::LanguageType lang_type; 451 452 if (m_cplusplus) 453 lang_type = lldb::eLanguageTypeC_plus_plus; 454 else if(m_objectivec) 455 lang_type = lldb::eLanguageTypeObjC; 456 else 457 lang_type = lldb::eLanguageTypeC; 458 459 if (!source_code->GetText(m_transformed_text, lang_type, m_const_object, m_static_method)) 460 { 461 error_stream.PutCString ("error: couldn't construct expression body"); 462 return false; 463 } 464 465 if (log) 466 log->Printf("Parsing the following code:\n%s", m_transformed_text.c_str()); 467 468 //////////////////////////////////// 469 // Set up the target and compiler 470 // 471 472 Target *target = exe_ctx.GetTargetPtr(); 473 474 if (!target) 475 { 476 error_stream.PutCString ("error: invalid target\n"); 477 return false; 478 } 479 480 ////////////////////////// 481 // Parse the expression 482 // 483 484 m_materializer_ap.reset(new Materializer()); 485 486 m_expr_decl_map.reset(new ClangExpressionDeclMap(keep_result_in_memory, exe_ctx)); 487 488 class OnExit 489 { 490 public: 491 typedef std::function <void (void)> Callback; 492 493 OnExit (Callback const &callback) : 494 m_callback(callback) 495 { 496 } 497 498 ~OnExit () 499 { 500 m_callback(); 501 } 502 private: 503 Callback m_callback; 504 }; 505 506 OnExit on_exit([this]() { m_expr_decl_map.reset(); }); 507 508 if (!m_expr_decl_map->WillParse(exe_ctx, m_materializer_ap.get())) 509 { 510 error_stream.PutCString ("error: current process state is unsuitable for expression parsing\n"); 511 return false; 512 } 513 514 Process *process = exe_ctx.GetProcessPtr(); 515 ExecutionContextScope *exe_scope = process; 516 517 if (!exe_scope) 518 exe_scope = exe_ctx.GetTargetPtr(); 519 520 ClangExpressionParser parser(exe_scope, *this); 521 522 unsigned num_errors = parser.Parse (error_stream); 523 524 if (num_errors) 525 { 526 error_stream.Printf ("error: %d errors parsing expression\n", num_errors); 527 528 m_expr_decl_map->DidParse(); 529 530 return false; 531 } 532 533 ////////////////////////////////////////////////////////////////////////////////////////// 534 // Prepare the output of the parser for execution, evaluating it statically if possible 535 // 536 537 Error jit_error = parser.PrepareForExecution (m_jit_start_addr, 538 m_jit_end_addr, 539 m_execution_unit_ap, 540 exe_ctx, 541 m_can_interpret, 542 execution_policy); 543 544 if (jit_error.Success()) 545 { 546 if (process && m_jit_start_addr != LLDB_INVALID_ADDRESS) 547 m_jit_process_wp = lldb::ProcessWP(process->shared_from_this()); 548 return true; 549 } 550 else 551 { 552 const char *error_cstr = jit_error.AsCString(); 553 if (error_cstr && error_cstr[0]) 554 error_stream.Printf ("error: %s\n", error_cstr); 555 else 556 error_stream.Printf ("error: expression can't be interpreted or run\n"); 557 return false; 558 } 559 } 560 561 static lldb::addr_t 562 GetObjectPointer (lldb::StackFrameSP frame_sp, 563 ConstString &object_name, 564 Error &err) 565 { 566 err.Clear(); 567 568 if (!frame_sp) 569 { 570 err.SetErrorStringWithFormat("Couldn't load '%s' because the context is incomplete", object_name.AsCString()); 571 return LLDB_INVALID_ADDRESS; 572 } 573 574 lldb::VariableSP var_sp; 575 lldb::ValueObjectSP valobj_sp; 576 577 valobj_sp = frame_sp->GetValueForVariableExpressionPath(object_name.AsCString(), 578 lldb::eNoDynamicValues, 579 StackFrame::eExpressionPathOptionCheckPtrVsMember || 580 StackFrame::eExpressionPathOptionsAllowDirectIVarAccess || 581 StackFrame::eExpressionPathOptionsNoFragileObjcIvar || 582 StackFrame::eExpressionPathOptionsNoSyntheticChildren || 583 StackFrame::eExpressionPathOptionsNoSyntheticArrayRange, 584 var_sp, 585 err); 586 587 if (!err.Success()) 588 return LLDB_INVALID_ADDRESS; 589 590 lldb::addr_t ret = valobj_sp->GetValueAsUnsigned(LLDB_INVALID_ADDRESS); 591 592 if (ret == LLDB_INVALID_ADDRESS) 593 { 594 err.SetErrorStringWithFormat("Couldn't load '%s' because its value couldn't be evaluated", object_name.AsCString()); 595 return LLDB_INVALID_ADDRESS; 596 } 597 598 return ret; 599 } 600 601 bool 602 ClangUserExpression::PrepareToExecuteJITExpression (Stream &error_stream, 603 ExecutionContext &exe_ctx, 604 lldb::addr_t &struct_address, 605 lldb::addr_t &object_ptr, 606 lldb::addr_t &cmd_ptr) 607 { 608 lldb::TargetSP target; 609 lldb::ProcessSP process; 610 lldb::StackFrameSP frame; 611 612 if (!LockAndCheckContext(exe_ctx, 613 target, 614 process, 615 frame)) 616 { 617 error_stream.Printf("The context has changed before we could JIT the expression!\n"); 618 return false; 619 } 620 621 if (m_jit_start_addr != LLDB_INVALID_ADDRESS || m_can_interpret) 622 { 623 if (m_needs_object_ptr) 624 { 625 ConstString object_name; 626 627 if (m_cplusplus) 628 { 629 object_name.SetCString("this"); 630 } 631 else if (m_objectivec) 632 { 633 object_name.SetCString("self"); 634 } 635 else 636 { 637 error_stream.Printf("Need object pointer but don't know the language\n"); 638 return false; 639 } 640 641 Error object_ptr_error; 642 643 object_ptr = GetObjectPointer(frame, object_name, object_ptr_error); 644 645 if (!object_ptr_error.Success()) 646 { 647 error_stream.Printf("warning: couldn't get required object pointer (substituting NULL): %s\n", object_ptr_error.AsCString()); 648 object_ptr = 0; 649 } 650 651 if (m_objectivec) 652 { 653 ConstString cmd_name("_cmd"); 654 655 cmd_ptr = GetObjectPointer(frame, cmd_name, object_ptr_error); 656 657 if (!object_ptr_error.Success()) 658 { 659 error_stream.Printf("warning: couldn't get cmd pointer (substituting NULL): %s\n", object_ptr_error.AsCString()); 660 cmd_ptr = 0; 661 } 662 } 663 } 664 665 if (m_materialized_address == LLDB_INVALID_ADDRESS) 666 { 667 Error alloc_error; 668 669 IRMemoryMap::AllocationPolicy policy = m_can_interpret ? IRMemoryMap::eAllocationPolicyHostOnly : IRMemoryMap::eAllocationPolicyMirror; 670 671 m_materialized_address = m_execution_unit_ap->Malloc(m_materializer_ap->GetStructByteSize(), 672 m_materializer_ap->GetStructAlignment(), 673 lldb::ePermissionsReadable | lldb::ePermissionsWritable, 674 policy, 675 alloc_error); 676 677 if (!alloc_error.Success()) 678 { 679 error_stream.Printf("Couldn't allocate space for materialized struct: %s\n", alloc_error.AsCString()); 680 return false; 681 } 682 } 683 684 struct_address = m_materialized_address; 685 686 if (m_can_interpret && m_stack_frame_bottom == LLDB_INVALID_ADDRESS) 687 { 688 Error alloc_error; 689 690 const size_t stack_frame_size = 512 * 1024; 691 692 m_stack_frame_bottom = m_execution_unit_ap->Malloc(stack_frame_size, 693 8, 694 lldb::ePermissionsReadable | lldb::ePermissionsWritable, 695 IRMemoryMap::eAllocationPolicyHostOnly, 696 alloc_error); 697 698 m_stack_frame_top = m_stack_frame_bottom + stack_frame_size; 699 700 if (!alloc_error.Success()) 701 { 702 error_stream.Printf("Couldn't allocate space for the stack frame: %s\n", alloc_error.AsCString()); 703 return false; 704 } 705 } 706 707 Error materialize_error; 708 709 m_dematerializer_sp = m_materializer_ap->Materialize(frame, *m_execution_unit_ap, struct_address, materialize_error); 710 711 if (!materialize_error.Success()) 712 { 713 error_stream.Printf("Couldn't materialize struct: %s\n", materialize_error.AsCString()); 714 return false; 715 } 716 } 717 return true; 718 } 719 720 ThreadPlan * 721 ClangUserExpression::GetThreadPlanToExecuteJITExpression (Stream &error_stream, 722 ExecutionContext &exe_ctx) 723 { 724 lldb::addr_t struct_address; 725 726 lldb::addr_t object_ptr = 0; 727 lldb::addr_t cmd_ptr = 0; 728 729 PrepareToExecuteJITExpression (error_stream, exe_ctx, struct_address, object_ptr, cmd_ptr); 730 731 // FIXME: This should really return a ThreadPlanCallUserExpression, in order to make sure that we don't release the 732 // ClangUserExpression resources before the thread plan finishes execution in the target. But because we are 733 // forcing unwind_on_error to be true here, in practical terms that can't happen. 734 735 const bool stop_others = true; 736 const bool unwind_on_error = true; 737 const bool ignore_breakpoints = false; 738 return ClangFunction::GetThreadPlanToCallFunction (exe_ctx, 739 m_jit_start_addr, 740 struct_address, 741 error_stream, 742 stop_others, 743 unwind_on_error, 744 ignore_breakpoints, 745 (m_needs_object_ptr ? &object_ptr : NULL), 746 (m_needs_object_ptr && m_objectivec) ? &cmd_ptr : NULL); 747 } 748 749 bool 750 ClangUserExpression::FinalizeJITExecution (Stream &error_stream, 751 ExecutionContext &exe_ctx, 752 lldb::ClangExpressionVariableSP &result, 753 lldb::addr_t function_stack_bottom, 754 lldb::addr_t function_stack_top) 755 { 756 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 757 758 if (log) 759 log->Printf("-- [ClangUserExpression::FinalizeJITExecution] Dematerializing after execution --"); 760 761 if (!m_dematerializer_sp) 762 { 763 error_stream.Printf ("Couldn't apply expression side effects : no dematerializer is present"); 764 return false; 765 } 766 767 Error dematerialize_error; 768 769 m_dematerializer_sp->Dematerialize(dematerialize_error, result, function_stack_bottom, function_stack_top); 770 771 if (!dematerialize_error.Success()) 772 { 773 error_stream.Printf ("Couldn't apply expression side effects : %s\n", dematerialize_error.AsCString("unknown error")); 774 return false; 775 } 776 777 if (result) 778 result->TransferAddress(); 779 780 m_dematerializer_sp.reset(); 781 782 return true; 783 } 784 785 ExecutionResults 786 ClangUserExpression::Execute (Stream &error_stream, 787 ExecutionContext &exe_ctx, 788 bool unwind_on_error, 789 bool ignore_breakpoints, 790 ClangUserExpression::ClangUserExpressionSP &shared_ptr_to_me, 791 lldb::ClangExpressionVariableSP &result, 792 bool run_others, 793 uint32_t timeout_usec) 794 { 795 // The expression log is quite verbose, and if you're just tracking the execution of the 796 // expression, it's quite convenient to have these logs come out with the STEP log as well. 797 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EXPRESSIONS | LIBLLDB_LOG_STEP)); 798 799 if (m_jit_start_addr != LLDB_INVALID_ADDRESS || m_can_interpret) 800 { 801 lldb::addr_t struct_address = LLDB_INVALID_ADDRESS; 802 803 lldb::addr_t object_ptr = 0; 804 lldb::addr_t cmd_ptr = 0; 805 806 if (!PrepareToExecuteJITExpression (error_stream, exe_ctx, struct_address, object_ptr, cmd_ptr)) 807 { 808 error_stream.Printf("Errored out in %s, couldn't PrepareToExecuteJITExpression", __FUNCTION__); 809 return eExecutionSetupError; 810 } 811 812 lldb::addr_t function_stack_bottom = LLDB_INVALID_ADDRESS; 813 lldb::addr_t function_stack_top = LLDB_INVALID_ADDRESS; 814 815 if (m_can_interpret) 816 { 817 llvm::Module *module = m_execution_unit_ap->GetModule(); 818 llvm::Function *function = m_execution_unit_ap->GetFunction(); 819 820 if (!module || !function) 821 { 822 error_stream.Printf("Supposed to interpret, but nothing is there"); 823 return eExecutionSetupError; 824 } 825 826 Error interpreter_error; 827 828 llvm::SmallVector <lldb::addr_t, 3> args; 829 830 if (m_needs_object_ptr) 831 { 832 args.push_back(object_ptr); 833 834 if (m_objectivec) 835 args.push_back(cmd_ptr); 836 } 837 838 args.push_back(struct_address); 839 840 function_stack_bottom = m_stack_frame_bottom; 841 function_stack_top = m_stack_frame_top; 842 843 IRInterpreter::Interpret (*module, 844 *function, 845 args, 846 *m_execution_unit_ap.get(), 847 interpreter_error, 848 function_stack_bottom, 849 function_stack_top); 850 851 if (!interpreter_error.Success()) 852 { 853 error_stream.Printf("Supposed to interpret, but failed: %s", interpreter_error.AsCString()); 854 return eExecutionDiscarded; 855 } 856 } 857 else 858 { 859 const bool stop_others = true; 860 const bool try_all_threads = run_others; 861 862 Address wrapper_address (m_jit_start_addr); 863 lldb::ThreadPlanSP call_plan_sp(new ThreadPlanCallUserExpression (exe_ctx.GetThreadRef(), 864 wrapper_address, 865 struct_address, 866 stop_others, 867 unwind_on_error, 868 ignore_breakpoints, 869 (m_needs_object_ptr ? &object_ptr : NULL), 870 ((m_needs_object_ptr && m_objectivec) ? &cmd_ptr : NULL), 871 shared_ptr_to_me)); 872 873 if (!call_plan_sp || !call_plan_sp->ValidatePlan (&error_stream)) 874 return eExecutionSetupError; 875 876 lldb::addr_t function_stack_pointer = static_cast<ThreadPlanCallFunction *>(call_plan_sp.get())->GetFunctionStackPointer(); 877 878 function_stack_bottom = function_stack_pointer - Host::GetPageSize(); 879 function_stack_top = function_stack_pointer; 880 881 if (log) 882 log->Printf("-- [ClangUserExpression::Execute] Execution of expression begins --"); 883 884 if (exe_ctx.GetProcessPtr()) 885 exe_ctx.GetProcessPtr()->SetRunningUserExpression(true); 886 887 ExecutionResults execution_result = exe_ctx.GetProcessRef().RunThreadPlan (exe_ctx, 888 call_plan_sp, 889 stop_others, 890 try_all_threads, 891 unwind_on_error, 892 ignore_breakpoints, 893 timeout_usec, 894 error_stream); 895 896 if (exe_ctx.GetProcessPtr()) 897 exe_ctx.GetProcessPtr()->SetRunningUserExpression(false); 898 899 if (log) 900 log->Printf("-- [ClangUserExpression::Execute] Execution of expression completed --"); 901 902 if (execution_result == eExecutionInterrupted || execution_result == eExecutionHitBreakpoint) 903 { 904 const char *error_desc = NULL; 905 906 if (call_plan_sp) 907 { 908 lldb::StopInfoSP real_stop_info_sp = call_plan_sp->GetRealStopInfo(); 909 if (real_stop_info_sp) 910 error_desc = real_stop_info_sp->GetDescription(); 911 } 912 if (error_desc) 913 error_stream.Printf ("Execution was interrupted, reason: %s.", error_desc); 914 else 915 error_stream.Printf ("Execution was interrupted."); 916 917 if ((execution_result == eExecutionInterrupted && unwind_on_error) 918 || (execution_result == eExecutionHitBreakpoint && ignore_breakpoints)) 919 error_stream.Printf ("\nThe process has been returned to the state before expression evaluation."); 920 else 921 error_stream.Printf ("\nThe process has been left at the point where it was interrupted, use \"thread return -x\" to return to the state before expression evaluation."); 922 923 return execution_result; 924 } 925 else if (execution_result != eExecutionCompleted) 926 { 927 error_stream.Printf ("Couldn't execute function; result was %s\n", Process::ExecutionResultAsCString (execution_result)); 928 return execution_result; 929 } 930 } 931 932 if (FinalizeJITExecution (error_stream, exe_ctx, result, function_stack_bottom, function_stack_top)) 933 { 934 return eExecutionCompleted; 935 } 936 else 937 { 938 return eExecutionSetupError; 939 } 940 } 941 else 942 { 943 error_stream.Printf("Expression can't be run, because there is no JIT compiled function"); 944 return eExecutionSetupError; 945 } 946 } 947 948 ExecutionResults 949 ClangUserExpression::Evaluate (ExecutionContext &exe_ctx, 950 lldb_private::ExecutionPolicy execution_policy, 951 lldb::LanguageType language, 952 ResultType desired_type, 953 bool unwind_on_error, 954 bool ignore_breakpoints, 955 const char *expr_cstr, 956 const char *expr_prefix, 957 lldb::ValueObjectSP &result_valobj_sp, 958 bool run_others, 959 uint32_t timeout_usec) 960 { 961 Error error; 962 return EvaluateWithError (exe_ctx, 963 execution_policy, 964 language, 965 desired_type, 966 unwind_on_error, 967 ignore_breakpoints, 968 expr_cstr, 969 expr_prefix, 970 result_valobj_sp, 971 error, 972 run_others, 973 timeout_usec); 974 } 975 976 ExecutionResults 977 ClangUserExpression::EvaluateWithError (ExecutionContext &exe_ctx, 978 lldb_private::ExecutionPolicy execution_policy, 979 lldb::LanguageType language, 980 ResultType desired_type, 981 bool unwind_on_error, 982 bool ignore_breakpoints, 983 const char *expr_cstr, 984 const char *expr_prefix, 985 lldb::ValueObjectSP &result_valobj_sp, 986 Error &error, 987 bool run_others, 988 uint32_t timeout_usec) 989 { 990 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EXPRESSIONS | LIBLLDB_LOG_STEP)); 991 992 ExecutionResults execution_results = eExecutionSetupError; 993 994 Process *process = exe_ctx.GetProcessPtr(); 995 996 if (process == NULL || process->GetState() != lldb::eStateStopped) 997 { 998 if (execution_policy == eExecutionPolicyAlways) 999 { 1000 if (log) 1001 log->Printf("== [ClangUserExpression::Evaluate] Expression may not run, but is not constant =="); 1002 1003 error.SetErrorString ("expression needed to run but couldn't"); 1004 1005 return execution_results; 1006 } 1007 } 1008 1009 if (process == NULL || !process->CanJIT()) 1010 execution_policy = eExecutionPolicyNever; 1011 1012 ClangUserExpressionSP user_expression_sp (new ClangUserExpression (expr_cstr, expr_prefix, language, desired_type)); 1013 1014 StreamString error_stream; 1015 1016 if (log) 1017 log->Printf("== [ClangUserExpression::Evaluate] Parsing expression %s ==", expr_cstr); 1018 1019 const bool keep_expression_in_memory = true; 1020 1021 if (!user_expression_sp->Parse (error_stream, exe_ctx, execution_policy, keep_expression_in_memory)) 1022 { 1023 if (error_stream.GetString().empty()) 1024 error.SetErrorString ("expression failed to parse, unknown error"); 1025 else 1026 error.SetErrorString (error_stream.GetString().c_str()); 1027 } 1028 else 1029 { 1030 lldb::ClangExpressionVariableSP expr_result; 1031 1032 if (execution_policy == eExecutionPolicyNever && 1033 !user_expression_sp->CanInterpret()) 1034 { 1035 if (log) 1036 log->Printf("== [ClangUserExpression::Evaluate] Expression may not run, but is not constant =="); 1037 1038 if (error_stream.GetString().empty()) 1039 error.SetErrorString ("expression needed to run but couldn't"); 1040 } 1041 else 1042 { 1043 error_stream.GetString().clear(); 1044 1045 if (log) 1046 log->Printf("== [ClangUserExpression::Evaluate] Executing expression =="); 1047 1048 execution_results = user_expression_sp->Execute (error_stream, 1049 exe_ctx, 1050 unwind_on_error, 1051 ignore_breakpoints, 1052 user_expression_sp, 1053 expr_result, 1054 run_others, 1055 timeout_usec); 1056 1057 if (execution_results != eExecutionCompleted) 1058 { 1059 if (log) 1060 log->Printf("== [ClangUserExpression::Evaluate] Execution completed abnormally =="); 1061 1062 if (error_stream.GetString().empty()) 1063 error.SetErrorString ("expression failed to execute, unknown error"); 1064 else 1065 error.SetErrorString (error_stream.GetString().c_str()); 1066 } 1067 else 1068 { 1069 if (expr_result) 1070 { 1071 result_valobj_sp = expr_result->GetValueObject(); 1072 1073 if (log) 1074 log->Printf("== [ClangUserExpression::Evaluate] Execution completed normally with result %s ==", result_valobj_sp->GetValueAsCString()); 1075 } 1076 else 1077 { 1078 if (log) 1079 log->Printf("== [ClangUserExpression::Evaluate] Execution completed normally with no result =="); 1080 1081 error.SetError(ClangUserExpression::kNoResult, lldb::eErrorTypeGeneric); 1082 } 1083 } 1084 } 1085 } 1086 1087 if (result_valobj_sp.get() == NULL) 1088 result_valobj_sp = ValueObjectConstResult::Create (NULL, error); 1089 1090 return execution_results; 1091 } 1092
