contrib/llvm-project/lldb/source/API/SBFrame.cpp

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