1 //===-- SBFrame.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 "lldb/API/SBFrame.h" 11 12 #include <string> 13 #include <algorithm> 14 15 #include "lldb/lldb-types.h" 16 17 #include "lldb/Core/Address.h" 18 #include "lldb/Core/ConstString.h" 19 #include "lldb/Core/Log.h" 20 #include "lldb/Core/Stream.h" 21 #include "lldb/Core/StreamFile.h" 22 #include "lldb/Core/ValueObjectRegister.h" 23 #include "lldb/Core/ValueObjectVariable.h" 24 #include "lldb/Expression/ClangUserExpression.h" 25 #include "lldb/Host/Host.h" 26 #include "lldb/Symbol/Block.h" 27 #include "lldb/Symbol/Function.h" 28 #include "lldb/Symbol/Symbol.h" 29 #include "lldb/Symbol/SymbolContext.h" 30 #include "lldb/Symbol/VariableList.h" 31 #include "lldb/Symbol/Variable.h" 32 #include "lldb/Target/ExecutionContext.h" 33 #include "lldb/Target/Target.h" 34 #include "lldb/Target/Process.h" 35 #include "lldb/Target/RegisterContext.h" 36 #include "lldb/Target/StackFrame.h" 37 #include "lldb/Target/StackID.h" 38 #include "lldb/Target/Thread.h" 39 40 #include "lldb/API/SBDebugger.h" 41 #include "lldb/API/SBValue.h" 42 #include "lldb/API/SBAddress.h" 43 #include "lldb/API/SBExpressionOptions.h" 44 #include "lldb/API/SBStream.h" 45 #include "lldb/API/SBSymbolContext.h" 46 #include "lldb/API/SBThread.h" 47 48 using namespace lldb; 49 using namespace lldb_private; 50 51 SBFrame()52 SBFrame::SBFrame () : 53 m_opaque_sp (new ExecutionContextRef()) 54 { 55 } 56 SBFrame(const StackFrameSP & lldb_object_sp)57 SBFrame::SBFrame (const StackFrameSP &lldb_object_sp) : 58 m_opaque_sp (new ExecutionContextRef (lldb_object_sp)) 59 { 60 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 61 62 if (log) 63 { 64 SBStream sstr; 65 GetDescription (sstr); 66 log->Printf ("SBFrame::SBFrame (sp=%p) => SBFrame(%p): %s", 67 lldb_object_sp.get(), lldb_object_sp.get(), sstr.GetData()); 68 69 } 70 } 71 SBFrame(const SBFrame & rhs)72 SBFrame::SBFrame(const SBFrame &rhs) : 73 m_opaque_sp (new ExecutionContextRef (*rhs.m_opaque_sp)) 74 { 75 } 76 77 const SBFrame & operator =(const SBFrame & rhs)78 SBFrame::operator = (const SBFrame &rhs) 79 { 80 if (this != &rhs) 81 *m_opaque_sp = *rhs.m_opaque_sp; 82 return *this; 83 } 84 ~SBFrame()85 SBFrame::~SBFrame() 86 { 87 } 88 89 StackFrameSP GetFrameSP() const90 SBFrame::GetFrameSP() const 91 { 92 if (m_opaque_sp) 93 return m_opaque_sp->GetFrameSP(); 94 return StackFrameSP(); 95 } 96 97 void SetFrameSP(const StackFrameSP & lldb_object_sp)98 SBFrame::SetFrameSP (const StackFrameSP &lldb_object_sp) 99 { 100 return m_opaque_sp->SetFrameSP(lldb_object_sp); 101 } 102 103 bool IsValid() const104 SBFrame::IsValid() const 105 { 106 return GetFrameSP().get() != NULL; 107 } 108 109 SBSymbolContext GetSymbolContext(uint32_t resolve_scope) const110 SBFrame::GetSymbolContext (uint32_t resolve_scope) const 111 { 112 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 113 SBSymbolContext sb_sym_ctx; 114 Mutex::Locker api_locker; 115 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 116 117 StackFrame *frame = NULL; 118 Target *target = exe_ctx.GetTargetPtr(); 119 Process *process = exe_ctx.GetProcessPtr(); 120 if (target && process) 121 { 122 Process::StopLocker stop_locker; 123 if (stop_locker.TryLock(&process->GetRunLock())) 124 { 125 frame = exe_ctx.GetFramePtr(); 126 if (frame) 127 { 128 sb_sym_ctx.SetSymbolContext(&frame->GetSymbolContext (resolve_scope)); 129 } 130 else 131 { 132 if (log) 133 log->Printf ("SBFrame::GetVariables () => error: could not reconstruct frame object for this SBFrame."); 134 } 135 } 136 else 137 { 138 if (log) 139 log->Printf ("SBFrame::GetSymbolContext () => error: process is running"); 140 } 141 } 142 143 if (log) 144 log->Printf ("SBFrame(%p)::GetSymbolContext (resolve_scope=0x%8.8x) => SBSymbolContext(%p)", 145 frame, resolve_scope, sb_sym_ctx.get()); 146 147 return sb_sym_ctx; 148 } 149 150 SBModule GetModule() const151 SBFrame::GetModule () const 152 { 153 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 154 SBModule sb_module; 155 ModuleSP module_sp; 156 Mutex::Locker api_locker; 157 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 158 159 StackFrame *frame = NULL; 160 Target *target = exe_ctx.GetTargetPtr(); 161 Process *process = exe_ctx.GetProcessPtr(); 162 if (target && process) 163 { 164 Process::StopLocker stop_locker; 165 if (stop_locker.TryLock(&process->GetRunLock())) 166 { 167 frame = exe_ctx.GetFramePtr(); 168 if (frame) 169 { 170 module_sp = frame->GetSymbolContext (eSymbolContextModule).module_sp; 171 sb_module.SetSP (module_sp); 172 } 173 else 174 { 175 if (log) 176 log->Printf ("SBFrame::GetModule () => error: could not reconstruct frame object for this SBFrame."); 177 } 178 } 179 else 180 { 181 if (log) 182 log->Printf ("SBFrame::GetModule () => error: process is running"); 183 } 184 } 185 186 if (log) 187 log->Printf ("SBFrame(%p)::GetModule () => SBModule(%p)", 188 frame, module_sp.get()); 189 190 return sb_module; 191 } 192 193 SBCompileUnit GetCompileUnit() const194 SBFrame::GetCompileUnit () const 195 { 196 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 197 SBCompileUnit sb_comp_unit; 198 Mutex::Locker api_locker; 199 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 200 201 StackFrame *frame = NULL; 202 Target *target = exe_ctx.GetTargetPtr(); 203 Process *process = exe_ctx.GetProcessPtr(); 204 if (target && process) 205 { 206 Process::StopLocker stop_locker; 207 if (stop_locker.TryLock(&process->GetRunLock())) 208 { 209 frame = exe_ctx.GetFramePtr(); 210 if (frame) 211 { 212 sb_comp_unit.reset (frame->GetSymbolContext (eSymbolContextCompUnit).comp_unit); 213 } 214 else 215 { 216 if (log) 217 log->Printf ("SBFrame::GetCompileUnit () => error: could not reconstruct frame object for this SBFrame."); 218 } 219 } 220 else 221 { 222 if (log) 223 log->Printf ("SBFrame::GetCompileUnit () => error: process is running"); 224 } 225 } 226 if (log) 227 log->Printf ("SBFrame(%p)::GetCompileUnit () => SBCompileUnit(%p)", 228 frame, sb_comp_unit.get()); 229 230 return sb_comp_unit; 231 } 232 233 SBFunction GetFunction() const234 SBFrame::GetFunction () const 235 { 236 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 237 SBFunction sb_function; 238 Mutex::Locker api_locker; 239 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 240 241 StackFrame *frame = NULL; 242 Target *target = exe_ctx.GetTargetPtr(); 243 Process *process = exe_ctx.GetProcessPtr(); 244 if (target && process) 245 { 246 Process::StopLocker stop_locker; 247 if (stop_locker.TryLock(&process->GetRunLock())) 248 { 249 frame = exe_ctx.GetFramePtr(); 250 if (frame) 251 { 252 sb_function.reset(frame->GetSymbolContext (eSymbolContextFunction).function); 253 } 254 else 255 { 256 if (log) 257 log->Printf ("SBFrame::GetFunction () => error: could not reconstruct frame object for this SBFrame."); 258 } 259 } 260 else 261 { 262 if (log) 263 log->Printf ("SBFrame::GetFunction () => error: process is running"); 264 } 265 } 266 if (log) 267 log->Printf ("SBFrame(%p)::GetFunction () => SBFunction(%p)", 268 frame, sb_function.get()); 269 270 return sb_function; 271 } 272 273 SBSymbol GetSymbol() const274 SBFrame::GetSymbol () const 275 { 276 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 277 SBSymbol sb_symbol; 278 Mutex::Locker api_locker; 279 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 280 281 StackFrame *frame = NULL; 282 Target *target = exe_ctx.GetTargetPtr(); 283 Process *process = exe_ctx.GetProcessPtr(); 284 if (target && process) 285 { 286 Process::StopLocker stop_locker; 287 if (stop_locker.TryLock(&process->GetRunLock())) 288 { 289 frame = exe_ctx.GetFramePtr(); 290 if (frame) 291 { 292 sb_symbol.reset(frame->GetSymbolContext (eSymbolContextSymbol).symbol); 293 } 294 else 295 { 296 if (log) 297 log->Printf ("SBFrame::GetSymbol () => error: could not reconstruct frame object for this SBFrame."); 298 } 299 } 300 else 301 { 302 if (log) 303 log->Printf ("SBFrame::GetSymbol () => error: process is running"); 304 } 305 } 306 if (log) 307 log->Printf ("SBFrame(%p)::GetSymbol () => SBSymbol(%p)", 308 frame, sb_symbol.get()); 309 return sb_symbol; 310 } 311 312 SBBlock GetBlock() const313 SBFrame::GetBlock () const 314 { 315 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 316 SBBlock sb_block; 317 Mutex::Locker api_locker; 318 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 319 320 StackFrame *frame = NULL; 321 Target *target = exe_ctx.GetTargetPtr(); 322 Process *process = exe_ctx.GetProcessPtr(); 323 if (target && process) 324 { 325 Process::StopLocker stop_locker; 326 if (stop_locker.TryLock(&process->GetRunLock())) 327 { 328 frame = exe_ctx.GetFramePtr(); 329 if (frame) 330 { 331 sb_block.SetPtr (frame->GetSymbolContext (eSymbolContextBlock).block); 332 } 333 else 334 { 335 if (log) 336 log->Printf ("SBFrame::GetBlock () => error: could not reconstruct frame object for this SBFrame."); 337 } 338 } 339 else 340 { 341 if (log) 342 log->Printf ("SBFrame(%p)::GetBlock () => error: process is running", frame); 343 } 344 } 345 if (log) 346 log->Printf ("SBFrame(%p)::GetBlock () => SBBlock(%p)", 347 frame, sb_block.GetPtr()); 348 return sb_block; 349 } 350 351 SBBlock GetFrameBlock() const352 SBFrame::GetFrameBlock () const 353 { 354 SBBlock sb_block; 355 Mutex::Locker api_locker; 356 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 357 358 StackFrame *frame = NULL; 359 Target *target = exe_ctx.GetTargetPtr(); 360 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 361 Process *process = exe_ctx.GetProcessPtr(); 362 if (target && process) 363 { 364 Process::StopLocker stop_locker; 365 if (stop_locker.TryLock(&process->GetRunLock())) 366 { 367 frame = exe_ctx.GetFramePtr(); 368 if (frame) 369 { 370 sb_block.SetPtr(frame->GetFrameBlock ()); 371 } 372 else 373 { 374 if (log) 375 log->Printf ("SBFrame::GetFrameBlock () => error: could not reconstruct frame object for this SBFrame."); 376 } 377 } 378 else 379 { 380 if (log) 381 log->Printf ("SBFrame::GetFrameBlock () => error: process is running"); 382 } 383 } 384 if (log) 385 log->Printf ("SBFrame(%p)::GetFrameBlock () => SBBlock(%p)", 386 frame, sb_block.GetPtr()); 387 return sb_block; 388 } 389 390 SBLineEntry GetLineEntry() const391 SBFrame::GetLineEntry () const 392 { 393 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 394 SBLineEntry sb_line_entry; 395 Mutex::Locker api_locker; 396 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 397 398 StackFrame *frame = NULL; 399 Target *target = exe_ctx.GetTargetPtr(); 400 Process *process = exe_ctx.GetProcessPtr(); 401 if (target && process) 402 { 403 Process::StopLocker stop_locker; 404 if (stop_locker.TryLock(&process->GetRunLock())) 405 { 406 frame = exe_ctx.GetFramePtr(); 407 if (frame) 408 { 409 sb_line_entry.SetLineEntry (frame->GetSymbolContext (eSymbolContextLineEntry).line_entry); 410 } 411 else 412 { 413 if (log) 414 log->Printf ("SBFrame::GetLineEntry () => error: could not reconstruct frame object for this SBFrame."); 415 } 416 } 417 else 418 { 419 if (log) 420 log->Printf ("SBFrame::GetLineEntry () => error: process is running"); 421 } 422 } 423 if (log) 424 log->Printf ("SBFrame(%p)::GetLineEntry () => SBLineEntry(%p)", 425 frame, sb_line_entry.get()); 426 return sb_line_entry; 427 } 428 429 uint32_t GetFrameID() const430 SBFrame::GetFrameID () const 431 { 432 uint32_t frame_idx = UINT32_MAX; 433 434 ExecutionContext exe_ctx(m_opaque_sp.get()); 435 StackFrame *frame = exe_ctx.GetFramePtr(); 436 if (frame) 437 frame_idx = frame->GetFrameIndex (); 438 439 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 440 if (log) 441 log->Printf ("SBFrame(%p)::GetFrameID () => %u", 442 frame, frame_idx); 443 return frame_idx; 444 } 445 446 addr_t GetPC() const447 SBFrame::GetPC () const 448 { 449 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 450 addr_t addr = LLDB_INVALID_ADDRESS; 451 Mutex::Locker api_locker; 452 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 453 454 StackFrame *frame = NULL; 455 Target *target = exe_ctx.GetTargetPtr(); 456 Process *process = exe_ctx.GetProcessPtr(); 457 if (target && process) 458 { 459 Process::StopLocker stop_locker; 460 if (stop_locker.TryLock(&process->GetRunLock())) 461 { 462 frame = exe_ctx.GetFramePtr(); 463 if (frame) 464 { 465 addr = frame->GetFrameCodeAddress().GetOpcodeLoadAddress (target); 466 } 467 else 468 { 469 if (log) 470 log->Printf ("SBFrame::GetPC () => error: could not reconstruct frame object for this SBFrame."); 471 } 472 } 473 else 474 { 475 if (log) 476 log->Printf ("SBFrame::GetPC () => error: process is running"); 477 } 478 } 479 480 if (log) 481 log->Printf ("SBFrame(%p)::GetPC () => 0x%" PRIx64, frame, addr); 482 483 return addr; 484 } 485 486 bool SetPC(addr_t new_pc)487 SBFrame::SetPC (addr_t new_pc) 488 { 489 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 490 bool ret_val = false; 491 Mutex::Locker api_locker; 492 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 493 494 StackFrame *frame = NULL; 495 Target *target = exe_ctx.GetTargetPtr(); 496 Process *process = exe_ctx.GetProcessPtr(); 497 if (target && process) 498 { 499 Process::StopLocker stop_locker; 500 if (stop_locker.TryLock(&process->GetRunLock())) 501 { 502 frame = exe_ctx.GetFramePtr(); 503 if (frame) 504 { 505 ret_val = frame->GetRegisterContext()->SetPC (new_pc); 506 } 507 else 508 { 509 if (log) 510 log->Printf ("SBFrame::SetPC () => error: could not reconstruct frame object for this SBFrame."); 511 } 512 } 513 else 514 { 515 if (log) 516 log->Printf ("SBFrame::SetPC () => error: process is running"); 517 } 518 } 519 520 if (log) 521 log->Printf ("SBFrame(%p)::SetPC (new_pc=0x%" PRIx64 ") => %i", 522 frame, new_pc, ret_val); 523 524 return ret_val; 525 } 526 527 addr_t GetSP() const528 SBFrame::GetSP () const 529 { 530 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 531 addr_t addr = LLDB_INVALID_ADDRESS; 532 Mutex::Locker api_locker; 533 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 534 535 StackFrame *frame = NULL; 536 Target *target = exe_ctx.GetTargetPtr(); 537 Process *process = exe_ctx.GetProcessPtr(); 538 if (target && process) 539 { 540 Process::StopLocker stop_locker; 541 if (stop_locker.TryLock(&process->GetRunLock())) 542 { 543 frame = exe_ctx.GetFramePtr(); 544 if (frame) 545 { 546 addr = frame->GetRegisterContext()->GetSP(); 547 } 548 else 549 { 550 if (log) 551 log->Printf ("SBFrame::GetSP () => error: could not reconstruct frame object for this SBFrame."); 552 } 553 } 554 else 555 { 556 if (log) 557 log->Printf ("SBFrame::GetSP () => error: process is running"); 558 } 559 } 560 if (log) 561 log->Printf ("SBFrame(%p)::GetSP () => 0x%" PRIx64, frame, addr); 562 563 return addr; 564 } 565 566 567 addr_t GetFP() const568 SBFrame::GetFP () const 569 { 570 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 571 addr_t addr = LLDB_INVALID_ADDRESS; 572 Mutex::Locker api_locker; 573 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 574 575 StackFrame *frame = NULL; 576 Target *target = exe_ctx.GetTargetPtr(); 577 Process *process = exe_ctx.GetProcessPtr(); 578 if (target && process) 579 { 580 Process::StopLocker stop_locker; 581 if (stop_locker.TryLock(&process->GetRunLock())) 582 { 583 frame = exe_ctx.GetFramePtr(); 584 if (frame) 585 { 586 addr = frame->GetRegisterContext()->GetFP(); 587 } 588 else 589 { 590 if (log) 591 log->Printf ("SBFrame::GetFP () => error: could not reconstruct frame object for this SBFrame."); 592 } 593 } 594 else 595 { 596 if (log) 597 log->Printf ("SBFrame::GetFP () => error: process is running"); 598 } 599 } 600 601 if (log) 602 log->Printf ("SBFrame(%p)::GetFP () => 0x%" PRIx64, frame, addr); 603 return addr; 604 } 605 606 607 SBAddress GetPCAddress() const608 SBFrame::GetPCAddress () const 609 { 610 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 611 SBAddress sb_addr; 612 Mutex::Locker api_locker; 613 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 614 615 StackFrame *frame = exe_ctx.GetFramePtr(); 616 Target *target = exe_ctx.GetTargetPtr(); 617 Process *process = exe_ctx.GetProcessPtr(); 618 if (target && process) 619 { 620 Process::StopLocker stop_locker; 621 if (stop_locker.TryLock(&process->GetRunLock())) 622 { 623 frame = exe_ctx.GetFramePtr(); 624 if (frame) 625 { 626 sb_addr.SetAddress (&frame->GetFrameCodeAddress()); 627 } 628 else 629 { 630 if (log) 631 log->Printf ("SBFrame::GetPCAddress () => error: could not reconstruct frame object for this SBFrame."); 632 } 633 } 634 else 635 { 636 if (log) 637 log->Printf ("SBFrame::GetPCAddress () => error: process is running"); 638 } 639 } 640 if (log) 641 log->Printf ("SBFrame(%p)::GetPCAddress () => SBAddress(%p)", frame, sb_addr.get()); 642 return sb_addr; 643 } 644 645 void Clear()646 SBFrame::Clear() 647 { 648 m_opaque_sp->Clear(); 649 } 650 651 lldb::SBValue GetValueForVariablePath(const char * var_path)652 SBFrame::GetValueForVariablePath (const char *var_path) 653 { 654 SBValue sb_value; 655 ExecutionContext exe_ctx(m_opaque_sp.get()); 656 StackFrame *frame = exe_ctx.GetFramePtr(); 657 Target *target = exe_ctx.GetTargetPtr(); 658 if (frame && target) 659 { 660 lldb::DynamicValueType use_dynamic = frame->CalculateTarget()->GetPreferDynamicValue(); 661 sb_value = GetValueForVariablePath (var_path, use_dynamic); 662 } 663 return sb_value; 664 } 665 666 lldb::SBValue GetValueForVariablePath(const char * var_path,DynamicValueType use_dynamic)667 SBFrame::GetValueForVariablePath (const char *var_path, DynamicValueType use_dynamic) 668 { 669 SBValue sb_value; 670 Mutex::Locker api_locker; 671 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 672 if (var_path == NULL || var_path[0] == '\0') 673 { 674 if (log) 675 log->Printf ("SBFrame::GetValueForVariablePath called with empty variable path."); 676 return sb_value; 677 } 678 679 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 680 681 StackFrame *frame = NULL; 682 Target *target = exe_ctx.GetTargetPtr(); 683 Process *process = exe_ctx.GetProcessPtr(); 684 if (target && process) 685 { 686 Process::StopLocker stop_locker; 687 if (stop_locker.TryLock(&process->GetRunLock())) 688 { 689 frame = exe_ctx.GetFramePtr(); 690 if (frame) 691 { 692 VariableSP var_sp; 693 Error error; 694 ValueObjectSP value_sp (frame->GetValueForVariableExpressionPath (var_path, 695 eNoDynamicValues, 696 StackFrame::eExpressionPathOptionCheckPtrVsMember | StackFrame::eExpressionPathOptionsAllowDirectIVarAccess, 697 var_sp, 698 error)); 699 sb_value.SetSP(value_sp, use_dynamic); 700 } 701 else 702 { 703 if (log) 704 log->Printf ("SBFrame::GetValueForVariablePath () => error: could not reconstruct frame object for this SBFrame."); 705 } 706 } 707 else 708 { 709 if (log) 710 log->Printf ("SBFrame::GetValueForVariablePath () => error: process is running"); 711 } 712 } 713 return sb_value; 714 } 715 716 SBValue FindVariable(const char * name)717 SBFrame::FindVariable (const char *name) 718 { 719 SBValue value; 720 ExecutionContext exe_ctx(m_opaque_sp.get()); 721 StackFrame *frame = exe_ctx.GetFramePtr(); 722 Target *target = exe_ctx.GetTargetPtr(); 723 if (frame && target) 724 { 725 lldb::DynamicValueType use_dynamic = frame->CalculateTarget()->GetPreferDynamicValue(); 726 value = FindVariable (name, use_dynamic); 727 } 728 return value; 729 } 730 731 732 SBValue FindVariable(const char * name,lldb::DynamicValueType use_dynamic)733 SBFrame::FindVariable (const char *name, lldb::DynamicValueType use_dynamic) 734 { 735 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 736 VariableSP var_sp; 737 SBValue sb_value; 738 739 if (name == NULL || name[0] == '\0') 740 { 741 if (log) 742 log->Printf ("SBFrame::FindVariable called with empty name"); 743 return sb_value; 744 } 745 746 ValueObjectSP value_sp; 747 Mutex::Locker api_locker; 748 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 749 750 StackFrame *frame = NULL; 751 Target *target = exe_ctx.GetTargetPtr(); 752 Process *process = exe_ctx.GetProcessPtr(); 753 if (target && process) 754 { 755 Process::StopLocker stop_locker; 756 if (stop_locker.TryLock(&process->GetRunLock())) 757 { 758 frame = exe_ctx.GetFramePtr(); 759 if (frame) 760 { 761 VariableList variable_list; 762 SymbolContext sc (frame->GetSymbolContext (eSymbolContextBlock)); 763 764 if (sc.block) 765 { 766 const bool can_create = true; 767 const bool get_parent_variables = true; 768 const bool stop_if_block_is_inlined_function = true; 769 770 if (sc.block->AppendVariables (can_create, 771 get_parent_variables, 772 stop_if_block_is_inlined_function, 773 &variable_list)) 774 { 775 var_sp = variable_list.FindVariable (ConstString(name)); 776 } 777 } 778 779 if (var_sp) 780 { 781 value_sp = frame->GetValueObjectForFrameVariable(var_sp, eNoDynamicValues); 782 sb_value.SetSP(value_sp, use_dynamic); 783 } 784 } 785 else 786 { 787 if (log) 788 log->Printf ("SBFrame::FindVariable () => error: could not reconstruct frame object for this SBFrame."); 789 } 790 } 791 else 792 { 793 if (log) 794 log->Printf ("SBFrame::FindVariable () => error: process is running"); 795 } 796 } 797 798 if (log) 799 log->Printf ("SBFrame(%p)::FindVariable (name=\"%s\") => SBValue(%p)", 800 frame, name, value_sp.get()); 801 802 return sb_value; 803 } 804 805 SBValue FindValue(const char * name,ValueType value_type)806 SBFrame::FindValue (const char *name, ValueType value_type) 807 { 808 SBValue value; 809 ExecutionContext exe_ctx(m_opaque_sp.get()); 810 StackFrame *frame = exe_ctx.GetFramePtr(); 811 Target *target = exe_ctx.GetTargetPtr(); 812 if (frame && target) 813 { 814 lldb::DynamicValueType use_dynamic = frame->CalculateTarget()->GetPreferDynamicValue(); 815 value = FindValue (name, value_type, use_dynamic); 816 } 817 return value; 818 } 819 820 SBValue FindValue(const char * name,ValueType value_type,lldb::DynamicValueType use_dynamic)821 SBFrame::FindValue (const char *name, ValueType value_type, lldb::DynamicValueType use_dynamic) 822 { 823 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 824 SBValue sb_value; 825 826 if (name == NULL || name[0] == '\0') 827 { 828 if (log) 829 log->Printf ("SBFrame::FindValue called with empty name."); 830 return sb_value; 831 } 832 833 ValueObjectSP value_sp; 834 Mutex::Locker api_locker; 835 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 836 837 StackFrame *frame = NULL; 838 Target *target = exe_ctx.GetTargetPtr(); 839 Process *process = exe_ctx.GetProcessPtr(); 840 if (target && process) 841 { 842 Process::StopLocker stop_locker; 843 if (stop_locker.TryLock(&process->GetRunLock())) 844 { 845 frame = exe_ctx.GetFramePtr(); 846 if (frame) 847 { 848 switch (value_type) 849 { 850 case eValueTypeVariableGlobal: // global variable 851 case eValueTypeVariableStatic: // static variable 852 case eValueTypeVariableArgument: // function argument variables 853 case eValueTypeVariableLocal: // function local variables 854 { 855 VariableList *variable_list = frame->GetVariableList(true); 856 857 SymbolContext sc (frame->GetSymbolContext (eSymbolContextBlock)); 858 859 const bool can_create = true; 860 const bool get_parent_variables = true; 861 const bool stop_if_block_is_inlined_function = true; 862 863 if (sc.block && sc.block->AppendVariables (can_create, 864 get_parent_variables, 865 stop_if_block_is_inlined_function, 866 variable_list)) 867 { 868 ConstString const_name(name); 869 const uint32_t num_variables = variable_list->GetSize(); 870 for (uint32_t i = 0; i < num_variables; ++i) 871 { 872 VariableSP variable_sp (variable_list->GetVariableAtIndex(i)); 873 if (variable_sp && 874 variable_sp->GetScope() == value_type && 875 variable_sp->GetName() == const_name) 876 { 877 value_sp = frame->GetValueObjectForFrameVariable (variable_sp, eNoDynamicValues); 878 sb_value.SetSP (value_sp, use_dynamic); 879 break; 880 } 881 } 882 } 883 } 884 break; 885 886 case eValueTypeRegister: // stack frame register value 887 { 888 RegisterContextSP reg_ctx (frame->GetRegisterContext()); 889 if (reg_ctx) 890 { 891 const uint32_t num_regs = reg_ctx->GetRegisterCount(); 892 for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx) 893 { 894 const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex (reg_idx); 895 if (reg_info && 896 ((reg_info->name && strcasecmp (reg_info->name, name) == 0) || 897 (reg_info->alt_name && strcasecmp (reg_info->alt_name, name) == 0))) 898 { 899 value_sp = ValueObjectRegister::Create (frame, reg_ctx, reg_idx); 900 sb_value.SetSP (value_sp); 901 break; 902 } 903 } 904 } 905 } 906 break; 907 908 case eValueTypeRegisterSet: // A collection of stack frame register values 909 { 910 RegisterContextSP reg_ctx (frame->GetRegisterContext()); 911 if (reg_ctx) 912 { 913 const uint32_t num_sets = reg_ctx->GetRegisterSetCount(); 914 for (uint32_t set_idx = 0; set_idx < num_sets; ++set_idx) 915 { 916 const RegisterSet *reg_set = reg_ctx->GetRegisterSet (set_idx); 917 if (reg_set && 918 ((reg_set->name && strcasecmp (reg_set->name, name) == 0) || 919 (reg_set->short_name && strcasecmp (reg_set->short_name, name) == 0))) 920 { 921 value_sp = ValueObjectRegisterSet::Create (frame, reg_ctx, set_idx); 922 sb_value.SetSP (value_sp); 923 break; 924 } 925 } 926 } 927 } 928 break; 929 930 case eValueTypeConstResult: // constant result variables 931 { 932 ConstString const_name(name); 933 ClangExpressionVariableSP expr_var_sp (target->GetPersistentVariables().GetVariable (const_name)); 934 if (expr_var_sp) 935 { 936 value_sp = expr_var_sp->GetValueObject(); 937 sb_value.SetSP (value_sp, use_dynamic); 938 } 939 } 940 break; 941 942 default: 943 break; 944 } 945 } 946 else 947 { 948 if (log) 949 log->Printf ("SBFrame::FindValue () => error: could not reconstruct frame object for this SBFrame."); 950 } 951 } 952 else 953 { 954 if (log) 955 log->Printf ("SBFrame::FindValue () => error: process is running"); 956 } 957 } 958 959 if (log) 960 log->Printf ("SBFrame(%p)::FindVariableInScope (name=\"%s\", value_type=%i) => SBValue(%p)", 961 frame, name, value_type, value_sp.get()); 962 963 964 return sb_value; 965 } 966 967 bool IsEqual(const SBFrame & that) const968 SBFrame::IsEqual (const SBFrame &that) const 969 { 970 lldb::StackFrameSP this_sp = GetFrameSP(); 971 lldb::StackFrameSP that_sp = that.GetFrameSP(); 972 return (this_sp && that_sp && this_sp->GetStackID() == that_sp->GetStackID()); 973 } 974 975 bool operator ==(const SBFrame & rhs) const976 SBFrame::operator == (const SBFrame &rhs) const 977 { 978 return IsEqual(rhs); 979 } 980 981 bool operator !=(const SBFrame & rhs) const982 SBFrame::operator != (const SBFrame &rhs) const 983 { 984 return !IsEqual(rhs); 985 } 986 987 SBThread GetThread() const988 SBFrame::GetThread () const 989 { 990 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 991 992 ExecutionContext exe_ctx(m_opaque_sp.get()); 993 ThreadSP thread_sp (exe_ctx.GetThreadSP()); 994 SBThread sb_thread (thread_sp); 995 996 if (log) 997 { 998 SBStream sstr; 999 sb_thread.GetDescription (sstr); 1000 log->Printf ("SBFrame(%p)::GetThread () => SBThread(%p): %s", 1001 exe_ctx.GetFramePtr(), 1002 thread_sp.get(), 1003 sstr.GetData()); 1004 } 1005 1006 return sb_thread; 1007 } 1008 1009 const char * Disassemble() const1010 SBFrame::Disassemble () const 1011 { 1012 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1013 const char *disassembly = NULL; 1014 Mutex::Locker api_locker; 1015 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 1016 1017 StackFrame *frame = NULL; 1018 Target *target = exe_ctx.GetTargetPtr(); 1019 Process *process = exe_ctx.GetProcessPtr(); 1020 if (target && process) 1021 { 1022 Process::StopLocker stop_locker; 1023 if (stop_locker.TryLock(&process->GetRunLock())) 1024 { 1025 frame = exe_ctx.GetFramePtr(); 1026 if (frame) 1027 { 1028 disassembly = frame->Disassemble(); 1029 } 1030 else 1031 { 1032 if (log) 1033 log->Printf ("SBFrame::Disassemble () => error: could not reconstruct frame object for this SBFrame."); 1034 } 1035 } 1036 else 1037 { 1038 if (log) 1039 log->Printf ("SBFrame::Disassemble () => error: process is running"); 1040 } 1041 } 1042 1043 if (log) 1044 log->Printf ("SBFrame(%p)::Disassemble () => %s", frame, disassembly); 1045 1046 return disassembly; 1047 } 1048 1049 1050 SBValueList GetVariables(bool arguments,bool locals,bool statics,bool in_scope_only)1051 SBFrame::GetVariables (bool arguments, 1052 bool locals, 1053 bool statics, 1054 bool in_scope_only) 1055 { 1056 SBValueList value_list; 1057 ExecutionContext exe_ctx(m_opaque_sp.get()); 1058 StackFrame *frame = exe_ctx.GetFramePtr(); 1059 Target *target = exe_ctx.GetTargetPtr(); 1060 if (frame && target) 1061 { 1062 lldb::DynamicValueType use_dynamic = frame->CalculateTarget()->GetPreferDynamicValue(); 1063 value_list = GetVariables (arguments, locals, statics, in_scope_only, use_dynamic); 1064 } 1065 return value_list; 1066 } 1067 1068 SBValueList GetVariables(bool arguments,bool locals,bool statics,bool in_scope_only,lldb::DynamicValueType use_dynamic)1069 SBFrame::GetVariables (bool arguments, 1070 bool locals, 1071 bool statics, 1072 bool in_scope_only, 1073 lldb::DynamicValueType use_dynamic) 1074 { 1075 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1076 1077 SBValueList value_list; 1078 Mutex::Locker api_locker; 1079 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 1080 1081 StackFrame *frame = NULL; 1082 Target *target = exe_ctx.GetTargetPtr(); 1083 1084 if (log) 1085 log->Printf ("SBFrame::GetVariables (arguments=%i, locals=%i, statics=%i, in_scope_only=%i)", 1086 arguments, 1087 locals, 1088 statics, 1089 in_scope_only); 1090 1091 Process *process = exe_ctx.GetProcessPtr(); 1092 if (target && process) 1093 { 1094 Process::StopLocker stop_locker; 1095 if (stop_locker.TryLock(&process->GetRunLock())) 1096 { 1097 frame = exe_ctx.GetFramePtr(); 1098 if (frame) 1099 { 1100 size_t i; 1101 VariableList *variable_list = NULL; 1102 variable_list = frame->GetVariableList(true); 1103 if (variable_list) 1104 { 1105 const size_t num_variables = variable_list->GetSize(); 1106 if (num_variables) 1107 { 1108 for (i = 0; i < num_variables; ++i) 1109 { 1110 VariableSP variable_sp (variable_list->GetVariableAtIndex(i)); 1111 if (variable_sp) 1112 { 1113 bool add_variable = false; 1114 switch (variable_sp->GetScope()) 1115 { 1116 case eValueTypeVariableGlobal: 1117 case eValueTypeVariableStatic: 1118 add_variable = statics; 1119 break; 1120 1121 case eValueTypeVariableArgument: 1122 add_variable = arguments; 1123 break; 1124 1125 case eValueTypeVariableLocal: 1126 add_variable = locals; 1127 break; 1128 1129 default: 1130 break; 1131 } 1132 if (add_variable) 1133 { 1134 if (in_scope_only && !variable_sp->IsInScope(frame)) 1135 continue; 1136 1137 ValueObjectSP valobj_sp(frame->GetValueObjectForFrameVariable (variable_sp, eNoDynamicValues)); 1138 SBValue value_sb; 1139 value_sb.SetSP(valobj_sp,use_dynamic); 1140 value_list.Append(value_sb); 1141 } 1142 } 1143 } 1144 } 1145 } 1146 } 1147 else 1148 { 1149 if (log) 1150 log->Printf ("SBFrame::GetVariables () => error: could not reconstruct frame object for this SBFrame."); 1151 } 1152 } 1153 else 1154 { 1155 if (log) 1156 log->Printf ("SBFrame::GetVariables () => error: process is running"); 1157 } 1158 } 1159 1160 if (log) 1161 { 1162 log->Printf ("SBFrame(%p)::GetVariables (...) => SBValueList(%p)", frame, value_list.opaque_ptr()); 1163 } 1164 1165 return value_list; 1166 } 1167 1168 SBValueList GetRegisters()1169 SBFrame::GetRegisters () 1170 { 1171 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1172 1173 SBValueList value_list; 1174 Mutex::Locker api_locker; 1175 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 1176 1177 StackFrame *frame = NULL; 1178 Target *target = exe_ctx.GetTargetPtr(); 1179 Process *process = exe_ctx.GetProcessPtr(); 1180 if (target && process) 1181 { 1182 Process::StopLocker stop_locker; 1183 if (stop_locker.TryLock(&process->GetRunLock())) 1184 { 1185 frame = exe_ctx.GetFramePtr(); 1186 if (frame) 1187 { 1188 RegisterContextSP reg_ctx (frame->GetRegisterContext()); 1189 if (reg_ctx) 1190 { 1191 const uint32_t num_sets = reg_ctx->GetRegisterSetCount(); 1192 for (uint32_t set_idx = 0; set_idx < num_sets; ++set_idx) 1193 { 1194 value_list.Append(ValueObjectRegisterSet::Create (frame, reg_ctx, set_idx)); 1195 } 1196 } 1197 } 1198 else 1199 { 1200 if (log) 1201 log->Printf ("SBFrame::GetRegisters () => error: could not reconstruct frame object for this SBFrame."); 1202 } 1203 } 1204 else 1205 { 1206 if (log) 1207 log->Printf ("SBFrame::GetRegisters () => error: process is running"); 1208 } 1209 } 1210 1211 if (log) 1212 log->Printf ("SBFrame(%p)::GetRegisters () => SBValueList(%p)", frame, value_list.opaque_ptr()); 1213 1214 return value_list; 1215 } 1216 1217 SBValue FindRegister(const char * name)1218 SBFrame::FindRegister (const char *name) 1219 { 1220 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1221 1222 SBValue result; 1223 ValueObjectSP value_sp; 1224 Mutex::Locker api_locker; 1225 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 1226 1227 StackFrame *frame = NULL; 1228 Target *target = exe_ctx.GetTargetPtr(); 1229 Process *process = exe_ctx.GetProcessPtr(); 1230 if (target && process) 1231 { 1232 Process::StopLocker stop_locker; 1233 if (stop_locker.TryLock(&process->GetRunLock())) 1234 { 1235 frame = exe_ctx.GetFramePtr(); 1236 if (frame) 1237 { 1238 RegisterContextSP reg_ctx (frame->GetRegisterContext()); 1239 if (reg_ctx) 1240 { 1241 const uint32_t num_regs = reg_ctx->GetRegisterCount(); 1242 for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx) 1243 { 1244 const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex (reg_idx); 1245 if (reg_info && 1246 ((reg_info->name && strcasecmp (reg_info->name, name) == 0) || 1247 (reg_info->alt_name && strcasecmp (reg_info->alt_name, name) == 0))) 1248 { 1249 value_sp = ValueObjectRegister::Create (frame, reg_ctx, reg_idx); 1250 result.SetSP (value_sp); 1251 break; 1252 } 1253 } 1254 } 1255 } 1256 else 1257 { 1258 if (log) 1259 log->Printf ("SBFrame::FindRegister () => error: could not reconstruct frame object for this SBFrame."); 1260 } 1261 } 1262 else 1263 { 1264 if (log) 1265 log->Printf ("SBFrame::FindRegister () => error: process is running"); 1266 } 1267 } 1268 1269 if (log) 1270 log->Printf ("SBFrame(%p)::FindRegister () => SBValue(%p)", frame, value_sp.get()); 1271 1272 return result; 1273 } 1274 1275 bool GetDescription(SBStream & description)1276 SBFrame::GetDescription (SBStream &description) 1277 { 1278 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1279 Stream &strm = description.ref(); 1280 1281 Mutex::Locker api_locker; 1282 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 1283 1284 StackFrame *frame; 1285 Target *target = exe_ctx.GetTargetPtr(); 1286 Process *process = exe_ctx.GetProcessPtr(); 1287 if (target && process) 1288 { 1289 Process::StopLocker stop_locker; 1290 if (stop_locker.TryLock(&process->GetRunLock())) 1291 { 1292 frame = exe_ctx.GetFramePtr(); 1293 if (frame) 1294 { 1295 frame->DumpUsingSettingsFormat (&strm); 1296 } 1297 else 1298 { 1299 if (log) 1300 log->Printf ("SBFrame::GetDescription () => error: could not reconstruct frame object for this SBFrame."); 1301 } 1302 } 1303 else 1304 { 1305 if (log) 1306 log->Printf ("SBFrame::GetDescription () => error: process is running"); 1307 } 1308 1309 } 1310 else 1311 strm.PutCString ("No value"); 1312 1313 return true; 1314 } 1315 1316 SBValue EvaluateExpression(const char * expr)1317 SBFrame::EvaluateExpression (const char *expr) 1318 { 1319 SBValue result; 1320 ExecutionContext exe_ctx(m_opaque_sp.get()); 1321 StackFrame *frame = exe_ctx.GetFramePtr(); 1322 Target *target = exe_ctx.GetTargetPtr(); 1323 if (frame && target) 1324 { 1325 SBExpressionOptions options; 1326 lldb::DynamicValueType fetch_dynamic_value = frame->CalculateTarget()->GetPreferDynamicValue(); 1327 options.SetFetchDynamicValue (fetch_dynamic_value); 1328 options.SetUnwindOnError (true); 1329 return EvaluateExpression (expr, options); 1330 } 1331 return result; 1332 } 1333 1334 SBValue EvaluateExpression(const char * expr,lldb::DynamicValueType fetch_dynamic_value)1335 SBFrame::EvaluateExpression (const char *expr, lldb::DynamicValueType fetch_dynamic_value) 1336 { 1337 SBExpressionOptions options; 1338 options.SetFetchDynamicValue (fetch_dynamic_value); 1339 options.SetUnwindOnError (true); 1340 return EvaluateExpression (expr, options); 1341 } 1342 1343 SBValue EvaluateExpression(const char * expr,lldb::DynamicValueType fetch_dynamic_value,bool unwind_on_error)1344 SBFrame::EvaluateExpression (const char *expr, lldb::DynamicValueType fetch_dynamic_value, bool unwind_on_error) 1345 { 1346 SBExpressionOptions options; 1347 options.SetFetchDynamicValue (fetch_dynamic_value); 1348 options.SetUnwindOnError (unwind_on_error); 1349 return EvaluateExpression (expr, options); 1350 } 1351 1352 lldb::SBValue EvaluateExpression(const char * expr,const SBExpressionOptions & options)1353 SBFrame::EvaluateExpression (const char *expr, const SBExpressionOptions &options) 1354 { 1355 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1356 1357 Log *expr_log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 1358 1359 ExecutionResults exe_results = eExecutionSetupError; 1360 SBValue expr_result; 1361 1362 if (expr == NULL || expr[0] == '\0') 1363 { 1364 if (log) 1365 log->Printf ("SBFrame::EvaluateExpression called with an empty expression"); 1366 return expr_result; 1367 } 1368 1369 ValueObjectSP expr_value_sp; 1370 1371 Mutex::Locker api_locker; 1372 ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker); 1373 1374 if (log) 1375 log->Printf ("SBFrame()::EvaluateExpression (expr=\"%s\")...", expr); 1376 1377 StackFrame *frame = NULL; 1378 Target *target = exe_ctx.GetTargetPtr(); 1379 Process *process = exe_ctx.GetProcessPtr(); 1380 1381 if (target && process) 1382 { 1383 Process::StopLocker stop_locker; 1384 if (stop_locker.TryLock(&process->GetRunLock())) 1385 { 1386 frame = exe_ctx.GetFramePtr(); 1387 if (frame) 1388 { 1389 #ifdef LLDB_CONFIGURATION_DEBUG 1390 StreamString frame_description; 1391 frame->DumpUsingSettingsFormat (&frame_description); 1392 Host::SetCrashDescriptionWithFormat ("SBFrame::EvaluateExpression (expr = \"%s\", fetch_dynamic_value = %u) %s", 1393 expr, options.GetFetchDynamicValue(), frame_description.GetString().c_str()); 1394 #endif 1395 exe_results = target->EvaluateExpression (expr, 1396 frame, 1397 expr_value_sp, 1398 options.ref()); 1399 expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue()); 1400 #ifdef LLDB_CONFIGURATION_DEBUG 1401 Host::SetCrashDescription (NULL); 1402 #endif 1403 } 1404 else 1405 { 1406 if (log) 1407 log->Printf ("SBFrame::EvaluateExpression () => error: could not reconstruct frame object for this SBFrame."); 1408 } 1409 } 1410 else 1411 { 1412 if (log) 1413 log->Printf ("SBFrame::EvaluateExpression () => error: process is running"); 1414 } 1415 } 1416 1417 #ifndef LLDB_DISABLE_PYTHON 1418 if (expr_log) 1419 expr_log->Printf("** [SBFrame::EvaluateExpression] Expression result is %s, summary %s **", 1420 expr_result.GetValue(), 1421 expr_result.GetSummary()); 1422 1423 if (log) 1424 log->Printf ("SBFrame(%p)::EvaluateExpression (expr=\"%s\") => SBValue(%p) (execution result=%d)", 1425 frame, 1426 expr, 1427 expr_value_sp.get(), 1428 exe_results); 1429 #endif 1430 1431 return expr_result; 1432 } 1433 1434 bool IsInlined()1435 SBFrame::IsInlined() 1436 { 1437 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1438 ExecutionContext exe_ctx(m_opaque_sp.get()); 1439 StackFrame *frame = NULL; 1440 Target *target = exe_ctx.GetTargetPtr(); 1441 Process *process = exe_ctx.GetProcessPtr(); 1442 if (target && process) 1443 { 1444 Process::StopLocker stop_locker; 1445 if (stop_locker.TryLock(&process->GetRunLock())) 1446 { 1447 frame = exe_ctx.GetFramePtr(); 1448 if (frame) 1449 { 1450 1451 Block *block = frame->GetSymbolContext(eSymbolContextBlock).block; 1452 if (block) 1453 return block->GetContainingInlinedBlock () != NULL; 1454 } 1455 else 1456 { 1457 if (log) 1458 log->Printf ("SBFrame::IsInlined () => error: could not reconstruct frame object for this SBFrame."); 1459 } 1460 } 1461 else 1462 { 1463 if (log) 1464 log->Printf ("SBFrame::IsInlined () => error: process is running"); 1465 } 1466 1467 } 1468 return false; 1469 } 1470 1471 const char * GetFunctionName()1472 SBFrame::GetFunctionName() 1473 { 1474 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1475 const char *name = NULL; 1476 ExecutionContext exe_ctx(m_opaque_sp.get()); 1477 StackFrame *frame = NULL; 1478 Target *target = exe_ctx.GetTargetPtr(); 1479 Process *process = exe_ctx.GetProcessPtr(); 1480 if (target && process) 1481 { 1482 Process::StopLocker stop_locker; 1483 if (stop_locker.TryLock(&process->GetRunLock())) 1484 { 1485 frame = exe_ctx.GetFramePtr(); 1486 if (frame) 1487 { 1488 SymbolContext sc (frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextBlock | eSymbolContextSymbol)); 1489 if (sc.block) 1490 { 1491 Block *inlined_block = sc.block->GetContainingInlinedBlock (); 1492 if (inlined_block) 1493 { 1494 const InlineFunctionInfo* inlined_info = inlined_block->GetInlinedFunctionInfo(); 1495 name = inlined_info->GetName().AsCString(); 1496 } 1497 } 1498 1499 if (name == NULL) 1500 { 1501 if (sc.function) 1502 name = sc.function->GetName().GetCString(); 1503 } 1504 1505 if (name == NULL) 1506 { 1507 if (sc.symbol) 1508 name = sc.symbol->GetName().GetCString(); 1509 } 1510 } 1511 else 1512 { 1513 if (log) 1514 log->Printf ("SBFrame::GetFunctionName () => error: could not reconstruct frame object for this SBFrame."); 1515 } 1516 } 1517 else 1518 { 1519 if (log) 1520 log->Printf ("SBFrame::GetFunctionName() => error: process is running"); 1521 1522 } 1523 } 1524 return name; 1525 } 1526 1527