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