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 #include "lldb/Target/StackFrame.h" 11 12 // C Includes 13 // C++ Includes 14 // Other libraries and framework includes 15 // Project includes 16 #include "lldb/Core/Module.h" 17 #include "lldb/Core/Debugger.h" 18 #include "lldb/Core/Disassembler.h" 19 #include "lldb/Core/Value.h" 20 #include "lldb/Core/ValueObjectVariable.h" 21 #include "lldb/Core/ValueObjectConstResult.h" 22 #include "lldb/Symbol/Function.h" 23 #include "lldb/Symbol/VariableList.h" 24 #include "lldb/Target/ExecutionContext.h" 25 #include "lldb/Target/Process.h" 26 #include "lldb/Target/RegisterContext.h" 27 #include "lldb/Target/Target.h" 28 #include "lldb/Target/Thread.h" 29 30 using namespace lldb; 31 using namespace lldb_private; 32 33 // The first bits in the flags are reserved for the SymbolContext::Scope bits 34 // so we know if we have tried to look up information in our internal symbol 35 // context (m_sc) already. 36 #define RESOLVED_FRAME_CODE_ADDR (uint32_t(eSymbolContextEverything + 1)) 37 #define RESOLVED_FRAME_ID_SYMBOL_SCOPE (RESOLVED_FRAME_CODE_ADDR << 1) 38 #define GOT_FRAME_BASE (RESOLVED_FRAME_ID_SYMBOL_SCOPE << 1) 39 #define RESOLVED_VARIABLES (GOT_FRAME_BASE << 1) 40 #define RESOLVED_GLOBAL_VARIABLES (RESOLVED_VARIABLES << 1) 41 42 StackFrame::StackFrame 43 ( 44 lldb::user_id_t frame_idx, 45 lldb::user_id_t unwind_frame_index, 46 Thread &thread, 47 lldb::addr_t cfa, 48 lldb::addr_t pc, 49 const SymbolContext *sc_ptr 50 ) : 51 m_thread (thread), 52 m_frame_index (frame_idx), 53 m_concrete_frame_index (unwind_frame_index), 54 m_reg_context_sp (), 55 m_id (pc, cfa, NULL), 56 m_frame_code_addr (NULL, pc), 57 m_sc (), 58 m_flags (), 59 m_frame_base (), 60 m_frame_base_error (), 61 m_variable_list_sp (), 62 m_variable_list_value_objects (), 63 m_disassembly () 64 { 65 if (sc_ptr != NULL) 66 { 67 m_sc = *sc_ptr; 68 m_flags.Set(m_sc.GetResolvedMask ()); 69 } 70 } 71 72 StackFrame::StackFrame 73 ( 74 lldb::user_id_t frame_idx, 75 lldb::user_id_t unwind_frame_index, 76 Thread &thread, 77 const RegisterContextSP ®_context_sp, 78 lldb::addr_t cfa, 79 lldb::addr_t pc, 80 const SymbolContext *sc_ptr 81 ) : 82 m_thread (thread), 83 m_frame_index (frame_idx), 84 m_concrete_frame_index (unwind_frame_index), 85 m_reg_context_sp (reg_context_sp), 86 m_id (pc, cfa, NULL), 87 m_frame_code_addr (NULL, pc), 88 m_sc (), 89 m_flags (), 90 m_frame_base (), 91 m_frame_base_error (), 92 m_variable_list_sp (), 93 m_variable_list_value_objects (), 94 m_disassembly () 95 { 96 if (sc_ptr != NULL) 97 { 98 m_sc = *sc_ptr; 99 m_flags.Set(m_sc.GetResolvedMask ()); 100 } 101 102 if (reg_context_sp && !m_sc.target_sp) 103 { 104 m_sc.target_sp = reg_context_sp->GetThread().GetProcess().GetTarget().GetSP(); 105 m_flags.Set (eSymbolContextTarget); 106 } 107 } 108 109 StackFrame::StackFrame 110 ( 111 lldb::user_id_t frame_idx, 112 lldb::user_id_t unwind_frame_index, 113 Thread &thread, 114 const RegisterContextSP ®_context_sp, 115 lldb::addr_t cfa, 116 const Address& pc_addr, 117 const SymbolContext *sc_ptr 118 ) : 119 m_thread (thread), 120 m_frame_index (frame_idx), 121 m_concrete_frame_index (unwind_frame_index), 122 m_reg_context_sp (reg_context_sp), 123 m_id (pc_addr.GetLoadAddress (&thread.GetProcess().GetTarget()), cfa, NULL), 124 m_frame_code_addr (pc_addr), 125 m_sc (), 126 m_flags (), 127 m_frame_base (), 128 m_frame_base_error (), 129 m_variable_list_sp (), 130 m_variable_list_value_objects (), 131 m_disassembly () 132 { 133 if (sc_ptr != NULL) 134 { 135 m_sc = *sc_ptr; 136 m_flags.Set(m_sc.GetResolvedMask ()); 137 } 138 139 if (m_sc.target_sp.get() == NULL && reg_context_sp) 140 { 141 m_sc.target_sp = reg_context_sp->GetThread().GetProcess().GetTarget().GetSP(); 142 m_flags.Set (eSymbolContextTarget); 143 } 144 145 Module *pc_module = pc_addr.GetModule(); 146 if (m_sc.module_sp.get() == NULL || m_sc.module_sp.get() != pc_module) 147 { 148 if (pc_module) 149 { 150 m_sc.module_sp = pc_module->GetSP(); 151 m_flags.Set (eSymbolContextModule); 152 } 153 else 154 { 155 m_sc.module_sp.reset(); 156 } 157 158 } 159 } 160 161 162 //---------------------------------------------------------------------- 163 // Destructor 164 //---------------------------------------------------------------------- 165 StackFrame::~StackFrame() 166 { 167 } 168 169 StackID& 170 StackFrame::GetStackID() 171 { 172 // Make sure we have resolved the StackID object's symbol context scope if 173 // we already haven't looked it up. 174 175 if (m_flags.IsClear (RESOLVED_FRAME_ID_SYMBOL_SCOPE)) 176 { 177 if (m_id.GetSymbolContextScope ()) 178 { 179 // We already have a symbol context scope, we just don't have our 180 // flag bit set. 181 m_flags.Set (RESOLVED_FRAME_ID_SYMBOL_SCOPE); 182 } 183 else 184 { 185 // Calculate the frame block and use this for the stack ID symbol 186 // context scope if we have one. 187 SymbolContextScope *scope = GetFrameBlock (); 188 if (scope == NULL) 189 { 190 // We don't have a block, so use the symbol 191 if (m_flags.IsClear (eSymbolContextSymbol)) 192 GetSymbolContext (eSymbolContextSymbol); 193 194 // It is ok if m_sc.symbol is NULL here 195 scope = m_sc.symbol; 196 } 197 // Set the symbol context scope (the accessor will set the 198 // RESOLVED_FRAME_ID_SYMBOL_SCOPE bit in m_flags). 199 SetSymbolContextScope (scope); 200 } 201 } 202 return m_id; 203 } 204 205 void 206 StackFrame::SetSymbolContextScope (SymbolContextScope *symbol_scope) 207 { 208 m_flags.Set (RESOLVED_FRAME_ID_SYMBOL_SCOPE); 209 m_id.SetSymbolContextScope (symbol_scope); 210 } 211 212 Address& 213 StackFrame::GetFrameCodeAddress() 214 { 215 if (m_flags.IsClear(RESOLVED_FRAME_CODE_ADDR) && !m_frame_code_addr.IsSectionOffset()) 216 { 217 m_flags.Set (RESOLVED_FRAME_CODE_ADDR); 218 219 // Resolve the PC into a temporary address because if ResolveLoadAddress 220 // fails to resolve the address, it will clear the address object... 221 Address resolved_pc; 222 if (m_thread.GetProcess().GetTarget().GetSectionLoadList().ResolveLoadAddress(m_frame_code_addr.GetOffset(), resolved_pc)) 223 { 224 m_frame_code_addr = resolved_pc; 225 const Section *section = m_frame_code_addr.GetSection(); 226 if (section) 227 { 228 Module *module = section->GetModule(); 229 if (module) 230 { 231 m_sc.module_sp = module->GetSP(); 232 if (m_sc.module_sp) 233 m_flags.Set(eSymbolContextModule); 234 } 235 } 236 } 237 } 238 return m_frame_code_addr; 239 } 240 241 void 242 StackFrame::ChangePC (addr_t pc) 243 { 244 m_frame_code_addr.SetOffset(pc); 245 m_frame_code_addr.SetSection(NULL); 246 m_sc.Clear(); 247 m_flags.Reset(0); 248 m_thread.ClearStackFrames (); 249 } 250 251 const char * 252 StackFrame::Disassemble () 253 { 254 if (m_disassembly.GetSize() == 0) 255 { 256 ExecutionContext exe_ctx; 257 CalculateExecutionContext(exe_ctx); 258 Target &target = m_thread.GetProcess().GetTarget(); 259 Disassembler::Disassemble (target.GetDebugger(), 260 target.GetArchitecture(), 261 NULL, 262 exe_ctx, 263 0, 264 0, 265 false, 266 false, 267 m_disassembly); 268 if (m_disassembly.GetSize() == 0) 269 return NULL; 270 } 271 return m_disassembly.GetData(); 272 } 273 274 Block * 275 StackFrame::GetFrameBlock () 276 { 277 if (m_sc.block == NULL && m_flags.IsClear (eSymbolContextBlock)) 278 GetSymbolContext (eSymbolContextBlock); 279 280 if (m_sc.block) 281 { 282 Block *inline_block = m_sc.block->GetContainingInlinedBlock(); 283 if (inline_block) 284 { 285 // Use the block with the inlined function info 286 // as the frame block we want this frame to have only the variables 287 // for the inlined function and its non-inlined block child blocks. 288 return inline_block; 289 } 290 else 291 { 292 // This block is not contained withing any inlined function blocks 293 // with so we want to use the top most function block. 294 return &m_sc.function->GetBlock (false); 295 } 296 } 297 return NULL; 298 } 299 300 //---------------------------------------------------------------------- 301 // Get the symbol context if we already haven't done so by resolving the 302 // PC address as much as possible. This way when we pass around a 303 // StackFrame object, everyone will have as much information as 304 // possible and no one will ever have to look things up manually. 305 //---------------------------------------------------------------------- 306 const SymbolContext& 307 StackFrame::GetSymbolContext (uint32_t resolve_scope) 308 { 309 // Copy our internal symbol context into "sc". 310 if ((m_flags.Get() & resolve_scope) != resolve_scope) 311 { 312 // Resolve our PC to section offset if we haven't alreday done so 313 // and if we don't have a module. The resolved address section will 314 // contain the 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 319 // value when doing address lookups since the PC will be on the 320 // instruction following the function call instruction... 321 322 Address lookup_addr(GetFrameCodeAddress()); 323 if (m_frame_index > 0 && lookup_addr.IsValid()) 324 { 325 addr_t offset = lookup_addr.GetOffset(); 326 if (offset > 0) 327 lookup_addr.SetOffset(offset - 1); 328 } 329 330 331 uint32_t resolved = 0; 332 if (m_sc.module_sp) 333 { 334 // We have something in our stack frame symbol context, lets check 335 // if we haven't already tried to lookup one of those things. If we 336 // haven't then we will do the query. 337 338 uint32_t actual_resolve_scope = 0; 339 340 if (resolve_scope & eSymbolContextCompUnit) 341 { 342 if (m_flags.IsClear (eSymbolContextCompUnit)) 343 { 344 if (m_sc.comp_unit) 345 resolved |= eSymbolContextCompUnit; 346 else 347 actual_resolve_scope |= eSymbolContextCompUnit; 348 } 349 } 350 351 if (resolve_scope & eSymbolContextFunction) 352 { 353 if (m_flags.IsClear (eSymbolContextFunction)) 354 { 355 if (m_sc.function) 356 resolved |= eSymbolContextFunction; 357 else 358 actual_resolve_scope |= eSymbolContextFunction; 359 } 360 } 361 362 if (resolve_scope & eSymbolContextBlock) 363 { 364 if (m_flags.IsClear (eSymbolContextBlock)) 365 { 366 if (m_sc.block) 367 resolved |= eSymbolContextBlock; 368 else 369 actual_resolve_scope |= eSymbolContextBlock; 370 } 371 } 372 373 if (resolve_scope & eSymbolContextSymbol) 374 { 375 if (m_flags.IsClear (eSymbolContextSymbol)) 376 { 377 if (m_sc.symbol) 378 resolved |= eSymbolContextSymbol; 379 else 380 actual_resolve_scope |= eSymbolContextSymbol; 381 } 382 } 383 384 if (resolve_scope & eSymbolContextLineEntry) 385 { 386 if (m_flags.IsClear (eSymbolContextLineEntry)) 387 { 388 if (m_sc.line_entry.IsValid()) 389 resolved |= eSymbolContextLineEntry; 390 else 391 actual_resolve_scope |= eSymbolContextLineEntry; 392 } 393 } 394 395 if (actual_resolve_scope) 396 { 397 // We might be resolving less information than what is already 398 // in our current symbol context so resolve into a temporary 399 // symbol context "sc" so we don't clear out data we have 400 // already found in "m_sc" 401 SymbolContext sc; 402 // Set flags that indicate what we have tried to resolve 403 resolved |= m_sc.module_sp->ResolveSymbolContextForAddress (lookup_addr, actual_resolve_scope, sc); 404 // Only replace what we didn't already have as we may have 405 // information for an inlined function scope that won't match 406 // what a standard lookup by address would match 407 if ((resolved & eSymbolContextCompUnit) && m_sc.comp_unit == NULL) 408 m_sc.comp_unit = sc.comp_unit; 409 if ((resolved & eSymbolContextFunction) && m_sc.function == NULL) 410 m_sc.function = sc.function; 411 if ((resolved & eSymbolContextBlock) && m_sc.block == NULL) 412 m_sc.block = sc.block; 413 if ((resolved & eSymbolContextSymbol) && m_sc.symbol == NULL) 414 m_sc.symbol = sc.symbol; 415 if ((resolved & eSymbolContextLineEntry) && !m_sc.line_entry.IsValid()) 416 m_sc.line_entry = sc.line_entry; 417 418 } 419 } 420 else 421 { 422 // If we don't have a module, then we can't have the compile unit, 423 // function, block, line entry or symbol, so we can safely call 424 // ResolveSymbolContextForAddress with our symbol context member m_sc. 425 resolved |= m_thread.GetProcess().GetTarget().GetImages().ResolveSymbolContextForAddress (lookup_addr, resolve_scope, m_sc); 426 } 427 428 // If the target was requested add that: 429 if (m_sc.target_sp.get() == NULL) 430 { 431 m_sc.target_sp = CalculateProcess()->GetTarget().GetSP(); 432 if (m_sc.target_sp) 433 resolved |= eSymbolContextTarget; 434 } 435 436 // Update our internal flags so we remember what we have tried to locate so 437 // we don't have to keep trying when more calls to this function are made. 438 // We might have dug up more information that was requested (for example 439 // if we were asked to only get the block, we will have gotten the 440 // compile unit, and function) so set any additional bits that we resolved 441 m_flags.Set (resolve_scope | resolved); 442 } 443 444 // Return the symbol context with everything that was possible to resolve 445 // resolved. 446 return m_sc; 447 } 448 449 450 VariableList * 451 StackFrame::GetVariableList (bool get_file_globals) 452 { 453 if (m_flags.IsClear(RESOLVED_VARIABLES)) 454 { 455 m_flags.Set(RESOLVED_VARIABLES); 456 457 Block *frame_block = GetFrameBlock(); 458 459 if (frame_block) 460 { 461 const bool get_child_variables = true; 462 const bool can_create = true; 463 const bool stop_if_child_block_is_inlined_function = true; 464 m_variable_list_sp.reset(new VariableList()); 465 frame_block->AppendBlockVariables(can_create, get_child_variables, stop_if_child_block_is_inlined_function, m_variable_list_sp.get()); 466 } 467 } 468 469 if (m_flags.IsClear(RESOLVED_GLOBAL_VARIABLES) && 470 get_file_globals) 471 { 472 m_flags.Set(RESOLVED_GLOBAL_VARIABLES); 473 474 if (m_flags.IsClear (eSymbolContextCompUnit)) 475 GetSymbolContext (eSymbolContextCompUnit); 476 477 if (m_sc.comp_unit) 478 { 479 VariableListSP global_variable_list_sp (m_sc.comp_unit->GetVariableList(true)); 480 if (m_variable_list_sp) 481 m_variable_list_sp->AddVariables (global_variable_list_sp.get()); 482 else 483 m_variable_list_sp = global_variable_list_sp; 484 } 485 } 486 487 return m_variable_list_sp.get(); 488 } 489 490 ValueObjectSP 491 StackFrame::GetValueForVariableExpressionPath (const char *var_expr_cstr, 492 lldb::DynamicValueType use_dynamic, 493 uint32_t options, 494 lldb::VariableSP &var_sp, 495 Error &error) 496 { 497 498 if (var_expr_cstr && var_expr_cstr[0]) 499 { 500 const bool check_ptr_vs_member = (options & eExpressionPathOptionCheckPtrVsMember) != 0; 501 const bool no_fragile_ivar = (options & eExpressionPathOptionsNoFragileObjcIvar) != 0; 502 error.Clear(); 503 bool deref = false; 504 bool address_of = false; 505 ValueObjectSP valobj_sp; 506 const bool get_file_globals = true; 507 VariableList *variable_list = GetVariableList (get_file_globals); 508 509 if (variable_list) 510 { 511 // If first character is a '*', then show pointer contents 512 const char *var_expr = var_expr_cstr; 513 if (var_expr[0] == '*') 514 { 515 deref = true; 516 var_expr++; // Skip the '*' 517 } 518 else if (var_expr[0] == '&') 519 { 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); 535 if (var_sp) 536 { 537 valobj_sp = GetValueObjectForFrameVariable (var_sp, use_dynamic); 538 if (!valobj_sp) 539 return valobj_sp; 540 541 var_path.erase (0, name_const_string.GetLength ()); 542 // We are dumping at least one child 543 while (separator_idx != std::string::npos) 544 { 545 // Calculate the next separator index ahead of time 546 ValueObjectSP child_valobj_sp; 547 const char separator_type = var_path[0]; 548 switch (separator_type) 549 { 550 551 case '-': 552 if (var_path.size() >= 2 && var_path[1] != '>') 553 return ValueObjectSP(); 554 555 if (no_fragile_ivar) 556 { 557 // Make sure we aren't trying to deref an objective 558 // C ivar if this is not allowed 559 const uint32_t pointer_type_flags = ClangASTContext::GetTypeInfo (valobj_sp->GetClangType(), NULL, NULL); 560 if ((pointer_type_flags & ClangASTContext::eTypeIsObjC) && 561 (pointer_type_flags & ClangASTContext::eTypeIsPointer)) 562 { 563 // This was an objective C object pointer and 564 // it was requested we skip any fragile ivars 565 // so return nothing here 566 return ValueObjectSP(); 567 } 568 } 569 var_path.erase (0, 1); // Remove the '-' 570 // Fall through 571 case '.': 572 { 573 const bool expr_is_ptr = var_path[0] == '>'; 574 575 var_path.erase (0, 1); // Remove the '.' or '>' 576 separator_idx = var_path.find_first_of(".-["); 577 ConstString child_name; 578 if (separator_idx == std::string::npos) 579 child_name.SetCString (var_path.c_str()); 580 else 581 child_name.SetCStringWithLength(var_path.c_str(), separator_idx); 582 583 if (check_ptr_vs_member) 584 { 585 // We either have a pointer type and need to verify 586 // valobj_sp is a pointer, or we have a member of a 587 // class/union/struct being accessed with the . syntax 588 // and need to verify we don't have a pointer. 589 const bool actual_is_ptr = valobj_sp->IsPointerType (); 590 591 if (actual_is_ptr != expr_is_ptr) 592 { 593 // Incorrect use of "." with a pointer, or "->" with 594 // a class/union/struct instance or reference. 595 valobj_sp->GetExpressionPath (var_expr_path_strm, false); 596 if (actual_is_ptr) 597 error.SetErrorStringWithFormat ("\"%s\" is a pointer and . was used to attempt to access \"%s\". Did you mean \"%s->%s\"?", 598 var_expr_path_strm.GetString().c_str(), 599 child_name.GetCString(), 600 var_expr_path_strm.GetString().c_str(), 601 var_path.c_str()); 602 else 603 error.SetErrorStringWithFormat ("\"%s\" is not a pointer and -> was used to attempt to access \"%s\". Did you mean \"%s.%s\"?", 604 var_expr_path_strm.GetString().c_str(), 605 child_name.GetCString(), 606 var_expr_path_strm.GetString().c_str(), 607 var_path.c_str()); 608 return ValueObjectSP(); 609 } 610 } 611 child_valobj_sp = valobj_sp->GetChildMemberWithName (child_name, true); 612 if (!child_valobj_sp) 613 { 614 // No child member with name "child_name" 615 valobj_sp->GetExpressionPath (var_expr_path_strm, false); 616 if (child_name) 617 { 618 error.SetErrorStringWithFormat ("\"%s\" is not a member of \"(%s) %s\"", 619 child_name.GetCString(), 620 valobj_sp->GetTypeName().AsCString("<invalid type>"), 621 var_expr_path_strm.GetString().c_str()); 622 } 623 else 624 { 625 error.SetErrorStringWithFormat ("incomplete expression path after \"%s\" in \"%s\"", 626 var_expr_path_strm.GetString().c_str(), 627 var_expr_cstr); 628 } 629 630 return ValueObjectSP(); 631 } 632 // Remove the child name from the path 633 var_path.erase(0, child_name.GetLength()); 634 if (use_dynamic != lldb::eNoDynamicValues) 635 { 636 ValueObjectSP dynamic_value_sp(child_valobj_sp->GetDynamicValue(use_dynamic)); 637 if (dynamic_value_sp) 638 child_valobj_sp = dynamic_value_sp; 639 } 640 } 641 break; 642 643 case '[': 644 // Array member access, or treating pointer as an array 645 if (var_path.size() > 2) // Need at least two brackets and a number 646 { 647 char *end = NULL; 648 long child_index = ::strtol (&var_path[1], &end, 0); 649 if (end && *end == ']') 650 { 651 652 if (valobj_sp->IsPointerType ()) 653 { 654 child_valobj_sp = valobj_sp->GetSyntheticArrayMemberFromPointer (child_index, true); 655 if (!child_valobj_sp) 656 { 657 valobj_sp->GetExpressionPath (var_expr_path_strm, false); 658 error.SetErrorStringWithFormat ("failed to use pointer as array for index %i for \"(%s) %s\"", 659 child_index, 660 valobj_sp->GetTypeName().AsCString("<invalid type>"), 661 var_expr_path_strm.GetString().c_str()); 662 } 663 } 664 else if (ClangASTContext::IsArrayType (valobj_sp->GetClangType(), NULL, NULL)) 665 { 666 // Pass false to dynamic_value here so we can tell the difference between 667 // no dynamic value and no member of this type... 668 child_valobj_sp = valobj_sp->GetChildAtIndex (child_index, true); 669 if (!child_valobj_sp) 670 { 671 valobj_sp->GetExpressionPath (var_expr_path_strm, false); 672 error.SetErrorStringWithFormat ("array index %i is not valid for \"(%s) %s\"", 673 child_index, 674 valobj_sp->GetTypeName().AsCString("<invalid type>"), 675 var_expr_path_strm.GetString().c_str()); 676 } 677 } 678 else 679 { 680 valobj_sp->GetExpressionPath (var_expr_path_strm, false); 681 error.SetErrorStringWithFormat ("\"(%s) %s\" is not an array type", 682 valobj_sp->GetTypeName().AsCString("<invalid type>"), 683 var_expr_path_strm.GetString().c_str()); 684 } 685 686 if (!child_valobj_sp) 687 { 688 // Invalid array index... 689 return ValueObjectSP(); 690 } 691 692 // Erase the array member specification '[%i]' where 693 // %i is the array index 694 var_path.erase(0, (end - var_path.c_str()) + 1); 695 separator_idx = var_path.find_first_of(".-["); 696 if (use_dynamic != lldb::eNoDynamicValues) 697 { 698 ValueObjectSP dynamic_value_sp(child_valobj_sp->GetDynamicValue(use_dynamic)); 699 if (dynamic_value_sp) 700 child_valobj_sp = dynamic_value_sp; 701 } 702 // Break out early from the switch since we were 703 // able to find the child member 704 break; 705 } 706 } 707 return ValueObjectSP(); 708 709 default: 710 // Failure... 711 { 712 valobj_sp->GetExpressionPath (var_expr_path_strm, false); 713 error.SetErrorStringWithFormat ("unexpected char '%c' encountered after \"%s\" in \"%s\"", 714 separator_type, 715 var_expr_path_strm.GetString().c_str(), 716 var_path.c_str()); 717 718 return ValueObjectSP(); 719 } 720 } 721 722 if (child_valobj_sp) 723 valobj_sp = child_valobj_sp; 724 725 if (var_path.empty()) 726 break; 727 728 } 729 if (valobj_sp) 730 { 731 if (deref) 732 { 733 ValueObjectSP deref_valobj_sp (valobj_sp->Dereference(error)); 734 valobj_sp = deref_valobj_sp; 735 } 736 else if (address_of) 737 { 738 ValueObjectSP address_of_valobj_sp (valobj_sp->AddressOf(error)); 739 valobj_sp = address_of_valobj_sp; 740 } 741 } 742 return valobj_sp; 743 } 744 else 745 { 746 error.SetErrorStringWithFormat("no variable named '%s' found in this frame", 747 name_const_string.GetCString()); 748 } 749 } 750 } 751 else 752 { 753 error.SetErrorStringWithFormat("invalid variable path '%s'", var_expr_cstr); 754 } 755 return ValueObjectSP(); 756 } 757 758 bool 759 StackFrame::GetFrameBaseValue (Scalar &frame_base, Error *error_ptr) 760 { 761 if (m_flags.IsClear(GOT_FRAME_BASE)) 762 { 763 if (m_sc.function) 764 { 765 m_frame_base.Clear(); 766 m_frame_base_error.Clear(); 767 768 m_flags.Set(GOT_FRAME_BASE); 769 ExecutionContext exe_ctx (&m_thread.GetProcess(), &m_thread, this); 770 Value expr_value; 771 addr_t loclist_base_addr = LLDB_INVALID_ADDRESS; 772 if (m_sc.function->GetFrameBaseExpression().IsLocationList()) 773 loclist_base_addr = m_sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress (&m_thread.GetProcess().GetTarget()); 774 775 if (m_sc.function->GetFrameBaseExpression().Evaluate(&exe_ctx, NULL, NULL, NULL, NULL, loclist_base_addr, NULL, expr_value, &m_frame_base_error) == false) 776 { 777 // We should really have an error if evaluate returns, but in case 778 // we don't, lets set the error to something at least. 779 if (m_frame_base_error.Success()) 780 m_frame_base_error.SetErrorString("Evaluation of the frame base expression failed."); 781 } 782 else 783 { 784 m_frame_base = expr_value.ResolveValue(&exe_ctx, NULL); 785 } 786 } 787 else 788 { 789 m_frame_base_error.SetErrorString ("No function in symbol context."); 790 } 791 } 792 793 if (m_frame_base_error.Success()) 794 frame_base = m_frame_base; 795 796 if (error_ptr) 797 *error_ptr = m_frame_base_error; 798 return m_frame_base_error.Success(); 799 } 800 801 RegisterContextSP 802 StackFrame::GetRegisterContext () 803 { 804 if (!m_reg_context_sp) 805 m_reg_context_sp = m_thread.CreateRegisterContextForFrame (this); 806 return m_reg_context_sp; 807 } 808 809 bool 810 StackFrame::HasDebugInformation () 811 { 812 GetSymbolContext (eSymbolContextLineEntry); 813 return m_sc.line_entry.IsValid(); 814 } 815 816 817 ValueObjectSP 818 StackFrame::GetValueObjectForFrameVariable (const VariableSP &variable_sp, lldb::DynamicValueType use_dynamic) 819 { 820 ValueObjectSP valobj_sp; 821 VariableList *var_list = GetVariableList (true); 822 if (var_list) 823 { 824 // Make sure the variable is a frame variable 825 const uint32_t var_idx = var_list->FindIndexForVariable (variable_sp.get()); 826 const uint32_t num_variables = var_list->GetSize(); 827 if (var_idx < num_variables) 828 { 829 valobj_sp = m_variable_list_value_objects.GetValueObjectAtIndex (var_idx); 830 if (valobj_sp.get() == NULL) 831 { 832 if (m_variable_list_value_objects.GetSize() < num_variables) 833 m_variable_list_value_objects.Resize(num_variables); 834 valobj_sp = ValueObjectVariable::Create (this, variable_sp); 835 m_variable_list_value_objects.SetValueObjectAtIndex (var_idx, valobj_sp); 836 } 837 } 838 } 839 if (use_dynamic != lldb::eNoDynamicValues && valobj_sp) 840 { 841 ValueObjectSP dynamic_sp = valobj_sp->GetDynamicValue (use_dynamic); 842 if (dynamic_sp) 843 return dynamic_sp; 844 } 845 return valobj_sp; 846 } 847 848 ValueObjectSP 849 StackFrame::TrackGlobalVariable (const VariableSP &variable_sp, lldb::DynamicValueType use_dynamic) 850 { 851 // Check to make sure we aren't already tracking this variable? 852 ValueObjectSP valobj_sp (GetValueObjectForFrameVariable (variable_sp, use_dynamic)); 853 if (!valobj_sp) 854 { 855 // We aren't already tracking this global 856 VariableList *var_list = GetVariableList (true); 857 // If this frame has no variables, create a new list 858 if (var_list == NULL) 859 m_variable_list_sp.reset (new VariableList()); 860 861 // Add the global/static variable to this frame 862 m_variable_list_sp->AddVariable (variable_sp); 863 864 // Now make a value object for it so we can track its changes 865 valobj_sp = GetValueObjectForFrameVariable (variable_sp, use_dynamic); 866 } 867 return valobj_sp; 868 } 869 870 bool 871 StackFrame::IsInlined () 872 { 873 if (m_sc.block == NULL) 874 GetSymbolContext (eSymbolContextBlock); 875 if (m_sc.block) 876 return m_sc.block->GetContainingInlinedBlock() != NULL; 877 return false; 878 } 879 880 Target * 881 StackFrame::CalculateTarget () 882 { 883 return m_thread.CalculateTarget(); 884 } 885 886 Process * 887 StackFrame::CalculateProcess () 888 { 889 return m_thread.CalculateProcess(); 890 } 891 892 Thread * 893 StackFrame::CalculateThread () 894 { 895 return &m_thread; 896 } 897 898 StackFrame * 899 StackFrame::CalculateStackFrame () 900 { 901 return this; 902 } 903 904 905 void 906 StackFrame::CalculateExecutionContext (ExecutionContext &exe_ctx) 907 { 908 m_thread.CalculateExecutionContext (exe_ctx); 909 exe_ctx.frame = this; 910 } 911 912 void 913 StackFrame::DumpUsingSettingsFormat (Stream *strm) 914 { 915 if (strm == NULL) 916 return; 917 918 GetSymbolContext(eSymbolContextEverything); 919 ExecutionContext exe_ctx; 920 CalculateExecutionContext(exe_ctx); 921 const char *end = NULL; 922 StreamString s; 923 const char *frame_format = m_thread.GetProcess().GetTarget().GetDebugger().GetFrameFormat(); 924 if (frame_format && Debugger::FormatPrompt (frame_format, &m_sc, &exe_ctx, NULL, s, &end)) 925 { 926 strm->Write(s.GetData(), s.GetSize()); 927 } 928 else 929 { 930 Dump (strm, true, false); 931 strm->EOL(); 932 } 933 } 934 935 void 936 StackFrame::Dump (Stream *strm, bool show_frame_index, bool show_fullpaths) 937 { 938 if (strm == NULL) 939 return; 940 941 if (show_frame_index) 942 strm->Printf("frame #%u: ", m_frame_index); 943 strm->Printf("0x%0*llx ", m_thread.GetProcess().GetTarget().GetArchitecture().GetAddressByteSize() * 2, GetFrameCodeAddress().GetLoadAddress(&m_thread.GetProcess().GetTarget())); 944 GetSymbolContext(eSymbolContextEverything); 945 const bool show_module = true; 946 const bool show_inline = true; 947 m_sc.DumpStopContext(strm, &m_thread.GetProcess(), GetFrameCodeAddress(), show_fullpaths, show_module, show_inline); 948 } 949 950 void 951 StackFrame::UpdateCurrentFrameFromPreviousFrame (StackFrame &prev_frame) 952 { 953 assert (GetStackID() == prev_frame.GetStackID()); // TODO: remove this after some testing 954 m_variable_list_sp = prev_frame.m_variable_list_sp; 955 m_variable_list_value_objects.Swap (prev_frame.m_variable_list_value_objects); 956 if (!m_disassembly.GetString().empty()) 957 m_disassembly.GetString().swap (m_disassembly.GetString()); 958 } 959 960 961 void 962 StackFrame::UpdatePreviousFrameFromCurrentFrame (StackFrame &curr_frame) 963 { 964 assert (GetStackID() == curr_frame.GetStackID()); // TODO: remove this after some testing 965 m_id.SetPC (curr_frame.m_id.GetPC()); // Update the Stack ID PC value 966 assert (&m_thread == &curr_frame.m_thread); 967 m_frame_index = curr_frame.m_frame_index; 968 m_concrete_frame_index = curr_frame.m_concrete_frame_index; 969 m_reg_context_sp = curr_frame.m_reg_context_sp; 970 m_frame_code_addr = curr_frame.m_frame_code_addr; 971 assert (m_sc.target_sp.get() == NULL || curr_frame.m_sc.target_sp.get() == NULL || m_sc.target_sp.get() == curr_frame.m_sc.target_sp.get()); 972 assert (m_sc.module_sp.get() == NULL || curr_frame.m_sc.module_sp.get() == NULL || m_sc.module_sp.get() == curr_frame.m_sc.module_sp.get()); 973 assert (m_sc.comp_unit == NULL || curr_frame.m_sc.comp_unit == NULL || m_sc.comp_unit == curr_frame.m_sc.comp_unit); 974 assert (m_sc.function == NULL || curr_frame.m_sc.function == NULL || m_sc.function == curr_frame.m_sc.function); 975 m_sc = curr_frame.m_sc; 976 m_flags.Clear(GOT_FRAME_BASE | eSymbolContextEverything); 977 m_flags.Set (m_sc.GetResolvedMask()); 978 m_frame_base.Clear(); 979 m_frame_base_error.Clear(); 980 } 981 982 983 bool 984 StackFrame::HasCachedData () const 985 { 986 if (m_variable_list_sp.get()) 987 return true; 988 if (m_variable_list_value_objects.GetSize() > 0) 989 return true; 990 if (!m_disassembly.GetString().empty()) 991 return true; 992 return false; 993 } 994 995 lldb::StackFrameSP 996 StackFrame::GetSP () 997 { 998 return m_thread.GetStackFrameSPForStackFramePtr (this); 999 } 1000 1001 1002 1003 bool 1004 StackFrame::GetStatus (Stream& strm, 1005 bool show_frame_info, 1006 bool show_source, 1007 uint32_t source_lines_before, 1008 uint32_t source_lines_after) 1009 { 1010 if (show_frame_info) 1011 { 1012 strm.Indent(); 1013 DumpUsingSettingsFormat (&strm); 1014 } 1015 1016 if (show_source) 1017 { 1018 GetSymbolContext(eSymbolContextCompUnit | eSymbolContextLineEntry); 1019 1020 if (m_sc.comp_unit && m_sc.line_entry.IsValid()) 1021 { 1022 Target &target = GetThread().GetProcess().GetTarget(); 1023 target.GetDebugger().GetSourceManager().DisplaySourceLinesWithLineNumbers ( 1024 &target, 1025 m_sc.line_entry.file, 1026 m_sc.line_entry.line, 1027 3, 1028 3, 1029 "->", 1030 &strm); 1031 1032 } 1033 } 1034 return true; 1035 } 1036 1037