contrib/llvm/tools/lldb/source/Target/StackFrame.cpp

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