contrib/llvm-project/lldb/source/Target/StackFrame.cpp

   1 //===-- StackFrame.cpp ------------------------------------------*- C++ -*-===//
   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 "lldb/Target/StackFrame.h"
  10 #include "lldb/Core/Debugger.h"
  11 #include "lldb/Core/Disassembler.h"
  12 #include "lldb/Core/FormatEntity.h"
  13 #include "lldb/Core/Mangled.h"
  14 #include "lldb/Core/Module.h"
  15 #include "lldb/Core/Value.h"
  16 #include "lldb/Core/ValueObjectConstResult.h"
  17 #include "lldb/Core/ValueObjectMemory.h"
  18 #include "lldb/Core/ValueObjectVariable.h"
  19 #include "lldb/Symbol/CompileUnit.h"
  20 #include "lldb/Symbol/Function.h"
  21 #include "lldb/Symbol/Symbol.h"
  22 #include "lldb/Symbol/SymbolContextScope.h"
  23 #include "lldb/Symbol/Type.h"
  24 #include "lldb/Symbol/VariableList.h"
  25 #include "lldb/Target/ABI.h"
  26 #include "lldb/Target/ExecutionContext.h"
  27 #include "lldb/Target/Process.h"
  28 #include "lldb/Target/RegisterContext.h"
  29 #include "lldb/Target/StackFrameRecognizer.h"
  30 #include "lldb/Target/Target.h"
  31 #include "lldb/Target/Thread.h"
  32 #include "lldb/Utility/RegisterValue.h"
  33
  34 #include "lldb/lldb-enumerations.h"
  35
  36 #include <memory>
  37
  38 using namespace lldb;
  39 using namespace lldb_private;
  40
  41 // The first bits in the flags are reserved for the SymbolContext::Scope bits
  42 // so we know if we have tried to look up information in our internal symbol
  43 // context (m_sc) already.
  44 #define RESOLVED_FRAME_CODE_ADDR (uint32_t(eSymbolContextEverything + 1))
  45 #define RESOLVED_FRAME_ID_SYMBOL_SCOPE (RESOLVED_FRAME_CODE_ADDR << 1)
  46 #define GOT_FRAME_BASE (RESOLVED_FRAME_ID_SYMBOL_SCOPE << 1)
  47 #define RESOLVED_VARIABLES (GOT_FRAME_BASE << 1)
  48 #define RESOLVED_GLOBAL_VARIABLES (RESOLVED_VARIABLES << 1)
  49
  50 StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx,
  51                        user_id_t unwind_frame_index, addr_t cfa,
  52                        bool cfa_is_valid, addr_t pc, StackFrame::Kind kind,
  53                        const SymbolContext *sc_ptr)
  54     : m_thread_wp(thread_sp), m_frame_index(frame_idx),
  55       m_concrete_frame_index(unwind_frame_index), m_reg_context_sp(),
  56       m_id(pc, cfa, nullptr), m_frame_code_addr(pc), m_sc(), m_flags(),
  57       m_frame_base(), m_frame_base_error(), m_cfa_is_valid(cfa_is_valid),
  58       m_stack_frame_kind(kind), m_variable_list_sp(),
  59       m_variable_list_value_objects(), m_recognized_frame_sp(), m_disassembly(),
  60       m_mutex() {
  61   // If we don't have a CFA value, use the frame index for our StackID so that
  62   // recursive functions properly aren't confused with one another on a history
  63   // stack.
  64   if (IsHistorical() && !m_cfa_is_valid) {
  65     m_id.SetCFA(m_frame_index);
  66   }
  67
  68   if (sc_ptr != nullptr) {
  69     m_sc = *sc_ptr;
  70     m_flags.Set(m_sc.GetResolvedMask());
  71   }
  72 }
  73
  74 StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx,
  75                        user_id_t unwind_frame_index,
  76                        const RegisterContextSP &reg_context_sp, addr_t cfa,
  77                        addr_t pc, const SymbolContext *sc_ptr)
  78     : m_thread_wp(thread_sp), m_frame_index(frame_idx),
  79       m_concrete_frame_index(unwind_frame_index),
  80       m_reg_context_sp(reg_context_sp), m_id(pc, cfa, nullptr),
  81       m_frame_code_addr(pc), m_sc(), m_flags(), m_frame_base(),
  82       m_frame_base_error(), m_cfa_is_valid(true),
  83       m_stack_frame_kind(StackFrame::Kind::Regular), m_variable_list_sp(),
  84       m_variable_list_value_objects(), m_recognized_frame_sp(), m_disassembly(),
  85       m_mutex() {
  86   if (sc_ptr != nullptr) {
  87     m_sc = *sc_ptr;
  88     m_flags.Set(m_sc.GetResolvedMask());
  89   }
  90
  91   if (reg_context_sp && !m_sc.target_sp) {
  92     m_sc.target_sp = reg_context_sp->CalculateTarget();
  93     if (m_sc.target_sp)
  94       m_flags.Set(eSymbolContextTarget);
  95   }
  96 }
  97
  98 StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx,
  99                        user_id_t unwind_frame_index,
 100                        const RegisterContextSP &reg_context_sp, addr_t cfa,
 101                        const Address &pc_addr, const SymbolContext *sc_ptr)
 102     : m_thread_wp(thread_sp), m_frame_index(frame_idx),
 103       m_concrete_frame_index(unwind_frame_index),
 104       m_reg_context_sp(reg_context_sp),
 105       m_id(pc_addr.GetLoadAddress(thread_sp->CalculateTarget().get()), cfa,
 106            nullptr),
 107       m_frame_code_addr(pc_addr), m_sc(), m_flags(), m_frame_base(),
 108       m_frame_base_error(), m_cfa_is_valid(true),
 109       m_stack_frame_kind(StackFrame::Kind::Regular), m_variable_list_sp(),
 110       m_variable_list_value_objects(), m_recognized_frame_sp(), m_disassembly(),
 111       m_mutex() {
 112   if (sc_ptr != nullptr) {
 113     m_sc = *sc_ptr;
 114     m_flags.Set(m_sc.GetResolvedMask());
 115   }
 116
 117   if (!m_sc.target_sp && reg_context_sp) {
 118     m_sc.target_sp = reg_context_sp->CalculateTarget();
 119     if (m_sc.target_sp)
 120       m_flags.Set(eSymbolContextTarget);
 121   }
 122
 123   ModuleSP pc_module_sp(pc_addr.GetModule());
 124   if (!m_sc.module_sp || m_sc.module_sp != pc_module_sp) {
 125     if (pc_module_sp) {
 126       m_sc.module_sp = pc_module_sp;
 127       m_flags.Set(eSymbolContextModule);
 128     } else {
 129       m_sc.module_sp.reset();
 130     }
 131   }
 132 }
 133
 134 StackFrame::~StackFrame() = default;
 135
 136 StackID &StackFrame::GetStackID() {
 137   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 138   // Make sure we have resolved the StackID object's symbol context scope if we
 139   // already haven't looked it up.
 140
 141   if (m_flags.IsClear(RESOLVED_FRAME_ID_SYMBOL_SCOPE)) {
 142     if (m_id.GetSymbolContextScope()) {
 143       // We already have a symbol context scope, we just don't have our flag
 144       // bit set.
 145       m_flags.Set(RESOLVED_FRAME_ID_SYMBOL_SCOPE);
 146     } else {
 147       // Calculate the frame block and use this for the stack ID symbol context
 148       // scope if we have one.
 149       SymbolContextScope *scope = GetFrameBlock();
 150       if (scope == nullptr) {
 151         // We don't have a block, so use the symbol
 152         if (m_flags.IsClear(eSymbolContextSymbol))
 153           GetSymbolContext(eSymbolContextSymbol);
 154
 155         // It is ok if m_sc.symbol is nullptr here
 156         scope = m_sc.symbol;
 157       }
 158       // Set the symbol context scope (the accessor will set the
 159       // RESOLVED_FRAME_ID_SYMBOL_SCOPE bit in m_flags).
 160       SetSymbolContextScope(scope);
 161     }
 162   }
 163   return m_id;
 164 }
 165
 166 uint32_t StackFrame::GetFrameIndex() const {
 167   ThreadSP thread_sp = GetThread();
 168   if (thread_sp)
 169     return thread_sp->GetStackFrameList()->GetVisibleStackFrameIndex(
 170         m_frame_index);
 171   else
 172     return m_frame_index;
 173 }
 174
 175 void StackFrame::SetSymbolContextScope(SymbolContextScope *symbol_scope) {
 176   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 177   m_flags.Set(RESOLVED_FRAME_ID_SYMBOL_SCOPE);
 178   m_id.SetSymbolContextScope(symbol_scope);
 179 }
 180
 181 const Address &StackFrame::GetFrameCodeAddress() {
 182   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 183   if (m_flags.IsClear(RESOLVED_FRAME_CODE_ADDR) &&
 184       !m_frame_code_addr.IsSectionOffset()) {
 185     m_flags.Set(RESOLVED_FRAME_CODE_ADDR);
 186
 187     // Resolve the PC into a temporary address because if ResolveLoadAddress
 188     // fails to resolve the address, it will clear the address object...
 189     ThreadSP thread_sp(GetThread());
 190     if (thread_sp) {
 191       TargetSP target_sp(thread_sp->CalculateTarget());
 192       if (target_sp) {
 193         const bool allow_section_end = true;
 194         if (m_frame_code_addr.SetOpcodeLoadAddress(
 195                 m_frame_code_addr.GetOffset(), target_sp.get(),
 196                 AddressClass::eCode, allow_section_end)) {
 197           ModuleSP module_sp(m_frame_code_addr.GetModule());
 198           if (module_sp) {
 199             m_sc.module_sp = module_sp;
 200             m_flags.Set(eSymbolContextModule);
 201           }
 202         }
 203       }
 204     }
 205   }
 206   return m_frame_code_addr;
 207 }
 208
 209 bool StackFrame::ChangePC(addr_t pc) {
 210   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 211   // We can't change the pc value of a history stack frame - it is immutable.
 212   if (IsHistorical())
 213     return false;
 214   m_frame_code_addr.SetRawAddress(pc);
 215   m_sc.Clear(false);
 216   m_flags.Reset(0);
 217   ThreadSP thread_sp(GetThread());
 218   if (thread_sp)
 219     thread_sp->ClearStackFrames();
 220   return true;
 221 }
 222
 223 const char *StackFrame::Disassemble() {
 224   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 225   if (m_disassembly.Empty()) {
 226     ExecutionContext exe_ctx(shared_from_this());
 227     Target *target = exe_ctx.GetTargetPtr();
 228     if (target) {
 229       const char *plugin_name = nullptr;
 230       const char *flavor = nullptr;
 231       Disassembler::Disassemble(target->GetDebugger(),
 232                                 target->GetArchitecture(), plugin_name, flavor,
 233                                 exe_ctx, 0, false, 0, 0, m_disassembly);
 234     }
 235     if (m_disassembly.Empty())
 236       return nullptr;
 237   }
 238
 239   return m_disassembly.GetData();
 240 }
 241
 242 Block *StackFrame::GetFrameBlock() {
 243   if (m_sc.block == nullptr && m_flags.IsClear(eSymbolContextBlock))
 244     GetSymbolContext(eSymbolContextBlock);
 245
 246   if (m_sc.block) {
 247     Block *inline_block = m_sc.block->GetContainingInlinedBlock();
 248     if (inline_block) {
 249       // Use the block with the inlined function info as the frame block we
 250       // want this frame to have only the variables for the inlined function
 251       // and its non-inlined block child blocks.
 252       return inline_block;
 253     } else {
 254       // This block is not contained within any inlined function blocks with so
 255       // we want to use the top most function block.
 256       return &m_sc.function->GetBlock(false);
 257     }
 258   }
 259   return nullptr;
 260 }
 261
 262 // Get the symbol context if we already haven't done so by resolving the
 263 // PC address as much as possible. This way when we pass around a
 264 // StackFrame object, everyone will have as much information as possible and no
 265 // one will ever have to look things up manually.
 266 const SymbolContext &
 267 StackFrame::GetSymbolContext(SymbolContextItem resolve_scope) {
 268   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 269   // Copy our internal symbol context into "sc".
 270   if ((m_flags.Get() & resolve_scope) != resolve_scope) {
 271     uint32_t resolved = 0;
 272
 273     // If the target was requested add that:
 274     if (!m_sc.target_sp) {
 275       m_sc.target_sp = CalculateTarget();
 276       if (m_sc.target_sp)
 277         resolved |= eSymbolContextTarget;
 278     }
 279
 280     // Resolve our PC to section offset if we haven't already done so and if we
 281     // don't have a module. The resolved address section will contain the
 282     // module to which it belongs
 283     if (!m_sc.module_sp && m_flags.IsClear(RESOLVED_FRAME_CODE_ADDR))
 284       GetFrameCodeAddress();
 285
 286     // If this is not frame zero, then we need to subtract 1 from the PC value
 287     // when doing address lookups since the PC will be on the instruction
 288     // following the function call instruction...
 289
 290     Address lookup_addr(GetFrameCodeAddress());
 291     if (m_frame_index > 0 && lookup_addr.IsValid()) {
 292       addr_t offset = lookup_addr.GetOffset();
 293       if (offset > 0) {
 294         lookup_addr.SetOffset(offset - 1);
 295
 296       } else {
 297         // lookup_addr is the start of a section.  We need do the math on the
 298         // actual load address and re-compute the section.  We're working with
 299         // a 'noreturn' function at the end of a section.
 300         ThreadSP thread_sp(GetThread());
 301         if (thread_sp) {
 302           TargetSP target_sp(thread_sp->CalculateTarget());
 303           if (target_sp) {
 304             addr_t addr_minus_one =
 305                 lookup_addr.GetLoadAddress(target_sp.get()) - 1;
 306             lookup_addr.SetLoadAddress(addr_minus_one, target_sp.get());
 307           } else {
 308             lookup_addr.SetOffset(offset - 1);
 309           }
 310         }
 311       }
 312     }
 313
 314     if (m_sc.module_sp) {
 315       // We have something in our stack frame symbol context, lets check if we
 316       // haven't already tried to lookup one of those things. If we haven't
 317       // then we will do the query.
 318
 319       SymbolContextItem actual_resolve_scope = SymbolContextItem(0);
 320
 321       if (resolve_scope & eSymbolContextCompUnit) {
 322         if (m_flags.IsClear(eSymbolContextCompUnit)) {
 323           if (m_sc.comp_unit)
 324             resolved |= eSymbolContextCompUnit;
 325           else
 326             actual_resolve_scope |= eSymbolContextCompUnit;
 327         }
 328       }
 329
 330       if (resolve_scope & eSymbolContextFunction) {
 331         if (m_flags.IsClear(eSymbolContextFunction)) {
 332           if (m_sc.function)
 333             resolved |= eSymbolContextFunction;
 334           else
 335             actual_resolve_scope |= eSymbolContextFunction;
 336         }
 337       }
 338
 339       if (resolve_scope & eSymbolContextBlock) {
 340         if (m_flags.IsClear(eSymbolContextBlock)) {
 341           if (m_sc.block)
 342             resolved |= eSymbolContextBlock;
 343           else
 344             actual_resolve_scope |= eSymbolContextBlock;
 345         }
 346       }
 347
 348       if (resolve_scope & eSymbolContextSymbol) {
 349         if (m_flags.IsClear(eSymbolContextSymbol)) {
 350           if (m_sc.symbol)
 351             resolved |= eSymbolContextSymbol;
 352           else
 353             actual_resolve_scope |= eSymbolContextSymbol;
 354         }
 355       }
 356
 357       if (resolve_scope & eSymbolContextLineEntry) {
 358         if (m_flags.IsClear(eSymbolContextLineEntry)) {
 359           if (m_sc.line_entry.IsValid())
 360             resolved |= eSymbolContextLineEntry;
 361           else
 362             actual_resolve_scope |= eSymbolContextLineEntry;
 363         }
 364       }
 365
 366       if (actual_resolve_scope) {
 367         // We might be resolving less information than what is already in our
 368         // current symbol context so resolve into a temporary symbol context
 369         // "sc" so we don't clear out data we have already found in "m_sc"
 370         SymbolContext sc;
 371         // Set flags that indicate what we have tried to resolve
 372         resolved |= m_sc.module_sp->ResolveSymbolContextForAddress(
 373             lookup_addr, actual_resolve_scope, sc);
 374         // Only replace what we didn't already have as we may have information
 375         // for an inlined function scope that won't match what a standard
 376         // lookup by address would match
 377         if ((resolved & eSymbolContextCompUnit) && m_sc.comp_unit == nullptr)
 378           m_sc.comp_unit = sc.comp_unit;
 379         if ((resolved & eSymbolContextFunction) && m_sc.function == nullptr)
 380           m_sc.function = sc.function;
 381         if ((resolved & eSymbolContextBlock) && m_sc.block == nullptr)
 382           m_sc.block = sc.block;
 383         if ((resolved & eSymbolContextSymbol) && m_sc.symbol == nullptr)
 384           m_sc.symbol = sc.symbol;
 385         if ((resolved & eSymbolContextLineEntry) &&
 386             !m_sc.line_entry.IsValid()) {
 387           m_sc.line_entry = sc.line_entry;
 388           m_sc.line_entry.ApplyFileMappings(m_sc.target_sp);
 389         }
 390       }
 391     } else {
 392       // If we don't have a module, then we can't have the compile unit,
 393       // function, block, line entry or symbol, so we can safely call
 394       // ResolveSymbolContextForAddress with our symbol context member m_sc.
 395       if (m_sc.target_sp) {
 396         resolved |= m_sc.target_sp->GetImages().ResolveSymbolContextForAddress(
 397             lookup_addr, resolve_scope, m_sc);
 398       }
 399     }
 400
 401     // Update our internal flags so we remember what we have tried to locate so
 402     // we don't have to keep trying when more calls to this function are made.
 403     // We might have dug up more information that was requested (for example if
 404     // we were asked to only get the block, we will have gotten the compile
 405     // unit, and function) so set any additional bits that we resolved
 406     m_flags.Set(resolve_scope | resolved);
 407   }
 408
 409   // Return the symbol context with everything that was possible to resolve
 410   // resolved.
 411   return m_sc;
 412 }
 413
 414 VariableList *StackFrame::GetVariableList(bool get_file_globals) {
 415   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 416   if (m_flags.IsClear(RESOLVED_VARIABLES)) {
 417     m_flags.Set(RESOLVED_VARIABLES);
 418
 419     Block *frame_block = GetFrameBlock();
 420
 421     if (frame_block) {
 422       const bool get_child_variables = true;
 423       const bool can_create = true;
 424       const bool stop_if_child_block_is_inlined_function = true;
 425       m_variable_list_sp = std::make_shared<VariableList>();
 426       frame_block->AppendBlockVariables(can_create, get_child_variables,
 427                                         stop_if_child_block_is_inlined_function,
 428                                         [](Variable *v) { return true; },
 429                                         m_variable_list_sp.get());
 430     }
 431   }
 432
 433   if (m_flags.IsClear(RESOLVED_GLOBAL_VARIABLES) && get_file_globals) {
 434     m_flags.Set(RESOLVED_GLOBAL_VARIABLES);
 435
 436     if (m_flags.IsClear(eSymbolContextCompUnit))
 437       GetSymbolContext(eSymbolContextCompUnit);
 438
 439     if (m_sc.comp_unit) {
 440       VariableListSP global_variable_list_sp(
 441           m_sc.comp_unit->GetVariableList(true));
 442       if (m_variable_list_sp)
 443         m_variable_list_sp->AddVariables(global_variable_list_sp.get());
 444       else
 445         m_variable_list_sp = global_variable_list_sp;
 446     }
 447   }
 448
 449   return m_variable_list_sp.get();
 450 }
 451
 452 VariableListSP
 453 StackFrame::GetInScopeVariableList(bool get_file_globals,
 454                                    bool must_have_valid_location) {
 455   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 456   // We can't fetch variable information for a history stack frame.
 457   if (IsHistorical())
 458     return VariableListSP();
 459
 460   VariableListSP var_list_sp(new VariableList);
 461   GetSymbolContext(eSymbolContextCompUnit | eSymbolContextBlock);
 462
 463   if (m_sc.block) {
 464     const bool can_create = true;
 465     const bool get_parent_variables = true;
 466     const bool stop_if_block_is_inlined_function = true;
 467     m_sc.block->AppendVariables(
 468         can_create, get_parent_variables, stop_if_block_is_inlined_function,
 469         [this, must_have_valid_location](Variable *v) {
 470           return v->IsInScope(this) && (!must_have_valid_location ||
 471                                         v->LocationIsValidForFrame(this));
 472         },
 473         var_list_sp.get());
 474   }
 475
 476   if (m_sc.comp_unit && get_file_globals) {
 477     VariableListSP global_variable_list_sp(
 478         m_sc.comp_unit->GetVariableList(true));
 479     if (global_variable_list_sp)
 480       var_list_sp->AddVariables(global_variable_list_sp.get());
 481   }
 482
 483   return var_list_sp;
 484 }
 485
 486 ValueObjectSP StackFrame::GetValueForVariableExpressionPath(
 487     llvm::StringRef var_expr, DynamicValueType use_dynamic, uint32_t options,
 488     VariableSP &var_sp, Status &error) {
 489   llvm::StringRef original_var_expr = var_expr;
 490   // We can't fetch variable information for a history stack frame.
 491   if (IsHistorical())
 492     return ValueObjectSP();
 493
 494   if (var_expr.empty()) {
 495     error.SetErrorStringWithFormat("invalid variable path '%s'",
 496                                    var_expr.str().c_str());
 497     return ValueObjectSP();
 498   }
 499
 500   const bool check_ptr_vs_member =
 501       (options & eExpressionPathOptionCheckPtrVsMember) != 0;
 502   const bool no_fragile_ivar =
 503       (options & eExpressionPathOptionsNoFragileObjcIvar) != 0;
 504   const bool no_synth_child =
 505       (options & eExpressionPathOptionsNoSyntheticChildren) != 0;
 506   // const bool no_synth_array = (options &
 507   // eExpressionPathOptionsNoSyntheticArrayRange) != 0;
 508   error.Clear();
 509   bool deref = false;
 510   bool address_of = false;
 511   ValueObjectSP valobj_sp;
 512   const bool get_file_globals = true;
 513   // When looking up a variable for an expression, we need only consider the
 514   // variables that are in scope.
 515   VariableListSP var_list_sp(GetInScopeVariableList(get_file_globals));
 516   VariableList *variable_list = var_list_sp.get();
 517
 518   if (!variable_list)
 519     return ValueObjectSP();
 520
 521   // If first character is a '*', then show pointer contents
 522   std::string var_expr_storage;
 523   if (var_expr[0] == '*') {
 524     deref = true;
 525     var_expr = var_expr.drop_front(); // Skip the '*'
 526   } else if (var_expr[0] == '&') {
 527     address_of = true;
 528     var_expr = var_expr.drop_front(); // Skip the '&'
 529   }
 530
 531   size_t separator_idx = var_expr.find_first_of(".-[=+~|&^%#@!/?,<>{}");
 532   StreamString var_expr_path_strm;
 533
 534   ConstString name_const_string(var_expr.substr(0, separator_idx));
 535
 536   var_sp = variable_list->FindVariable(name_const_string, false);
 537
 538   bool synthetically_added_instance_object = false;
 539
 540   if (var_sp) {
 541     var_expr = var_expr.drop_front(name_const_string.GetLength());
 542   }
 543
 544   if (!var_sp && (options & eExpressionPathOptionsAllowDirectIVarAccess)) {
 545     // Check for direct ivars access which helps us with implicit access to
 546     // ivars with the "this->" or "self->"
 547     GetSymbolContext(eSymbolContextFunction | eSymbolContextBlock);
 548     lldb::LanguageType method_language = eLanguageTypeUnknown;
 549     bool is_instance_method = false;
 550     ConstString method_object_name;
 551     if (m_sc.GetFunctionMethodInfo(method_language, is_instance_method,
 552                                    method_object_name)) {
 553       if (is_instance_method && method_object_name) {
 554         var_sp = variable_list->FindVariable(method_object_name);
 555         if (var_sp) {
 556           separator_idx = 0;
 557           var_expr_storage = "->";
 558           var_expr_storage += var_expr;
 559           var_expr = var_expr_storage;
 560           synthetically_added_instance_object = true;
 561         }
 562       }
 563     }
 564   }
 565
 566   if (!var_sp && (options & eExpressionPathOptionsInspectAnonymousUnions)) {
 567     // Check if any anonymous unions are there which contain a variable with
 568     // the name we need
 569     for (size_t i = 0; i < variable_list->GetSize(); i++) {
 570       VariableSP variable_sp = variable_list->GetVariableAtIndex(i);
 571       if (!variable_sp)
 572         continue;
 573       if (!variable_sp->GetName().IsEmpty())
 574         continue;
 575
 576       Type *var_type = variable_sp->GetType();
 577       if (!var_type)
 578         continue;
 579
 580       if (!var_type->GetForwardCompilerType().IsAnonymousType())
 581         continue;
 582       valobj_sp = GetValueObjectForFrameVariable(variable_sp, use_dynamic);
 583       if (!valobj_sp)
 584         return valobj_sp;
 585       valobj_sp = valobj_sp->GetChildMemberWithName(name_const_string, true);
 586       if (valobj_sp)
 587         break;
 588     }
 589   }
 590
 591   if (var_sp && !valobj_sp) {
 592     valobj_sp = GetValueObjectForFrameVariable(var_sp, use_dynamic);
 593     if (!valobj_sp)
 594       return valobj_sp;
 595   }
 596   if (!valobj_sp) {
 597     error.SetErrorStringWithFormat("no variable named '%s' found in this frame",
 598                                    name_const_string.GetCString());
 599     return ValueObjectSP();
 600   }
 601
 602   // We are dumping at least one child
 603   while (separator_idx != std::string::npos) {
 604     // Calculate the next separator index ahead of time
 605     ValueObjectSP child_valobj_sp;
 606     const char separator_type = var_expr[0];
 607     bool expr_is_ptr = false;
 608     switch (separator_type) {
 609     case '-':
 610       expr_is_ptr = true;
 611       if (var_expr.size() >= 2 && var_expr[1] != '>')
 612         return ValueObjectSP();
 613
 614       if (no_fragile_ivar) {
 615         // Make sure we aren't trying to deref an objective
 616         // C ivar if this is not allowed
 617         const uint32_t pointer_type_flags =
 618             valobj_sp->GetCompilerType().GetTypeInfo(nullptr);
 619         if ((pointer_type_flags & eTypeIsObjC) &&
 620             (pointer_type_flags & eTypeIsPointer)) {
 621           // This was an objective C object pointer and it was requested we
 622           // skip any fragile ivars so return nothing here
 623           return ValueObjectSP();
 624         }
 625       }
 626
 627       // If we have a non pointer type with a sythetic value then lets check if
 628       // we have an sythetic dereference specified.
 629       if (!valobj_sp->IsPointerType() && valobj_sp->HasSyntheticValue()) {
 630         Status deref_error;
 631         if (valobj_sp->GetCompilerType().IsReferenceType()) {
 632           valobj_sp = valobj_sp->GetSyntheticValue()->Dereference(deref_error);
 633           if (error.Fail()) {
 634             error.SetErrorStringWithFormatv(
 635                 "Failed to dereference reference type: %s", deref_error);
 636             return ValueObjectSP();
 637           }
 638         }
 639
 640         valobj_sp = valobj_sp->Dereference(deref_error);
 641         if (error.Fail()) {
 642           error.SetErrorStringWithFormatv(
 643               "Failed to dereference sythetic value: {0}", deref_error);
 644           return ValueObjectSP();
 645         }
 646         // Some synthetic plug-ins fail to set the error in Dereference
 647         if (!valobj_sp) {
 648           error.SetErrorString("Failed to dereference sythetic value");
 649           return ValueObjectSP();
 650         }
 651         expr_is_ptr = false;
 652       }
 653
 654       var_expr = var_expr.drop_front(); // Remove the '-'
 655       LLVM_FALLTHROUGH;
 656     case '.': {
 657       var_expr = var_expr.drop_front(); // Remove the '.' or '>'
 658       separator_idx = var_expr.find_first_of(".-[");
 659       ConstString child_name(var_expr.substr(0, var_expr.find_first_of(".-[")));
 660
 661       if (check_ptr_vs_member) {
 662         // We either have a pointer type and need to verify valobj_sp is a
 663         // pointer, or we have a member of a class/union/struct being accessed
 664         // with the . syntax and need to verify we don't have a pointer.
 665         const bool actual_is_ptr = valobj_sp->IsPointerType();
 666
 667         if (actual_is_ptr != expr_is_ptr) {
 668           // Incorrect use of "." with a pointer, or "->" with a
 669           // class/union/struct instance or reference.
 670           valobj_sp->GetExpressionPath(var_expr_path_strm, false);
 671           if (actual_is_ptr)
 672             error.SetErrorStringWithFormat(
 673                 "\"%s\" is a pointer and . was used to attempt to access "
 674                 "\"%s\". Did you mean \"%s->%s\"?",
 675                 var_expr_path_strm.GetData(), child_name.GetCString(),
 676                 var_expr_path_strm.GetData(), var_expr.str().c_str());
 677           else
 678             error.SetErrorStringWithFormat(
 679                 "\"%s\" is not a pointer and -> was used to attempt to "
 680                 "access \"%s\". Did you mean \"%s.%s\"?",
 681                 var_expr_path_strm.GetData(), child_name.GetCString(),
 682                 var_expr_path_strm.GetData(), var_expr.str().c_str());
 683           return ValueObjectSP();
 684         }
 685       }
 686       child_valobj_sp = valobj_sp->GetChildMemberWithName(child_name, true);
 687       if (!child_valobj_sp) {
 688         if (!no_synth_child) {
 689           child_valobj_sp = valobj_sp->GetSyntheticValue();
 690           if (child_valobj_sp)
 691             child_valobj_sp =
 692                 child_valobj_sp->GetChildMemberWithName(child_name, true);
 693         }
 694
 695         if (no_synth_child || !child_valobj_sp) {
 696           // No child member with name "child_name"
 697           if (synthetically_added_instance_object) {
 698             // We added a "this->" or "self->" to the beginning of the
 699             // expression and this is the first pointer ivar access, so just
 700             // return the normal error
 701             error.SetErrorStringWithFormat(
 702                 "no variable or instance variable named '%s' found in "
 703                 "this frame",
 704                 name_const_string.GetCString());
 705           } else {
 706             valobj_sp->GetExpressionPath(var_expr_path_strm, false);
 707             if (child_name) {
 708               error.SetErrorStringWithFormat(
 709                   "\"%s\" is not a member of \"(%s) %s\"",
 710                   child_name.GetCString(),
 711                   valobj_sp->GetTypeName().AsCString("<invalid type>"),
 712                   var_expr_path_strm.GetData());
 713             } else {
 714               error.SetErrorStringWithFormat(
 715                   "incomplete expression path after \"%s\" in \"%s\"",
 716                   var_expr_path_strm.GetData(),
 717                   original_var_expr.str().c_str());
 718             }
 719           }
 720           return ValueObjectSP();
 721         }
 722       }
 723       synthetically_added_instance_object = false;
 724       // Remove the child name from the path
 725       var_expr = var_expr.drop_front(child_name.GetLength());
 726       if (use_dynamic != eNoDynamicValues) {
 727         ValueObjectSP dynamic_value_sp(
 728             child_valobj_sp->GetDynamicValue(use_dynamic));
 729         if (dynamic_value_sp)
 730           child_valobj_sp = dynamic_value_sp;
 731       }
 732     } break;
 733
 734     case '[': {
 735       // Array member access, or treating pointer as an array Need at least two
 736       // brackets and a number
 737       if (var_expr.size() <= 2) {
 738         error.SetErrorStringWithFormat(
 739             "invalid square bracket encountered after \"%s\" in \"%s\"",
 740             var_expr_path_strm.GetData(), var_expr.str().c_str());
 741         return ValueObjectSP();
 742       }
 743
 744       // Drop the open brace.
 745       var_expr = var_expr.drop_front();
 746       long child_index = 0;
 747
 748       // If there's no closing brace, this is an invalid expression.
 749       size_t end_pos = var_expr.find_first_of(']');
 750       if (end_pos == llvm::StringRef::npos) {
 751         error.SetErrorStringWithFormat(
 752             "missing closing square bracket in expression \"%s\"",
 753             var_expr_path_strm.GetData());
 754         return ValueObjectSP();
 755       }
 756       llvm::StringRef index_expr = var_expr.take_front(end_pos);
 757       llvm::StringRef original_index_expr = index_expr;
 758       // Drop all of "[index_expr]"
 759       var_expr = var_expr.drop_front(end_pos + 1);
 760
 761       if (index_expr.consumeInteger(0, child_index)) {
 762         // If there was no integer anywhere in the index expression, this is
 763         // erroneous expression.
 764         error.SetErrorStringWithFormat("invalid index expression \"%s\"",
 765                                        index_expr.str().c_str());
 766         return ValueObjectSP();
 767       }
 768
 769       if (index_expr.empty()) {
 770         // The entire index expression was a single integer.
 771
 772         if (valobj_sp->GetCompilerType().IsPointerToScalarType() && deref) {
 773           // what we have is *ptr[low]. the most similar C++ syntax is to deref
 774           // ptr and extract bit low out of it. reading array item low would be
 775           // done by saying ptr[low], without a deref * sign
 776           Status error;
 777           ValueObjectSP temp(valobj_sp->Dereference(error));
 778           if (error.Fail()) {
 779             valobj_sp->GetExpressionPath(var_expr_path_strm, false);
 780             error.SetErrorStringWithFormat(
 781                 "could not dereference \"(%s) %s\"",
 782                 valobj_sp->GetTypeName().AsCString("<invalid type>"),
 783                 var_expr_path_strm.GetData());
 784             return ValueObjectSP();
 785           }
 786           valobj_sp = temp;
 787           deref = false;
 788         } else if (valobj_sp->GetCompilerType().IsArrayOfScalarType() &&
 789                    deref) {
 790           // what we have is *arr[low]. the most similar C++ syntax is to get
 791           // arr[0] (an operation that is equivalent to deref-ing arr) and
 792           // extract bit low out of it. reading array item low would be done by
 793           // saying arr[low], without a deref * sign
 794           Status error;
 795           ValueObjectSP temp(valobj_sp->GetChildAtIndex(0, true));
 796           if (error.Fail()) {
 797             valobj_sp->GetExpressionPath(var_expr_path_strm, false);
 798             error.SetErrorStringWithFormat(
 799                 "could not get item 0 for \"(%s) %s\"",
 800                 valobj_sp->GetTypeName().AsCString("<invalid type>"),
 801                 var_expr_path_strm.GetData());
 802             return ValueObjectSP();
 803           }
 804           valobj_sp = temp;
 805           deref = false;
 806         }
 807
 808         bool is_incomplete_array = false;
 809         if (valobj_sp->IsPointerType()) {
 810           bool is_objc_pointer = true;
 811
 812           if (valobj_sp->GetCompilerType().GetMinimumLanguage() !=
 813               eLanguageTypeObjC)
 814             is_objc_pointer = false;
 815           else if (!valobj_sp->GetCompilerType().IsPointerType())
 816             is_objc_pointer = false;
 817
 818           if (no_synth_child && is_objc_pointer) {
 819             error.SetErrorStringWithFormat(
 820                 "\"(%s) %s\" is an Objective-C pointer, and cannot be "
 821                 "subscripted",
 822                 valobj_sp->GetTypeName().AsCString("<invalid type>"),
 823                 var_expr_path_strm.GetData());
 824
 825             return ValueObjectSP();
 826           } else if (is_objc_pointer) {
 827             // dereferencing ObjC variables is not valid.. so let's try and
 828             // recur to synthetic children
 829             ValueObjectSP synthetic = valobj_sp->GetSyntheticValue();
 830             if (!synthetic                 /* no synthetic */
 831                 || synthetic == valobj_sp) /* synthetic is the same as
 832                                               the original object */
 833             {
 834               valobj_sp->GetExpressionPath(var_expr_path_strm, false);
 835               error.SetErrorStringWithFormat(
 836                   "\"(%s) %s\" is not an array type",
 837                   valobj_sp->GetTypeName().AsCString("<invalid type>"),
 838                   var_expr_path_strm.GetData());
 839             } else if (
 840                 static_cast<uint32_t>(child_index) >=
 841                 synthetic
 842                     ->GetNumChildren() /* synthetic does not have that many values */) {
 843               valobj_sp->GetExpressionPath(var_expr_path_strm, false);
 844               error.SetErrorStringWithFormat(
 845                   "array index %ld is not valid for \"(%s) %s\"", child_index,
 846                   valobj_sp->GetTypeName().AsCString("<invalid type>"),
 847                   var_expr_path_strm.GetData());
 848             } else {
 849               child_valobj_sp = synthetic->GetChildAtIndex(child_index, true);
 850               if (!child_valobj_sp) {
 851                 valobj_sp->GetExpressionPath(var_expr_path_strm, false);
 852                 error.SetErrorStringWithFormat(
 853                     "array index %ld is not valid for \"(%s) %s\"", child_index,
 854                     valobj_sp->GetTypeName().AsCString("<invalid type>"),
 855                     var_expr_path_strm.GetData());
 856               }
 857             }
 858           } else {
 859             child_valobj_sp =
 860                 valobj_sp->GetSyntheticArrayMember(child_index, true);
 861             if (!child_valobj_sp) {
 862               valobj_sp->GetExpressionPath(var_expr_path_strm, false);
 863               error.SetErrorStringWithFormat(
 864                   "failed to use pointer as array for index %ld for "
 865                   "\"(%s) %s\"",
 866                   child_index,
 867                   valobj_sp->GetTypeName().AsCString("<invalid type>"),
 868                   var_expr_path_strm.GetData());
 869             }
 870           }
 871         } else if (valobj_sp->GetCompilerType().IsArrayType(
 872                        nullptr, nullptr, &is_incomplete_array)) {
 873           // Pass false to dynamic_value here so we can tell the difference
 874           // between no dynamic value and no member of this type...
 875           child_valobj_sp = valobj_sp->GetChildAtIndex(child_index, true);
 876           if (!child_valobj_sp && (is_incomplete_array || !no_synth_child))
 877             child_valobj_sp =
 878                 valobj_sp->GetSyntheticArrayMember(child_index, true);
 879
 880           if (!child_valobj_sp) {
 881             valobj_sp->GetExpressionPath(var_expr_path_strm, false);
 882             error.SetErrorStringWithFormat(
 883                 "array index %ld is not valid for \"(%s) %s\"", child_index,
 884                 valobj_sp->GetTypeName().AsCString("<invalid type>"),
 885                 var_expr_path_strm.GetData());
 886           }
 887         } else if (valobj_sp->GetCompilerType().IsScalarType()) {
 888           // this is a bitfield asking to display just one bit
 889           child_valobj_sp = valobj_sp->GetSyntheticBitFieldChild(
 890               child_index, child_index, true);
 891           if (!child_valobj_sp) {
 892             valobj_sp->GetExpressionPath(var_expr_path_strm, false);
 893             error.SetErrorStringWithFormat(
 894                 "bitfield range %ld-%ld is not valid for \"(%s) %s\"",
 895                 child_index, child_index,
 896                 valobj_sp->GetTypeName().AsCString("<invalid type>"),
 897                 var_expr_path_strm.GetData());
 898           }
 899         } else {
 900           ValueObjectSP synthetic = valobj_sp->GetSyntheticValue();
 901           if (no_synth_child /* synthetic is forbidden */ ||
 902               !synthetic                 /* no synthetic */
 903               || synthetic == valobj_sp) /* synthetic is the same as the
 904                                             original object */
 905           {
 906             valobj_sp->GetExpressionPath(var_expr_path_strm, false);
 907             error.SetErrorStringWithFormat(
 908                 "\"(%s) %s\" is not an array type",
 909                 valobj_sp->GetTypeName().AsCString("<invalid type>"),
 910                 var_expr_path_strm.GetData());
 911           } else if (
 912               static_cast<uint32_t>(child_index) >=
 913               synthetic
 914                   ->GetNumChildren() /* synthetic does not have that many values */) {
 915             valobj_sp->GetExpressionPath(var_expr_path_strm, false);
 916             error.SetErrorStringWithFormat(
 917                 "array index %ld is not valid for \"(%s) %s\"", child_index,
 918                 valobj_sp->GetTypeName().AsCString("<invalid type>"),
 919                 var_expr_path_strm.GetData());
 920           } else {
 921             child_valobj_sp = synthetic->GetChildAtIndex(child_index, true);
 922             if (!child_valobj_sp) {
 923               valobj_sp->GetExpressionPath(var_expr_path_strm, false);
 924               error.SetErrorStringWithFormat(
 925                   "array index %ld is not valid for \"(%s) %s\"", child_index,
 926                   valobj_sp->GetTypeName().AsCString("<invalid type>"),
 927                   var_expr_path_strm.GetData());
 928             }
 929           }
 930         }
 931
 932         if (!child_valobj_sp) {
 933           // Invalid array index...
 934           return ValueObjectSP();
 935         }
 936
 937         separator_idx = var_expr.find_first_of(".-[");
 938         if (use_dynamic != eNoDynamicValues) {
 939           ValueObjectSP dynamic_value_sp(
 940               child_valobj_sp->GetDynamicValue(use_dynamic));
 941           if (dynamic_value_sp)
 942             child_valobj_sp = dynamic_value_sp;
 943         }
 944         // Break out early from the switch since we were able to find the child
 945         // member
 946         break;
 947       }
 948
 949       // this is most probably a BitField, let's take a look
 950       if (index_expr.front() != '-') {
 951         error.SetErrorStringWithFormat("invalid range expression \"'%s'\"",
 952                                        original_index_expr.str().c_str());
 953         return ValueObjectSP();
 954       }
 955
 956       index_expr = index_expr.drop_front();
 957       long final_index = 0;
 958       if (index_expr.getAsInteger(0, final_index)) {
 959         error.SetErrorStringWithFormat("invalid range expression \"'%s'\"",
 960                                        original_index_expr.str().c_str());
 961         return ValueObjectSP();
 962       }
 963
 964       // if the format given is [high-low], swap range
 965       if (child_index > final_index) {
 966         long temp = child_index;
 967         child_index = final_index;
 968         final_index = temp;
 969       }
 970
 971       if (valobj_sp->GetCompilerType().IsPointerToScalarType() && deref) {
 972         // what we have is *ptr[low-high]. the most similar C++ syntax is to
 973         // deref ptr and extract bits low thru high out of it. reading array
 974         // items low thru high would be done by saying ptr[low-high], without a
 975         // deref * sign
 976         Status error;
 977         ValueObjectSP temp(valobj_sp->Dereference(error));
 978         if (error.Fail()) {
 979           valobj_sp->GetExpressionPath(var_expr_path_strm, false);
 980           error.SetErrorStringWithFormat(
 981               "could not dereference \"(%s) %s\"",
 982               valobj_sp->GetTypeName().AsCString("<invalid type>"),
 983               var_expr_path_strm.GetData());
 984           return ValueObjectSP();
 985         }
 986         valobj_sp = temp;
 987         deref = false;
 988       } else if (valobj_sp->GetCompilerType().IsArrayOfScalarType() && deref) {
 989         // what we have is *arr[low-high]. the most similar C++ syntax is to
 990         // get arr[0] (an operation that is equivalent to deref-ing arr) and
 991         // extract bits low thru high out of it. reading array items low thru
 992         // high would be done by saying arr[low-high], without a deref * sign
 993         Status error;
 994         ValueObjectSP temp(valobj_sp->GetChildAtIndex(0, true));
 995         if (error.Fail()) {
 996           valobj_sp->GetExpressionPath(var_expr_path_strm, false);
 997           error.SetErrorStringWithFormat(
 998               "could not get item 0 for \"(%s) %s\"",
 999               valobj_sp->GetTypeName().AsCString("<invalid type>"),
1000               var_expr_path_strm.GetData());
1001           return ValueObjectSP();
1002         }
1003         valobj_sp = temp;
1004         deref = false;
1005       }
1006
1007       child_valobj_sp =
1008           valobj_sp->GetSyntheticBitFieldChild(child_index, final_index, true);
1009       if (!child_valobj_sp) {
1010         valobj_sp->GetExpressionPath(var_expr_path_strm, false);
1011         error.SetErrorStringWithFormat(
1012             "bitfield range %ld-%ld is not valid for \"(%s) %s\"", child_index,
1013             final_index, valobj_sp->GetTypeName().AsCString("<invalid type>"),
1014             var_expr_path_strm.GetData());
1015       }
1016
1017       if (!child_valobj_sp) {
1018         // Invalid bitfield range...
1019         return ValueObjectSP();
1020       }
1021
1022       separator_idx = var_expr.find_first_of(".-[");
1023       if (use_dynamic != eNoDynamicValues) {
1024         ValueObjectSP dynamic_value_sp(
1025             child_valobj_sp->GetDynamicValue(use_dynamic));
1026         if (dynamic_value_sp)
1027           child_valobj_sp = dynamic_value_sp;
1028       }
1029       // Break out early from the switch since we were able to find the child
1030       // member
1031       break;
1032     }
1033     default:
1034       // Failure...
1035       {
1036         valobj_sp->GetExpressionPath(var_expr_path_strm, false);
1037         error.SetErrorStringWithFormat(
1038             "unexpected char '%c' encountered after \"%s\" in \"%s\"",
1039             separator_type, var_expr_path_strm.GetData(),
1040             var_expr.str().c_str());
1041
1042         return ValueObjectSP();
1043       }
1044     }
1045
1046     if (child_valobj_sp)
1047       valobj_sp = child_valobj_sp;
1048
1049     if (var_expr.empty())
1050       break;
1051   }
1052   if (valobj_sp) {
1053     if (deref) {
1054       ValueObjectSP deref_valobj_sp(valobj_sp->Dereference(error));
1055       valobj_sp = deref_valobj_sp;
1056     } else if (address_of) {
1057       ValueObjectSP address_of_valobj_sp(valobj_sp->AddressOf(error));
1058       valobj_sp = address_of_valobj_sp;
1059     }
1060   }
1061   return valobj_sp;
1062 }
1063
1064 bool StackFrame::GetFrameBaseValue(Scalar &frame_base, Status *error_ptr) {
1065   std::lock_guard<std::recursive_mutex> guard(m_mutex);
1066   if (!m_cfa_is_valid) {
1067     m_frame_base_error.SetErrorString(
1068         "No frame base available for this historical stack frame.");
1069     return false;
1070   }
1071
1072   if (m_flags.IsClear(GOT_FRAME_BASE)) {
1073     if (m_sc.function) {
1074       m_frame_base.Clear();
1075       m_frame_base_error.Clear();
1076
1077       m_flags.Set(GOT_FRAME_BASE);
1078       ExecutionContext exe_ctx(shared_from_this());
1079       Value expr_value;
1080       addr_t loclist_base_addr = LLDB_INVALID_ADDRESS;
1081       if (m_sc.function->GetFrameBaseExpression().IsLocationList())
1082         loclist_base_addr =
1083             m_sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress(
1084                 exe_ctx.GetTargetPtr());
1085
1086       if (!m_sc.function->GetFrameBaseExpression().Evaluate(
1087               &exe_ctx, nullptr, loclist_base_addr, nullptr, nullptr,
1088               expr_value, &m_frame_base_error)) {
1089         // We should really have an error if evaluate returns, but in case we
1090         // don't, lets set the error to something at least.
1091         if (m_frame_base_error.Success())
1092           m_frame_base_error.SetErrorString(
1093               "Evaluation of the frame base expression failed.");
1094       } else {
1095         m_frame_base = expr_value.ResolveValue(&exe_ctx);
1096       }
1097     } else {
1098       m_frame_base_error.SetErrorString("No function in symbol context.");
1099     }
1100   }
1101
1102   if (m_frame_base_error.Success())
1103     frame_base = m_frame_base;
1104
1105   if (error_ptr)
1106     *error_ptr = m_frame_base_error;
1107   return m_frame_base_error.Success();
1108 }
1109
1110 DWARFExpression *StackFrame::GetFrameBaseExpression(Status *error_ptr) {
1111   if (!m_sc.function) {
1112     if (error_ptr) {
1113       error_ptr->SetErrorString("No function in symbol context.");
1114     }
1115     return nullptr;
1116   }
1117
1118   return &m_sc.function->GetFrameBaseExpression();
1119 }
1120
1121 RegisterContextSP StackFrame::GetRegisterContext() {
1122   std::lock_guard<std::recursive_mutex> guard(m_mutex);
1123   if (!m_reg_context_sp) {
1124     ThreadSP thread_sp(GetThread());
1125     if (thread_sp)
1126       m_reg_context_sp = thread_sp->CreateRegisterContextForFrame(this);
1127   }
1128   return m_reg_context_sp;
1129 }
1130
1131 bool StackFrame::HasDebugInformation() {
1132   GetSymbolContext(eSymbolContextLineEntry);
1133   return m_sc.line_entry.IsValid();
1134 }
1135
1136 ValueObjectSP
1137 StackFrame::GetValueObjectForFrameVariable(const VariableSP &variable_sp,
1138                                            DynamicValueType use_dynamic) {
1139   std::lock_guard<std::recursive_mutex> guard(m_mutex);
1140   ValueObjectSP valobj_sp;
1141   if (IsHistorical()) {
1142     return valobj_sp;
1143   }
1144   VariableList *var_list = GetVariableList(true);
1145   if (var_list) {
1146     // Make sure the variable is a frame variable
1147     const uint32_t var_idx = var_list->FindIndexForVariable(variable_sp.get());
1148     const uint32_t num_variables = var_list->GetSize();
1149     if (var_idx < num_variables) {
1150       valobj_sp = m_variable_list_value_objects.GetValueObjectAtIndex(var_idx);
1151       if (!valobj_sp) {
1152         if (m_variable_list_value_objects.GetSize() < num_variables)
1153           m_variable_list_value_objects.Resize(num_variables);
1154         valobj_sp = ValueObjectVariable::Create(this, variable_sp);
1155         m_variable_list_value_objects.SetValueObjectAtIndex(var_idx, valobj_sp);
1156       }
1157     }
1158   }
1159   if (use_dynamic != eNoDynamicValues && valobj_sp) {
1160     ValueObjectSP dynamic_sp = valobj_sp->GetDynamicValue(use_dynamic);
1161     if (dynamic_sp)
1162       return dynamic_sp;
1163   }
1164   return valobj_sp;
1165 }
1166
1167 ValueObjectSP StackFrame::TrackGlobalVariable(const VariableSP &variable_sp,
1168                                               DynamicValueType use_dynamic) {
1169   std::lock_guard<std::recursive_mutex> guard(m_mutex);
1170   if (IsHistorical())
1171     return ValueObjectSP();
1172
1173   // Check to make sure we aren't already tracking this variable?
1174   ValueObjectSP valobj_sp(
1175       GetValueObjectForFrameVariable(variable_sp, use_dynamic));
1176   if (!valobj_sp) {
1177     // We aren't already tracking this global
1178     VariableList *var_list = GetVariableList(true);
1179     // If this frame has no variables, create a new list
1180     if (var_list == nullptr)
1181       m_variable_list_sp = std::make_shared<VariableList>();
1182
1183     // Add the global/static variable to this frame
1184     m_variable_list_sp->AddVariable(variable_sp);
1185
1186     // Now make a value object for it so we can track its changes
1187     valobj_sp = GetValueObjectForFrameVariable(variable_sp, use_dynamic);
1188   }
1189   return valobj_sp;
1190 }
1191
1192 bool StackFrame::IsInlined() {
1193   if (m_sc.block == nullptr)
1194     GetSymbolContext(eSymbolContextBlock);
1195   if (m_sc.block)
1196     return m_sc.block->GetContainingInlinedBlock() != nullptr;
1197   return false;
1198 }
1199
1200 bool StackFrame::IsHistorical() const {
1201   return m_stack_frame_kind == StackFrame::Kind::History;
1202 }
1203
1204 bool StackFrame::IsArtificial() const {
1205   return m_stack_frame_kind == StackFrame::Kind::Artificial;
1206 }
1207
1208 lldb::LanguageType StackFrame::GetLanguage() {
1209   CompileUnit *cu = GetSymbolContext(eSymbolContextCompUnit).comp_unit;
1210   if (cu)
1211     return cu->GetLanguage();
1212   return lldb::eLanguageTypeUnknown;
1213 }
1214
1215 lldb::LanguageType StackFrame::GuessLanguage() {
1216   LanguageType lang_type = GetLanguage();
1217
1218   if (lang_type == eLanguageTypeUnknown) {
1219     SymbolContext sc = GetSymbolContext(eSymbolContextFunction
1220                                         | eSymbolContextSymbol);
1221     if (sc.function) {
1222       lang_type = sc.function->GetMangled().GuessLanguage();
1223     }
1224     else if (sc.symbol)
1225     {
1226       lang_type = sc.symbol->GetMangled().GuessLanguage();
1227     }
1228   }
1229
1230   return lang_type;
1231 }
1232
1233 namespace {
1234 std::pair<const Instruction::Operand *, int64_t>
1235 GetBaseExplainingValue(const Instruction::Operand &operand,
1236                        RegisterContext &register_context, lldb::addr_t value) {
1237   switch (operand.m_type) {
1238   case Instruction::Operand::Type::Dereference:
1239   case Instruction::Operand::Type::Immediate:
1240   case Instruction::Operand::Type::Invalid:
1241   case Instruction::Operand::Type::Product:
1242     // These are not currently interesting
1243     return std::make_pair(nullptr, 0);
1244   case Instruction::Operand::Type::Sum: {
1245     const Instruction::Operand *immediate_child = nullptr;
1246     const Instruction::Operand *variable_child = nullptr;
1247     if (operand.m_children[0].m_type == Instruction::Operand::Type::Immediate) {
1248       immediate_child = &operand.m_children[0];
1249       variable_child = &operand.m_children[1];
1250     } else if (operand.m_children[1].m_type ==
1251                Instruction::Operand::Type::Immediate) {
1252       immediate_child = &operand.m_children[1];
1253       variable_child = &operand.m_children[0];
1254     }
1255     if (!immediate_child) {
1256       return std::make_pair(nullptr, 0);
1257     }
1258     lldb::addr_t adjusted_value = value;
1259     if (immediate_child->m_negative) {
1260       adjusted_value += immediate_child->m_immediate;
1261     } else {
1262       adjusted_value -= immediate_child->m_immediate;
1263     }
1264     std::pair<const Instruction::Operand *, int64_t> base_and_offset =
1265         GetBaseExplainingValue(*variable_child, register_context,
1266                                adjusted_value);
1267     if (!base_and_offset.first) {
1268       return std::make_pair(nullptr, 0);
1269     }
1270     if (immediate_child->m_negative) {
1271       base_and_offset.second -= immediate_child->m_immediate;
1272     } else {
1273       base_and_offset.second += immediate_child->m_immediate;
1274     }
1275     return base_and_offset;
1276   }
1277   case Instruction::Operand::Type::Register: {
1278     const RegisterInfo *info =
1279         register_context.GetRegisterInfoByName(operand.m_register.AsCString());
1280     if (!info) {
1281       return std::make_pair(nullptr, 0);
1282     }
1283     RegisterValue reg_value;
1284     if (!register_context.ReadRegister(info, reg_value)) {
1285       return std::make_pair(nullptr, 0);
1286     }
1287     if (reg_value.GetAsUInt64() == value) {
1288       return std::make_pair(&operand, 0);
1289     } else {
1290       return std::make_pair(nullptr, 0);
1291     }
1292   }
1293   }
1294   return std::make_pair(nullptr, 0);
1295 }
1296
1297 std::pair<const Instruction::Operand *, int64_t>
1298 GetBaseExplainingDereference(const Instruction::Operand &operand,
1299                              RegisterContext &register_context,
1300                              lldb::addr_t addr) {
1301   if (operand.m_type == Instruction::Operand::Type::Dereference) {
1302     return GetBaseExplainingValue(operand.m_children[0], register_context,
1303                                   addr);
1304   }
1305   return std::make_pair(nullptr, 0);
1306 }
1307 }
1308
1309 lldb::ValueObjectSP StackFrame::GuessValueForAddress(lldb::addr_t addr) {
1310   TargetSP target_sp = CalculateTarget();
1311
1312   const ArchSpec &target_arch = target_sp->GetArchitecture();
1313
1314   AddressRange pc_range;
1315   pc_range.GetBaseAddress() = GetFrameCodeAddress();
1316   pc_range.SetByteSize(target_arch.GetMaximumOpcodeByteSize());
1317
1318   ExecutionContext exe_ctx(shared_from_this());
1319
1320   const char *plugin_name = nullptr;
1321   const char *flavor = nullptr;
1322   const bool prefer_file_cache = false;
1323
1324   DisassemblerSP disassembler_sp = Disassembler::DisassembleRange(
1325       target_arch, plugin_name, flavor, exe_ctx, pc_range, prefer_file_cache);
1326
1327   if (!disassembler_sp || !disassembler_sp->GetInstructionList().GetSize()) {
1328     return ValueObjectSP();
1329   }
1330
1331   InstructionSP instruction_sp =
1332       disassembler_sp->GetInstructionList().GetInstructionAtIndex(0);
1333
1334   llvm::SmallVector<Instruction::Operand, 3> operands;
1335
1336   if (!instruction_sp->ParseOperands(operands)) {
1337     return ValueObjectSP();
1338   }
1339
1340   RegisterContextSP register_context_sp = GetRegisterContext();
1341
1342   if (!register_context_sp) {
1343     return ValueObjectSP();
1344   }
1345
1346   for (const Instruction::Operand &operand : operands) {
1347     std::pair<const Instruction::Operand *, int64_t> base_and_offset =
1348         GetBaseExplainingDereference(operand, *register_context_sp, addr);
1349
1350     if (!base_and_offset.first) {
1351       continue;
1352     }
1353
1354     switch (base_and_offset.first->m_type) {
1355     case Instruction::Operand::Type::Immediate: {
1356       lldb_private::Address addr;
1357       if (target_sp->ResolveLoadAddress(base_and_offset.first->m_immediate +
1358                                             base_and_offset.second,
1359                                         addr)) {
1360         TypeSystem *c_type_system =
1361             target_sp->GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC);
1362         if (!c_type_system) {
1363           return ValueObjectSP();
1364         } else {
1365           CompilerType void_ptr_type =
1366               c_type_system
1367                   ->GetBasicTypeFromAST(lldb::BasicType::eBasicTypeChar)
1368                   .GetPointerType();
1369           return ValueObjectMemory::Create(this, "", addr, void_ptr_type);
1370         }
1371       } else {
1372         return ValueObjectSP();
1373       }
1374       break;
1375     }
1376     case Instruction::Operand::Type::Register: {
1377       return GuessValueForRegisterAndOffset(base_and_offset.first->m_register,
1378                                             base_and_offset.second);
1379     }
1380     default:
1381       return ValueObjectSP();
1382     }
1383   }
1384
1385   return ValueObjectSP();
1386 }
1387
1388 namespace {
1389 ValueObjectSP GetValueForOffset(StackFrame &frame, ValueObjectSP &parent,
1390                                 int64_t offset) {
1391   if (offset < 0 || uint64_t(offset) >= parent->GetByteSize()) {
1392     return ValueObjectSP();
1393   }
1394
1395   if (parent->IsPointerOrReferenceType()) {
1396     return parent;
1397   }
1398
1399   for (int ci = 0, ce = parent->GetNumChildren(); ci != ce; ++ci) {
1400     const bool can_create = true;
1401     ValueObjectSP child_sp = parent->GetChildAtIndex(ci, can_create);
1402
1403     if (!child_sp) {
1404       return ValueObjectSP();
1405     }
1406
1407     int64_t child_offset = child_sp->GetByteOffset();
1408     int64_t child_size = child_sp->GetByteSize();
1409
1410     if (offset >= child_offset && offset < (child_offset + child_size)) {
1411       return GetValueForOffset(frame, child_sp, offset - child_offset);
1412     }
1413   }
1414
1415   if (offset == 0) {
1416     return parent;
1417   } else {
1418     return ValueObjectSP();
1419   }
1420 }
1421
1422 ValueObjectSP GetValueForDereferincingOffset(StackFrame &frame,
1423                                              ValueObjectSP &base,
1424                                              int64_t offset) {
1425   // base is a pointer to something
1426   // offset is the thing to add to the pointer We return the most sensible
1427   // ValueObject for the result of *(base+offset)
1428
1429   if (!base->IsPointerOrReferenceType()) {
1430     return ValueObjectSP();
1431   }
1432
1433   Status error;
1434   ValueObjectSP pointee = base->Dereference(error);
1435
1436   if (!pointee) {
1437     return ValueObjectSP();
1438   }
1439
1440   if (offset >= 0 && uint64_t(offset) >= pointee->GetByteSize()) {
1441     int64_t index = offset / pointee->GetByteSize();
1442     offset = offset % pointee->GetByteSize();
1443     const bool can_create = true;
1444     pointee = base->GetSyntheticArrayMember(index, can_create);
1445   }
1446
1447   if (!pointee || error.Fail()) {
1448     return ValueObjectSP();
1449   }
1450
1451   return GetValueForOffset(frame, pointee, offset);
1452 }
1453
1454 /// Attempt to reconstruct the ValueObject for the address contained in a
1455 /// given register plus an offset.
1456 ///
1457 /// \params [in] frame
1458 ///   The current stack frame.
1459 ///
1460 /// \params [in] reg
1461 ///   The register.
1462 ///
1463 /// \params [in] offset
1464 ///   The offset from the register.
1465 ///
1466 /// \param [in] disassembler
1467 ///   A disassembler containing instructions valid up to the current PC.
1468 ///
1469 /// \param [in] variables
1470 ///   The variable list from the current frame,
1471 ///
1472 /// \param [in] pc
1473 ///   The program counter for the instruction considered the 'user'.
1474 ///
1475 /// \return
1476 ///   A string describing the base for the ExpressionPath.  This could be a
1477 ///     variable, a register value, an argument, or a function return value.
1478 ///   The ValueObject if found.  If valid, it has a valid ExpressionPath.
1479 lldb::ValueObjectSP DoGuessValueAt(StackFrame &frame, ConstString reg,
1480                                    int64_t offset, Disassembler &disassembler,
1481                                    VariableList &variables, const Address &pc) {
1482   // Example of operation for Intel:
1483   //
1484   // +14: movq   -0x8(%rbp), %rdi
1485   // +18: movq   0x8(%rdi), %rdi
1486   // +22: addl   0x4(%rdi), %eax
1487   //
1488   // f, a pointer to a struct, is known to be at -0x8(%rbp).
1489   //
1490   // DoGuessValueAt(frame, rdi, 4, dis, vars, 0x22) finds the instruction at
1491   // +18 that assigns to rdi, and calls itself recursively for that dereference
1492   //   DoGuessValueAt(frame, rdi, 8, dis, vars, 0x18) finds the instruction at
1493   //   +14 that assigns to rdi, and calls itself recursively for that
1494   //   derefernece
1495   //     DoGuessValueAt(frame, rbp, -8, dis, vars, 0x14) finds "f" in the
1496   //     variable list.
1497   //     Returns a ValueObject for f.  (That's what was stored at rbp-8 at +14)
1498   //   Returns a ValueObject for *(f+8) or f->b (That's what was stored at rdi+8
1499   //   at +18)
1500   // Returns a ValueObject for *(f->b+4) or f->b->a (That's what was stored at
1501   // rdi+4 at +22)
1502
1503   // First, check the variable list to see if anything is at the specified
1504   // location.
1505
1506   using namespace OperandMatchers;
1507
1508   const RegisterInfo *reg_info =
1509       frame.GetRegisterContext()->GetRegisterInfoByName(reg.AsCString());
1510   if (!reg_info) {
1511     return ValueObjectSP();
1512   }
1513
1514   Instruction::Operand op =
1515       offset ? Instruction::Operand::BuildDereference(
1516                    Instruction::Operand::BuildSum(
1517                        Instruction::Operand::BuildRegister(reg),
1518                        Instruction::Operand::BuildImmediate(offset)))
1519              : Instruction::Operand::BuildDereference(
1520                    Instruction::Operand::BuildRegister(reg));
1521
1522   for (size_t vi = 0, ve = variables.GetSize(); vi != ve; ++vi) {
1523     VariableSP var_sp = variables.GetVariableAtIndex(vi);
1524     if (var_sp->LocationExpression().MatchesOperand(frame, op)) {
1525       return frame.GetValueObjectForFrameVariable(var_sp, eNoDynamicValues);
1526     }
1527   }
1528
1529   const uint32_t current_inst =
1530       disassembler.GetInstructionList().GetIndexOfInstructionAtAddress(pc);
1531   if (current_inst == UINT32_MAX) {
1532     return ValueObjectSP();
1533   }
1534
1535   for (uint32_t ii = current_inst - 1; ii != (uint32_t)-1; --ii) {
1536     // This is not an exact algorithm, and it sacrifices accuracy for
1537     // generality.  Recognizing "mov" and "ld" instructions –– and which
1538     // are their source and destination operands -- is something the
1539     // disassembler should do for us.
1540     InstructionSP instruction_sp =
1541         disassembler.GetInstructionList().GetInstructionAtIndex(ii);
1542
1543     if (instruction_sp->IsCall()) {
1544       ABISP abi_sp = frame.CalculateProcess()->GetABI();
1545       if (!abi_sp) {
1546         continue;
1547       }
1548
1549       const char *return_register_name;
1550       if (!abi_sp->GetPointerReturnRegister(return_register_name)) {
1551         continue;
1552       }
1553
1554       const RegisterInfo *return_register_info =
1555           frame.GetRegisterContext()->GetRegisterInfoByName(
1556               return_register_name);
1557       if (!return_register_info) {
1558         continue;
1559       }
1560
1561       int64_t offset = 0;
1562
1563       if (!MatchUnaryOp(MatchOpType(Instruction::Operand::Type::Dereference),
1564                         MatchRegOp(*return_register_info))(op) &&
1565           !MatchUnaryOp(
1566               MatchOpType(Instruction::Operand::Type::Dereference),
1567               MatchBinaryOp(MatchOpType(Instruction::Operand::Type::Sum),
1568                             MatchRegOp(*return_register_info),
1569                             FetchImmOp(offset)))(op)) {
1570         continue;
1571       }
1572
1573       llvm::SmallVector<Instruction::Operand, 1> operands;
1574       if (!instruction_sp->ParseOperands(operands) || operands.size() != 1) {
1575         continue;
1576       }
1577
1578       switch (operands[0].m_type) {
1579       default:
1580         break;
1581       case Instruction::Operand::Type::Immediate: {
1582         SymbolContext sc;
1583         Address load_address;
1584         if (!frame.CalculateTarget()->ResolveLoadAddress(
1585                 operands[0].m_immediate, load_address)) {
1586           break;
1587         }
1588         frame.CalculateTarget()->GetImages().ResolveSymbolContextForAddress(
1589             load_address, eSymbolContextFunction, sc);
1590         if (!sc.function) {
1591           break;
1592         }
1593         CompilerType function_type = sc.function->GetCompilerType();
1594         if (!function_type.IsFunctionType()) {
1595           break;
1596         }
1597         CompilerType return_type = function_type.GetFunctionReturnType();
1598         RegisterValue return_value;
1599         if (!frame.GetRegisterContext()->ReadRegister(return_register_info,
1600                                                       return_value)) {
1601           break;
1602         }
1603         std::string name_str(
1604             sc.function->GetName().AsCString("<unknown function>"));
1605         name_str.append("()");
1606         Address return_value_address(return_value.GetAsUInt64());
1607         ValueObjectSP return_value_sp = ValueObjectMemory::Create(
1608             &frame, name_str, return_value_address, return_type);
1609         return GetValueForDereferincingOffset(frame, return_value_sp, offset);
1610       }
1611       }
1612
1613       continue;
1614     }
1615
1616     llvm::SmallVector<Instruction::Operand, 2> operands;
1617     if (!instruction_sp->ParseOperands(operands) || operands.size() != 2) {
1618       continue;
1619     }
1620
1621     Instruction::Operand *origin_operand = nullptr;
1622     auto clobbered_reg_matcher = [reg_info](const Instruction::Operand &op) {
1623       return MatchRegOp(*reg_info)(op) && op.m_clobbered;
1624     };
1625
1626     if (clobbered_reg_matcher(operands[0])) {
1627       origin_operand = &operands[1];
1628     }
1629     else if (clobbered_reg_matcher(operands[1])) {
1630       origin_operand = &operands[0];
1631     }
1632     else {
1633       continue;
1634     }
1635
1636     // We have an origin operand.  Can we track its value down?
1637     ValueObjectSP source_path;
1638     ConstString origin_register;
1639     int64_t origin_offset = 0;
1640
1641     if (FetchRegOp(origin_register)(*origin_operand)) {
1642       source_path = DoGuessValueAt(frame, origin_register, 0, disassembler,
1643                                    variables, instruction_sp->GetAddress());
1644     } else if (MatchUnaryOp(
1645                    MatchOpType(Instruction::Operand::Type::Dereference),
1646                    FetchRegOp(origin_register))(*origin_operand) ||
1647                MatchUnaryOp(
1648                    MatchOpType(Instruction::Operand::Type::Dereference),
1649                    MatchBinaryOp(MatchOpType(Instruction::Operand::Type::Sum),
1650                                  FetchRegOp(origin_register),
1651                                  FetchImmOp(origin_offset)))(*origin_operand)) {
1652       source_path =
1653           DoGuessValueAt(frame, origin_register, origin_offset, disassembler,
1654                          variables, instruction_sp->GetAddress());
1655       if (!source_path) {
1656         continue;
1657       }
1658       source_path =
1659           GetValueForDereferincingOffset(frame, source_path, offset);
1660     }
1661
1662     if (source_path) {
1663       return source_path;
1664     }
1665   }
1666
1667   return ValueObjectSP();
1668 }
1669 }
1670
1671 lldb::ValueObjectSP StackFrame::GuessValueForRegisterAndOffset(ConstString reg,
1672                                                                int64_t offset) {
1673   TargetSP target_sp = CalculateTarget();
1674
1675   const ArchSpec &target_arch = target_sp->GetArchitecture();
1676
1677   Block *frame_block = GetFrameBlock();
1678
1679   if (!frame_block) {
1680     return ValueObjectSP();
1681   }
1682
1683   Function *function = frame_block->CalculateSymbolContextFunction();
1684   if (!function) {
1685     return ValueObjectSP();
1686   }
1687
1688   AddressRange pc_range = function->GetAddressRange();
1689
1690   if (GetFrameCodeAddress().GetFileAddress() <
1691           pc_range.GetBaseAddress().GetFileAddress() ||
1692       GetFrameCodeAddress().GetFileAddress() -
1693               pc_range.GetBaseAddress().GetFileAddress() >=
1694           pc_range.GetByteSize()) {
1695     return ValueObjectSP();
1696   }
1697
1698   ExecutionContext exe_ctx(shared_from_this());
1699
1700   const char *plugin_name = nullptr;
1701   const char *flavor = nullptr;
1702   const bool prefer_file_cache = false;
1703   DisassemblerSP disassembler_sp = Disassembler::DisassembleRange(
1704       target_arch, plugin_name, flavor, exe_ctx, pc_range, prefer_file_cache);
1705
1706   if (!disassembler_sp || !disassembler_sp->GetInstructionList().GetSize()) {
1707     return ValueObjectSP();
1708   }
1709
1710   const bool get_file_globals = false;
1711   VariableList *variables = GetVariableList(get_file_globals);
1712
1713   if (!variables) {
1714     return ValueObjectSP();
1715   }
1716
1717   return DoGuessValueAt(*this, reg, offset, *disassembler_sp, *variables,
1718                         GetFrameCodeAddress());
1719 }
1720
1721 lldb::ValueObjectSP StackFrame::FindVariable(ConstString name) {
1722   ValueObjectSP value_sp;
1723
1724   if (!name)
1725     return value_sp;
1726
1727   TargetSP target_sp = CalculateTarget();
1728   ProcessSP process_sp = CalculateProcess();
1729
1730   if (!target_sp && !process_sp)
1731     return value_sp;
1732
1733   VariableList variable_list;
1734   VariableSP var_sp;
1735   SymbolContext sc(GetSymbolContext(eSymbolContextBlock));
1736
1737   if (sc.block) {
1738     const bool can_create = true;
1739     const bool get_parent_variables = true;
1740     const bool stop_if_block_is_inlined_function = true;
1741
1742     if (sc.block->AppendVariables(
1743             can_create, get_parent_variables, stop_if_block_is_inlined_function,
1744             [this](Variable *v) { return v->IsInScope(this); },
1745             &variable_list)) {
1746       var_sp = variable_list.FindVariable(name);
1747     }
1748
1749     if (var_sp)
1750       value_sp = GetValueObjectForFrameVariable(var_sp, eNoDynamicValues);
1751   }
1752
1753   return value_sp;
1754 }
1755
1756 TargetSP StackFrame::CalculateTarget() {
1757   TargetSP target_sp;
1758   ThreadSP thread_sp(GetThread());
1759   if (thread_sp) {
1760     ProcessSP process_sp(thread_sp->CalculateProcess());
1761     if (process_sp)
1762       target_sp = process_sp->CalculateTarget();
1763   }
1764   return target_sp;
1765 }
1766
1767 ProcessSP StackFrame::CalculateProcess() {
1768   ProcessSP process_sp;
1769   ThreadSP thread_sp(GetThread());
1770   if (thread_sp)
1771     process_sp = thread_sp->CalculateProcess();
1772   return process_sp;
1773 }
1774
1775 ThreadSP StackFrame::CalculateThread() { return GetThread(); }
1776
1777 StackFrameSP StackFrame::CalculateStackFrame() { return shared_from_this(); }
1778
1779 void StackFrame::CalculateExecutionContext(ExecutionContext &exe_ctx) {
1780   exe_ctx.SetContext(shared_from_this());
1781 }
1782
1783 void StackFrame::DumpUsingSettingsFormat(Stream *strm, bool show_unique,
1784                                          const char *frame_marker) {
1785   if (strm == nullptr)
1786     return;
1787
1788   GetSymbolContext(eSymbolContextEverything);
1789   ExecutionContext exe_ctx(shared_from_this());
1790   StreamString s;
1791
1792   if (frame_marker)
1793     s.PutCString(frame_marker);
1794
1795   const FormatEntity::Entry *frame_format = nullptr;
1796   Target *target = exe_ctx.GetTargetPtr();
1797   if (target) {
1798     if (show_unique) {
1799       frame_format = target->GetDebugger().GetFrameFormatUnique();
1800     } else {
1801       frame_format = target->GetDebugger().GetFrameFormat();
1802     }
1803   }
1804   if (frame_format && FormatEntity::Format(*frame_format, s, &m_sc, &exe_ctx,
1805                                            nullptr, nullptr, false, false)) {
1806     strm->PutCString(s.GetString());
1807   } else {
1808     Dump(strm, true, false);
1809     strm->EOL();
1810   }
1811 }
1812
1813 void StackFrame::Dump(Stream *strm, bool show_frame_index,
1814                       bool show_fullpaths) {
1815   if (strm == nullptr)
1816     return;
1817
1818   if (show_frame_index)
1819     strm->Printf("frame #%u: ", m_frame_index);
1820   ExecutionContext exe_ctx(shared_from_this());
1821   Target *target = exe_ctx.GetTargetPtr();
1822   strm->Printf("0x%0*" PRIx64 " ",
1823                target ? (target->GetArchitecture().GetAddressByteSize() * 2)
1824                       : 16,
1825                GetFrameCodeAddress().GetLoadAddress(target));
1826   GetSymbolContext(eSymbolContextEverything);
1827   const bool show_module = true;
1828   const bool show_inline = true;
1829   const bool show_function_arguments = true;
1830   const bool show_function_name = true;
1831   m_sc.DumpStopContext(strm, exe_ctx.GetBestExecutionContextScope(),
1832                        GetFrameCodeAddress(), show_fullpaths, show_module,
1833                        show_inline, show_function_arguments,
1834                        show_function_name);
1835 }
1836
1837 void StackFrame::UpdateCurrentFrameFromPreviousFrame(StackFrame &prev_frame) {
1838   std::lock_guard<std::recursive_mutex> guard(m_mutex);
1839   assert(GetStackID() ==
1840          prev_frame.GetStackID()); // TODO: remove this after some testing
1841   m_variable_list_sp = prev_frame.m_variable_list_sp;
1842   m_variable_list_value_objects.Swap(prev_frame.m_variable_list_value_objects);
1843   if (!m_disassembly.GetString().empty()) {
1844     m_disassembly.Clear();
1845     m_disassembly.PutCString(prev_frame.m_disassembly.GetString());
1846   }
1847 }
1848
1849 void StackFrame::UpdatePreviousFrameFromCurrentFrame(StackFrame &curr_frame) {
1850   std::lock_guard<std::recursive_mutex> guard(m_mutex);
1851   assert(GetStackID() ==
1852          curr_frame.GetStackID());     // TODO: remove this after some testing
1853   m_id.SetPC(curr_frame.m_id.GetPC()); // Update the Stack ID PC value
1854   assert(GetThread() == curr_frame.GetThread());
1855   m_frame_index = curr_frame.m_frame_index;
1856   m_concrete_frame_index = curr_frame.m_concrete_frame_index;
1857   m_reg_context_sp = curr_frame.m_reg_context_sp;
1858   m_frame_code_addr = curr_frame.m_frame_code_addr;
1859   assert(!m_sc.target_sp || !curr_frame.m_sc.target_sp ||
1860          m_sc.target_sp.get() == curr_frame.m_sc.target_sp.get());
1861   assert(!m_sc.module_sp || !curr_frame.m_sc.module_sp ||
1862          m_sc.module_sp.get() == curr_frame.m_sc.module_sp.get());
1863   assert(m_sc.comp_unit == nullptr || curr_frame.m_sc.comp_unit == nullptr ||
1864          m_sc.comp_unit == curr_frame.m_sc.comp_unit);
1865   assert(m_sc.function == nullptr || curr_frame.m_sc.function == nullptr ||
1866          m_sc.function == curr_frame.m_sc.function);
1867   m_sc = curr_frame.m_sc;
1868   m_flags.Clear(GOT_FRAME_BASE | eSymbolContextEverything);
1869   m_flags.Set(m_sc.GetResolvedMask());
1870   m_frame_base.Clear();
1871   m_frame_base_error.Clear();
1872 }
1873
1874 bool StackFrame::HasCachedData() const {
1875   if (m_variable_list_sp)
1876     return true;
1877   if (m_variable_list_value_objects.GetSize() > 0)
1878     return true;
1879   if (!m_disassembly.GetString().empty())
1880     return true;
1881   return false;
1882 }
1883
1884 bool StackFrame::GetStatus(Stream &strm, bool show_frame_info, bool show_source,
1885                            bool show_unique, const char *frame_marker) {
1886   if (show_frame_info) {
1887     strm.Indent();
1888     DumpUsingSettingsFormat(&strm, show_unique, frame_marker);
1889   }
1890
1891   if (show_source) {
1892     ExecutionContext exe_ctx(shared_from_this());
1893     bool have_source = false, have_debuginfo = false;
1894     Debugger::StopDisassemblyType disasm_display =
1895         Debugger::eStopDisassemblyTypeNever;
1896     Target *target = exe_ctx.GetTargetPtr();
1897     if (target) {
1898       Debugger &debugger = target->GetDebugger();
1899       const uint32_t source_lines_before =
1900           debugger.GetStopSourceLineCount(true);
1901       const uint32_t source_lines_after =
1902           debugger.GetStopSourceLineCount(false);
1903       disasm_display = debugger.GetStopDisassemblyDisplay();
1904
1905       GetSymbolContext(eSymbolContextCompUnit | eSymbolContextLineEntry);
1906       if (m_sc.comp_unit && m_sc.line_entry.IsValid()) {
1907         have_debuginfo = true;
1908         if (source_lines_before > 0 || source_lines_after > 0) {
1909           size_t num_lines =
1910               target->GetSourceManager().DisplaySourceLinesWithLineNumbers(
1911                   m_sc.line_entry.file, m_sc.line_entry.line,
1912                   m_sc.line_entry.column, source_lines_before,
1913                   source_lines_after, "->", &strm);
1914           if (num_lines != 0)
1915             have_source = true;
1916           // TODO: Give here a one time warning if source file is missing.
1917         }
1918       }
1919       switch (disasm_display) {
1920       case Debugger::eStopDisassemblyTypeNever:
1921         break;
1922
1923       case Debugger::eStopDisassemblyTypeNoDebugInfo:
1924         if (have_debuginfo)
1925           break;
1926         LLVM_FALLTHROUGH;
1927
1928       case Debugger::eStopDisassemblyTypeNoSource:
1929         if (have_source)
1930           break;
1931         LLVM_FALLTHROUGH;
1932
1933       case Debugger::eStopDisassemblyTypeAlways:
1934         if (target) {
1935           const uint32_t disasm_lines = debugger.GetDisassemblyLineCount();
1936           if (disasm_lines > 0) {
1937             const ArchSpec &target_arch = target->GetArchitecture();
1938             AddressRange pc_range;
1939             pc_range.GetBaseAddress() = GetFrameCodeAddress();
1940             pc_range.SetByteSize(disasm_lines *
1941                                  target_arch.GetMaximumOpcodeByteSize());
1942             const char *plugin_name = nullptr;
1943             const char *flavor = nullptr;
1944             const bool mixed_source_and_assembly = false;
1945             Disassembler::Disassemble(
1946                 target->GetDebugger(), target_arch, plugin_name, flavor,
1947                 exe_ctx, pc_range, disasm_lines, mixed_source_and_assembly, 0,
1948                 Disassembler::eOptionMarkPCAddress, strm);
1949           }
1950         }
1951         break;
1952       }
1953     }
1954   }
1955   return true;
1956 }
1957
1958 RecognizedStackFrameSP StackFrame::GetRecognizedFrame() {
1959   if (!m_recognized_frame_sp) {
1960     m_recognized_frame_sp =
1961         StackFrameRecognizerManager::RecognizeFrame(CalculateStackFrame());
1962   }
1963   return m_recognized_frame_sp;
1964 }