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