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