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 const 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 222 if (m_frame_code_addr.SetOpcodeLoadAddress (m_frame_code_addr.GetOffset(), &m_thread.GetProcess().GetTarget())) 223 { 224 const Section *section = m_frame_code_addr.GetSection(); 225 if (section) 226 { 227 Module *module = section->GetModule(); 228 if (module) 229 { 230 m_sc.module_sp = module->GetSP(); 231 if (m_sc.module_sp) 232 m_flags.Set(eSymbolContextModule); 233 } 234 } 235 } 236 } 237 return m_frame_code_addr; 238 } 239 240 void 241 StackFrame::ChangePC (addr_t pc) 242 { 243 m_frame_code_addr.SetOffset(pc); 244 m_frame_code_addr.SetSection(NULL); 245 m_sc.Clear(); 246 m_flags.Reset(0); 247 m_thread.ClearStackFrames (); 248 } 249 250 const char * 251 StackFrame::Disassemble () 252 { 253 if (m_disassembly.GetSize() == 0) 254 { 255 ExecutionContext exe_ctx; 256 CalculateExecutionContext(exe_ctx); 257 Target &target = m_thread.GetProcess().GetTarget(); 258 Disassembler::Disassemble (target.GetDebugger(), 259 target.GetArchitecture(), 260 NULL, 261 exe_ctx, 262 0, 263 0, 264 0, 265 m_disassembly); 266 if (m_disassembly.GetSize() == 0) 267 return NULL; 268 } 269 return m_disassembly.GetData(); 270 } 271 272 Block * 273 StackFrame::GetFrameBlock () 274 { 275 if (m_sc.block == NULL && m_flags.IsClear (eSymbolContextBlock)) 276 GetSymbolContext (eSymbolContextBlock); 277 278 if (m_sc.block) 279 { 280 Block *inline_block = m_sc.block->GetContainingInlinedBlock(); 281 if (inline_block) 282 { 283 // Use the block with the inlined function info 284 // as the frame block we want this frame to have only the variables 285 // for the inlined function and its non-inlined block child blocks. 286 return inline_block; 287 } 288 else 289 { 290 // This block is not contained withing any inlined function blocks 291 // with so we want to use the top most function block. 292 return &m_sc.function->GetBlock (false); 293 } 294 } 295 return NULL; 296 } 297 298 //---------------------------------------------------------------------- 299 // Get the symbol context if we already haven't done so by resolving the 300 // PC address as much as possible. This way when we pass around a 301 // StackFrame object, everyone will have as much information as 302 // possible and no one will ever have to look things up manually. 303 //---------------------------------------------------------------------- 304 const SymbolContext& 305 StackFrame::GetSymbolContext (uint32_t resolve_scope) 306 { 307 // Copy our internal symbol context into "sc". 308 if ((m_flags.Get() & resolve_scope) != resolve_scope) 309 { 310 // Resolve our PC to section offset if we haven't alreday done so 311 // and if we don't have a module. The resolved address section will 312 // contain the module to which it belongs 313 if (!m_sc.module_sp && m_flags.IsClear(RESOLVED_FRAME_CODE_ADDR)) 314 GetFrameCodeAddress(); 315 316 // If this is not frame zero, then we need to subtract 1 from the PC 317 // value when doing address lookups since the PC will be on the 318 // instruction following the function call instruction... 319 320 Address lookup_addr(GetFrameCodeAddress()); 321 if (m_frame_index > 0 && lookup_addr.IsValid()) 322 { 323 addr_t offset = lookup_addr.GetOffset(); 324 if (offset > 0) 325 lookup_addr.SetOffset(offset - 1); 326 } 327 328 329 uint32_t resolved = 0; 330 if (m_sc.module_sp) 331 { 332 // We have something in our stack frame symbol context, lets check 333 // if we haven't already tried to lookup one of those things. If we 334 // haven't then we will do the query. 335 336 uint32_t actual_resolve_scope = 0; 337 338 if (resolve_scope & eSymbolContextCompUnit) 339 { 340 if (m_flags.IsClear (eSymbolContextCompUnit)) 341 { 342 if (m_sc.comp_unit) 343 resolved |= eSymbolContextCompUnit; 344 else 345 actual_resolve_scope |= eSymbolContextCompUnit; 346 } 347 } 348 349 if (resolve_scope & eSymbolContextFunction) 350 { 351 if (m_flags.IsClear (eSymbolContextFunction)) 352 { 353 if (m_sc.function) 354 resolved |= eSymbolContextFunction; 355 else 356 actual_resolve_scope |= eSymbolContextFunction; 357 } 358 } 359 360 if (resolve_scope & eSymbolContextBlock) 361 { 362 if (m_flags.IsClear (eSymbolContextBlock)) 363 { 364 if (m_sc.block) 365 resolved |= eSymbolContextBlock; 366 else 367 actual_resolve_scope |= eSymbolContextBlock; 368 } 369 } 370 371 if (resolve_scope & eSymbolContextSymbol) 372 { 373 if (m_flags.IsClear (eSymbolContextSymbol)) 374 { 375 if (m_sc.symbol) 376 resolved |= eSymbolContextSymbol; 377 else 378 actual_resolve_scope |= eSymbolContextSymbol; 379 } 380 } 381 382 if (resolve_scope & eSymbolContextLineEntry) 383 { 384 if (m_flags.IsClear (eSymbolContextLineEntry)) 385 { 386 if (m_sc.line_entry.IsValid()) 387 resolved |= eSymbolContextLineEntry; 388 else 389 actual_resolve_scope |= eSymbolContextLineEntry; 390 } 391 } 392 393 if (actual_resolve_scope) 394 { 395 // We might be resolving less information than what is already 396 // in our current symbol context so resolve into a temporary 397 // symbol context "sc" so we don't clear out data we have 398 // already found in "m_sc" 399 SymbolContext sc; 400 // Set flags that indicate what we have tried to resolve 401 resolved |= m_sc.module_sp->ResolveSymbolContextForAddress (lookup_addr, actual_resolve_scope, sc); 402 // Only replace what we didn't already have as we may have 403 // information for an inlined function scope that won't match 404 // what a standard lookup by address would match 405 if ((resolved & eSymbolContextCompUnit) && m_sc.comp_unit == NULL) 406 m_sc.comp_unit = sc.comp_unit; 407 if ((resolved & eSymbolContextFunction) && m_sc.function == NULL) 408 m_sc.function = sc.function; 409 if ((resolved & eSymbolContextBlock) && m_sc.block == NULL) 410 m_sc.block = sc.block; 411 if ((resolved & eSymbolContextSymbol) && m_sc.symbol == NULL) 412 m_sc.symbol = sc.symbol; 413 if ((resolved & eSymbolContextLineEntry) && !m_sc.line_entry.IsValid()) 414 m_sc.line_entry = sc.line_entry; 415 416 } 417 } 418 else 419 { 420 // If we don't have a module, then we can't have the compile unit, 421 // function, block, line entry or symbol, so we can safely call 422 // ResolveSymbolContextForAddress with our symbol context member m_sc. 423 resolved |= m_thread.GetProcess().GetTarget().GetImages().ResolveSymbolContextForAddress (lookup_addr, resolve_scope, m_sc); 424 } 425 426 // If the target was requested add that: 427 if (m_sc.target_sp.get() == NULL) 428 { 429 m_sc.target_sp = CalculateProcess()->GetTarget().GetSP(); 430 if (m_sc.target_sp) 431 resolved |= eSymbolContextTarget; 432 } 433 434 // Update our internal flags so we remember what we have tried to locate so 435 // we don't have to keep trying when more calls to this function are made. 436 // We might have dug up more information that was requested (for example 437 // if we were asked to only get the block, we will have gotten the 438 // compile unit, and function) so set any additional bits that we resolved 439 m_flags.Set (resolve_scope | resolved); 440 } 441 442 // Return the symbol context with everything that was possible to resolve 443 // resolved. 444 return m_sc; 445 } 446 447 448 VariableList * 449 StackFrame::GetVariableList (bool get_file_globals) 450 { 451 if (m_flags.IsClear(RESOLVED_VARIABLES)) 452 { 453 m_flags.Set(RESOLVED_VARIABLES); 454 455 Block *frame_block = GetFrameBlock(); 456 457 if (frame_block) 458 { 459 const bool get_child_variables = true; 460 const bool can_create = true; 461 const bool stop_if_child_block_is_inlined_function = true; 462 m_variable_list_sp.reset(new VariableList()); 463 frame_block->AppendBlockVariables(can_create, get_child_variables, stop_if_child_block_is_inlined_function, m_variable_list_sp.get()); 464 } 465 } 466 467 if (m_flags.IsClear(RESOLVED_GLOBAL_VARIABLES) && 468 get_file_globals) 469 { 470 m_flags.Set(RESOLVED_GLOBAL_VARIABLES); 471 472 if (m_flags.IsClear (eSymbolContextCompUnit)) 473 GetSymbolContext (eSymbolContextCompUnit); 474 475 if (m_sc.comp_unit) 476 { 477 VariableListSP global_variable_list_sp (m_sc.comp_unit->GetVariableList(true)); 478 if (m_variable_list_sp) 479 m_variable_list_sp->AddVariables (global_variable_list_sp.get()); 480 else 481 m_variable_list_sp = global_variable_list_sp; 482 } 483 } 484 485 return m_variable_list_sp.get(); 486 } 487 488 VariableListSP 489 StackFrame::GetInScopeVariableList (bool get_file_globals) 490 { 491 VariableListSP var_list_sp(new VariableList); 492 GetSymbolContext (eSymbolContextCompUnit | eSymbolContextBlock); 493 494 if (m_sc.block) 495 { 496 const bool can_create = true; 497 const bool get_parent_variables = true; 498 const bool stop_if_block_is_inlined_function = true; 499 m_sc.block->AppendVariables (can_create, 500 get_parent_variables, 501 stop_if_block_is_inlined_function, 502 var_list_sp.get()); 503 } 504 505 if (m_sc.comp_unit) 506 { 507 VariableListSP global_variable_list_sp (m_sc.comp_unit->GetVariableList(true)); 508 if (global_variable_list_sp) 509 var_list_sp->AddVariables (global_variable_list_sp.get()); 510 } 511 512 return var_list_sp; 513 } 514 515 516 ValueObjectSP 517 StackFrame::GetValueForVariableExpressionPath (const char *var_expr_cstr, 518 lldb::DynamicValueType use_dynamic, 519 uint32_t options, 520 lldb::VariableSP &var_sp, 521 Error &error) 522 { 523 524 if (var_expr_cstr && var_expr_cstr[0]) 525 { 526 const bool check_ptr_vs_member = (options & eExpressionPathOptionCheckPtrVsMember) != 0; 527 const bool no_fragile_ivar = (options & eExpressionPathOptionsNoFragileObjcIvar) != 0; 528 const bool no_synth_child = (options & eExpressionPathOptionsNoSyntheticChildren) != 0; 529 //const bool no_synth_array = (options & eExpressionPathOptionsNoSyntheticArrayRange) != 0; 530 error.Clear(); 531 bool deref = false; 532 bool address_of = false; 533 ValueObjectSP valobj_sp; 534 const bool get_file_globals = true; 535 // When looking up a variable for an expression, we need only consider the 536 // variables that are in scope. 537 VariableListSP var_list_sp (GetInScopeVariableList (get_file_globals)); 538 VariableList *variable_list = var_list_sp.get(); 539 540 if (variable_list) 541 { 542 // If first character is a '*', then show pointer contents 543 const char *var_expr = var_expr_cstr; 544 if (var_expr[0] == '*') 545 { 546 deref = true; 547 var_expr++; // Skip the '*' 548 } 549 else if (var_expr[0] == '&') 550 { 551 address_of = true; 552 var_expr++; // Skip the '&' 553 } 554 555 std::string var_path (var_expr); 556 size_t separator_idx = var_path.find_first_of(".-[=+~|&^%#@!/?,<>{}"); 557 StreamString var_expr_path_strm; 558 559 ConstString name_const_string; 560 if (separator_idx == std::string::npos) 561 name_const_string.SetCString (var_path.c_str()); 562 else 563 name_const_string.SetCStringWithLength (var_path.c_str(), separator_idx); 564 565 var_sp = variable_list->FindVariable(name_const_string); 566 if (var_sp) 567 { 568 valobj_sp = GetValueObjectForFrameVariable (var_sp, use_dynamic); 569 if (!valobj_sp) 570 return valobj_sp; 571 572 var_path.erase (0, name_const_string.GetLength ()); 573 // We are dumping at least one child 574 while (separator_idx != std::string::npos) 575 { 576 // Calculate the next separator index ahead of time 577 ValueObjectSP child_valobj_sp; 578 const char separator_type = var_path[0]; 579 switch (separator_type) 580 { 581 582 case '-': 583 if (var_path.size() >= 2 && var_path[1] != '>') 584 return ValueObjectSP(); 585 586 if (no_fragile_ivar) 587 { 588 // Make sure we aren't trying to deref an objective 589 // C ivar if this is not allowed 590 const uint32_t pointer_type_flags = ClangASTContext::GetTypeInfo (valobj_sp->GetClangType(), NULL, NULL); 591 if ((pointer_type_flags & ClangASTContext::eTypeIsObjC) && 592 (pointer_type_flags & ClangASTContext::eTypeIsPointer)) 593 { 594 // This was an objective C object pointer and 595 // it was requested we skip any fragile ivars 596 // so return nothing here 597 return ValueObjectSP(); 598 } 599 } 600 var_path.erase (0, 1); // Remove the '-' 601 // Fall through 602 case '.': 603 { 604 const bool expr_is_ptr = var_path[0] == '>'; 605 606 var_path.erase (0, 1); // Remove the '.' or '>' 607 separator_idx = var_path.find_first_of(".-["); 608 ConstString child_name; 609 if (separator_idx == std::string::npos) 610 child_name.SetCString (var_path.c_str()); 611 else 612 child_name.SetCStringWithLength(var_path.c_str(), separator_idx); 613 614 if (check_ptr_vs_member) 615 { 616 // We either have a pointer type and need to verify 617 // valobj_sp is a pointer, or we have a member of a 618 // class/union/struct being accessed with the . syntax 619 // and need to verify we don't have a pointer. 620 const bool actual_is_ptr = valobj_sp->IsPointerType (); 621 622 if (actual_is_ptr != expr_is_ptr) 623 { 624 // Incorrect use of "." with a pointer, or "->" with 625 // a class/union/struct instance or reference. 626 valobj_sp->GetExpressionPath (var_expr_path_strm, false); 627 if (actual_is_ptr) 628 error.SetErrorStringWithFormat ("\"%s\" is a pointer and . was used to attempt to access \"%s\". Did you mean \"%s->%s\"?", 629 var_expr_path_strm.GetString().c_str(), 630 child_name.GetCString(), 631 var_expr_path_strm.GetString().c_str(), 632 var_path.c_str()); 633 else 634 error.SetErrorStringWithFormat ("\"%s\" is not a pointer and -> was used to attempt to access \"%s\". Did you mean \"%s.%s\"?", 635 var_expr_path_strm.GetString().c_str(), 636 child_name.GetCString(), 637 var_expr_path_strm.GetString().c_str(), 638 var_path.c_str()); 639 return ValueObjectSP(); 640 } 641 } 642 child_valobj_sp = valobj_sp->GetChildMemberWithName (child_name, true); 643 if (!child_valobj_sp) 644 { 645 if (no_synth_child == false) 646 child_valobj_sp = valobj_sp->GetSyntheticValue(lldb::eUseSyntheticFilter)->GetChildMemberWithName (child_name, true); 647 648 if (no_synth_child || !child_valobj_sp) 649 { 650 // No child member with name "child_name" 651 valobj_sp->GetExpressionPath (var_expr_path_strm, false); 652 if (child_name) 653 { 654 error.SetErrorStringWithFormat ("\"%s\" is not a member of \"(%s) %s\"", 655 child_name.GetCString(), 656 valobj_sp->GetTypeName().AsCString("<invalid type>"), 657 var_expr_path_strm.GetString().c_str()); 658 } 659 else 660 { 661 error.SetErrorStringWithFormat ("incomplete expression path after \"%s\" in \"%s\"", 662 var_expr_path_strm.GetString().c_str(), 663 var_expr_cstr); 664 } 665 return ValueObjectSP(); 666 } 667 } 668 // Remove the child name from the path 669 var_path.erase(0, child_name.GetLength()); 670 if (use_dynamic != lldb::eNoDynamicValues) 671 { 672 ValueObjectSP dynamic_value_sp(child_valobj_sp->GetDynamicValue(use_dynamic)); 673 if (dynamic_value_sp) 674 child_valobj_sp = dynamic_value_sp; 675 } 676 } 677 break; 678 679 case '[': 680 // Array member access, or treating pointer as an array 681 if (var_path.size() > 2) // Need at least two brackets and a number 682 { 683 char *end = NULL; 684 long child_index = ::strtol (&var_path[1], &end, 0); 685 if (end && *end == ']' 686 && *(end-1) != '[') // this code forces an error in the case of arr[]. as bitfield[] is not a good syntax we're good to go 687 { 688 if (ClangASTContext::IsPointerToScalarType(valobj_sp->GetClangType()) && deref) 689 { 690 // what we have is *ptr[low]. the most similar C++ syntax is to deref ptr 691 // and extract bit low out of it. reading array item low 692 // would be done by saying ptr[low], without a deref * sign 693 Error error; 694 ValueObjectSP temp(valobj_sp->Dereference(error)); 695 if (error.Fail()) 696 { 697 valobj_sp->GetExpressionPath (var_expr_path_strm, false); 698 error.SetErrorStringWithFormat ("could not dereference \"(%s) %s\"", 699 valobj_sp->GetTypeName().AsCString("<invalid type>"), 700 var_expr_path_strm.GetString().c_str()); 701 return ValueObjectSP(); 702 } 703 valobj_sp = temp; 704 deref = false; 705 } 706 else if (ClangASTContext::IsArrayOfScalarType(valobj_sp->GetClangType()) && deref) 707 { 708 // what we have is *arr[low]. the most similar C++ syntax is to get arr[0] 709 // (an operation that is equivalent to deref-ing arr) 710 // and extract bit low out of it. reading array item low 711 // would be done by saying arr[low], without a deref * sign 712 Error error; 713 ValueObjectSP temp(valobj_sp->GetChildAtIndex (0, true)); 714 if (error.Fail()) 715 { 716 valobj_sp->GetExpressionPath (var_expr_path_strm, false); 717 error.SetErrorStringWithFormat ("could not get item 0 for \"(%s) %s\"", 718 valobj_sp->GetTypeName().AsCString("<invalid type>"), 719 var_expr_path_strm.GetString().c_str()); 720 return ValueObjectSP(); 721 } 722 valobj_sp = temp; 723 deref = false; 724 } 725 726 if (valobj_sp->IsPointerType ()) 727 { 728 if (no_synth_child == false 729 && 730 ClangASTType::GetMinimumLanguage(valobj_sp->GetClangAST(), 731 valobj_sp->GetClangType()) == lldb::eLanguageTypeObjC /* is ObjC pointer */ 732 && 733 ClangASTContext::IsPointerType(ClangASTType::GetPointeeType(valobj_sp->GetClangType())) == false /* is not double-ptr */) 734 { 735 // dereferencing ObjC variables is not valid.. so let's try and recur to synthetic children 736 lldb::ValueObjectSP synthetic = valobj_sp->GetSyntheticValue(lldb::eUseSyntheticFilter); 737 if (synthetic.get() == NULL /* no synthetic */ 738 || synthetic == valobj_sp) /* synthetic is the same as the original object */ 739 { 740 valobj_sp->GetExpressionPath (var_expr_path_strm, false); 741 error.SetErrorStringWithFormat ("\"(%s) %s\" is not an array type", 742 valobj_sp->GetTypeName().AsCString("<invalid type>"), 743 var_expr_path_strm.GetString().c_str()); 744 } 745 else if (child_index >= synthetic->GetNumChildren() /* synthetic does not have that many values */) 746 { 747 valobj_sp->GetExpressionPath (var_expr_path_strm, false); 748 error.SetErrorStringWithFormat ("array index %i is not valid for \"(%s) %s\"", 749 child_index, 750 valobj_sp->GetTypeName().AsCString("<invalid type>"), 751 var_expr_path_strm.GetString().c_str()); 752 } 753 else 754 { 755 child_valobj_sp = synthetic->GetChildAtIndex(child_index, true); 756 if (!child_valobj_sp) 757 { 758 valobj_sp->GetExpressionPath (var_expr_path_strm, false); 759 error.SetErrorStringWithFormat ("array index %i is not valid for \"(%s) %s\"", 760 child_index, 761 valobj_sp->GetTypeName().AsCString("<invalid type>"), 762 var_expr_path_strm.GetString().c_str()); 763 } 764 } 765 } 766 else 767 { 768 child_valobj_sp = valobj_sp->GetSyntheticArrayMemberFromPointer (child_index, true); 769 if (!child_valobj_sp) 770 { 771 valobj_sp->GetExpressionPath (var_expr_path_strm, false); 772 error.SetErrorStringWithFormat ("failed to use pointer as array for index %i for \"(%s) %s\"", 773 child_index, 774 valobj_sp->GetTypeName().AsCString("<invalid type>"), 775 var_expr_path_strm.GetString().c_str()); 776 } 777 } 778 } 779 else if (ClangASTContext::IsArrayType (valobj_sp->GetClangType(), NULL, NULL)) 780 { 781 // Pass false to dynamic_value here so we can tell the difference between 782 // no dynamic value and no member of this type... 783 child_valobj_sp = valobj_sp->GetChildAtIndex (child_index, true); 784 if (!child_valobj_sp) 785 { 786 valobj_sp->GetExpressionPath (var_expr_path_strm, false); 787 error.SetErrorStringWithFormat ("array index %i is not valid for \"(%s) %s\"", 788 child_index, 789 valobj_sp->GetTypeName().AsCString("<invalid type>"), 790 var_expr_path_strm.GetString().c_str()); 791 } 792 } 793 else if (ClangASTContext::IsScalarType(valobj_sp->GetClangType())) 794 { 795 // this is a bitfield asking to display just one bit 796 child_valobj_sp = valobj_sp->GetSyntheticBitFieldChild(child_index, child_index, true); 797 if (!child_valobj_sp) 798 { 799 valobj_sp->GetExpressionPath (var_expr_path_strm, false); 800 error.SetErrorStringWithFormat ("bitfield range %i-%i is not valid for \"(%s) %s\"", 801 child_index, child_index, 802 valobj_sp->GetTypeName().AsCString("<invalid type>"), 803 var_expr_path_strm.GetString().c_str()); 804 } 805 } 806 else 807 { 808 lldb::ValueObjectSP synthetic = valobj_sp->GetSyntheticValue(lldb::eUseSyntheticFilter); 809 if (no_synth_child /* synthetic is forbidden */ || 810 synthetic.get() == NULL /* no synthetic */ 811 || synthetic == valobj_sp) /* synthetic is the same as the original object */ 812 { 813 valobj_sp->GetExpressionPath (var_expr_path_strm, false); 814 error.SetErrorStringWithFormat ("\"(%s) %s\" is not an array type", 815 valobj_sp->GetTypeName().AsCString("<invalid type>"), 816 var_expr_path_strm.GetString().c_str()); 817 } 818 else if (child_index >= synthetic->GetNumChildren() /* synthetic does not have that many values */) 819 { 820 valobj_sp->GetExpressionPath (var_expr_path_strm, false); 821 error.SetErrorStringWithFormat ("array index %i is not valid for \"(%s) %s\"", 822 child_index, 823 valobj_sp->GetTypeName().AsCString("<invalid type>"), 824 var_expr_path_strm.GetString().c_str()); 825 } 826 else 827 { 828 child_valobj_sp = synthetic->GetChildAtIndex(child_index, true); 829 if (!child_valobj_sp) 830 { 831 valobj_sp->GetExpressionPath (var_expr_path_strm, false); 832 error.SetErrorStringWithFormat ("array index %i is not valid for \"(%s) %s\"", 833 child_index, 834 valobj_sp->GetTypeName().AsCString("<invalid type>"), 835 var_expr_path_strm.GetString().c_str()); 836 } 837 } 838 } 839 840 if (!child_valobj_sp) 841 { 842 // Invalid array index... 843 return ValueObjectSP(); 844 } 845 846 // Erase the array member specification '[%i]' where 847 // %i is the array index 848 var_path.erase(0, (end - var_path.c_str()) + 1); 849 separator_idx = var_path.find_first_of(".-["); 850 if (use_dynamic != lldb::eNoDynamicValues) 851 { 852 ValueObjectSP dynamic_value_sp(child_valobj_sp->GetDynamicValue(use_dynamic)); 853 if (dynamic_value_sp) 854 child_valobj_sp = dynamic_value_sp; 855 } 856 // Break out early from the switch since we were 857 // able to find the child member 858 break; 859 } 860 else if (end && *end == '-') 861 { 862 // this is most probably a BitField, let's take a look 863 char *real_end = NULL; 864 long final_index = ::strtol (end+1, &real_end, 0); 865 bool expand_bitfield = true; 866 if (real_end && *real_end == ']') 867 { 868 // if the format given is [high-low], swap range 869 if (child_index > final_index) 870 { 871 long temp = child_index; 872 child_index = final_index; 873 final_index = temp; 874 } 875 876 if (ClangASTContext::IsPointerToScalarType(valobj_sp->GetClangType()) && deref) 877 { 878 // what we have is *ptr[low-high]. the most similar C++ syntax is to deref ptr 879 // and extract bits low thru high out of it. reading array items low thru high 880 // would be done by saying ptr[low-high], without a deref * sign 881 Error error; 882 ValueObjectSP temp(valobj_sp->Dereference(error)); 883 if (error.Fail()) 884 { 885 valobj_sp->GetExpressionPath (var_expr_path_strm, false); 886 error.SetErrorStringWithFormat ("could not dereference \"(%s) %s\"", 887 valobj_sp->GetTypeName().AsCString("<invalid type>"), 888 var_expr_path_strm.GetString().c_str()); 889 return ValueObjectSP(); 890 } 891 valobj_sp = temp; 892 deref = false; 893 } 894 else if (ClangASTContext::IsArrayOfScalarType(valobj_sp->GetClangType()) && deref) 895 { 896 // what we have is *arr[low-high]. the most similar C++ syntax is to get arr[0] 897 // (an operation that is equivalent to deref-ing arr) 898 // and extract bits low thru high out of it. reading array items low thru high 899 // would be done by saying arr[low-high], without a deref * sign 900 Error error; 901 ValueObjectSP temp(valobj_sp->GetChildAtIndex (0, true)); 902 if (error.Fail()) 903 { 904 valobj_sp->GetExpressionPath (var_expr_path_strm, false); 905 error.SetErrorStringWithFormat ("could not get item 0 for \"(%s) %s\"", 906 valobj_sp->GetTypeName().AsCString("<invalid type>"), 907 var_expr_path_strm.GetString().c_str()); 908 return ValueObjectSP(); 909 } 910 valobj_sp = temp; 911 deref = false; 912 } 913 /*else if (valobj_sp->IsArrayType() || valobj_sp->IsPointerType()) 914 { 915 child_valobj_sp = valobj_sp->GetSyntheticArrayRangeChild(child_index, final_index, true); 916 expand_bitfield = false; 917 if (!child_valobj_sp) 918 { 919 valobj_sp->GetExpressionPath (var_expr_path_strm, false); 920 error.SetErrorStringWithFormat ("array range %i-%i is not valid for \"(%s) %s\"", 921 child_index, final_index, 922 valobj_sp->GetTypeName().AsCString("<invalid type>"), 923 var_expr_path_strm.GetString().c_str()); 924 } 925 }*/ 926 927 if (expand_bitfield) 928 { 929 child_valobj_sp = valobj_sp->GetSyntheticBitFieldChild(child_index, final_index, true); 930 if (!child_valobj_sp) 931 { 932 valobj_sp->GetExpressionPath (var_expr_path_strm, false); 933 error.SetErrorStringWithFormat ("bitfield range %i-%i is not valid for \"(%s) %s\"", 934 child_index, final_index, 935 valobj_sp->GetTypeName().AsCString("<invalid type>"), 936 var_expr_path_strm.GetString().c_str()); 937 } 938 } 939 } 940 941 if (!child_valobj_sp) 942 { 943 // Invalid bitfield range... 944 return ValueObjectSP(); 945 } 946 947 // Erase the bitfield member specification '[%i-%i]' where 948 // %i is the index 949 var_path.erase(0, (real_end - var_path.c_str()) + 1); 950 separator_idx = var_path.find_first_of(".-["); 951 if (use_dynamic != lldb::eNoDynamicValues) 952 { 953 ValueObjectSP dynamic_value_sp(child_valobj_sp->GetDynamicValue(use_dynamic)); 954 if (dynamic_value_sp) 955 child_valobj_sp = dynamic_value_sp; 956 } 957 // Break out early from the switch since we were 958 // able to find the child member 959 break; 960 961 } 962 } 963 else 964 { 965 error.SetErrorStringWithFormat("invalid square bracket encountered after \"%s\" in \"%s\"", 966 var_expr_path_strm.GetString().c_str(), 967 var_path.c_str()); 968 } 969 return ValueObjectSP(); 970 971 default: 972 // Failure... 973 { 974 valobj_sp->GetExpressionPath (var_expr_path_strm, false); 975 error.SetErrorStringWithFormat ("unexpected char '%c' encountered after \"%s\" in \"%s\"", 976 separator_type, 977 var_expr_path_strm.GetString().c_str(), 978 var_path.c_str()); 979 980 return ValueObjectSP(); 981 } 982 } 983 984 if (child_valobj_sp) 985 valobj_sp = child_valobj_sp; 986 987 if (var_path.empty()) 988 break; 989 990 } 991 if (valobj_sp) 992 { 993 if (deref) 994 { 995 ValueObjectSP deref_valobj_sp (valobj_sp->Dereference(error)); 996 valobj_sp = deref_valobj_sp; 997 } 998 else if (address_of) 999 { 1000 ValueObjectSP address_of_valobj_sp (valobj_sp->AddressOf(error)); 1001 valobj_sp = address_of_valobj_sp; 1002 } 1003 } 1004 return valobj_sp; 1005 } 1006 else 1007 { 1008 error.SetErrorStringWithFormat("no variable named '%s' found in this frame", 1009 name_const_string.GetCString()); 1010 } 1011 } 1012 } 1013 else 1014 { 1015 error.SetErrorStringWithFormat("invalid variable path '%s'", var_expr_cstr); 1016 } 1017 return ValueObjectSP(); 1018 } 1019 1020 bool 1021 StackFrame::GetFrameBaseValue (Scalar &frame_base, Error *error_ptr) 1022 { 1023 if (m_flags.IsClear(GOT_FRAME_BASE)) 1024 { 1025 if (m_sc.function) 1026 { 1027 m_frame_base.Clear(); 1028 m_frame_base_error.Clear(); 1029 1030 m_flags.Set(GOT_FRAME_BASE); 1031 ExecutionContext exe_ctx (&m_thread.GetProcess(), &m_thread, this); 1032 Value expr_value; 1033 addr_t loclist_base_addr = LLDB_INVALID_ADDRESS; 1034 if (m_sc.function->GetFrameBaseExpression().IsLocationList()) 1035 loclist_base_addr = m_sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress (&m_thread.GetProcess().GetTarget()); 1036 1037 if (m_sc.function->GetFrameBaseExpression().Evaluate(&exe_ctx, NULL, NULL, NULL, NULL, loclist_base_addr, NULL, expr_value, &m_frame_base_error) == false) 1038 { 1039 // We should really have an error if evaluate returns, but in case 1040 // we don't, lets set the error to something at least. 1041 if (m_frame_base_error.Success()) 1042 m_frame_base_error.SetErrorString("Evaluation of the frame base expression failed."); 1043 } 1044 else 1045 { 1046 m_frame_base = expr_value.ResolveValue(&exe_ctx, NULL); 1047 } 1048 } 1049 else 1050 { 1051 m_frame_base_error.SetErrorString ("No function in symbol context."); 1052 } 1053 } 1054 1055 if (m_frame_base_error.Success()) 1056 frame_base = m_frame_base; 1057 1058 if (error_ptr) 1059 *error_ptr = m_frame_base_error; 1060 return m_frame_base_error.Success(); 1061 } 1062 1063 RegisterContextSP 1064 StackFrame::GetRegisterContext () 1065 { 1066 if (!m_reg_context_sp) 1067 m_reg_context_sp = m_thread.CreateRegisterContextForFrame (this); 1068 return m_reg_context_sp; 1069 } 1070 1071 bool 1072 StackFrame::HasDebugInformation () 1073 { 1074 GetSymbolContext (eSymbolContextLineEntry); 1075 return m_sc.line_entry.IsValid(); 1076 } 1077 1078 1079 ValueObjectSP 1080 StackFrame::GetValueObjectForFrameVariable (const VariableSP &variable_sp, lldb::DynamicValueType use_dynamic) 1081 { 1082 ValueObjectSP valobj_sp; 1083 VariableList *var_list = GetVariableList (true); 1084 if (var_list) 1085 { 1086 // Make sure the variable is a frame variable 1087 const uint32_t var_idx = var_list->FindIndexForVariable (variable_sp.get()); 1088 const uint32_t num_variables = var_list->GetSize(); 1089 if (var_idx < num_variables) 1090 { 1091 valobj_sp = m_variable_list_value_objects.GetValueObjectAtIndex (var_idx); 1092 if (valobj_sp.get() == NULL) 1093 { 1094 if (m_variable_list_value_objects.GetSize() < num_variables) 1095 m_variable_list_value_objects.Resize(num_variables); 1096 valobj_sp = ValueObjectVariable::Create (this, variable_sp); 1097 m_variable_list_value_objects.SetValueObjectAtIndex (var_idx, valobj_sp); 1098 } 1099 } 1100 } 1101 if (use_dynamic != lldb::eNoDynamicValues && valobj_sp) 1102 { 1103 ValueObjectSP dynamic_sp = valobj_sp->GetDynamicValue (use_dynamic); 1104 if (dynamic_sp) 1105 return dynamic_sp; 1106 } 1107 return valobj_sp; 1108 } 1109 1110 ValueObjectSP 1111 StackFrame::TrackGlobalVariable (const VariableSP &variable_sp, lldb::DynamicValueType use_dynamic) 1112 { 1113 // Check to make sure we aren't already tracking this variable? 1114 ValueObjectSP valobj_sp (GetValueObjectForFrameVariable (variable_sp, use_dynamic)); 1115 if (!valobj_sp) 1116 { 1117 // We aren't already tracking this global 1118 VariableList *var_list = GetVariableList (true); 1119 // If this frame has no variables, create a new list 1120 if (var_list == NULL) 1121 m_variable_list_sp.reset (new VariableList()); 1122 1123 // Add the global/static variable to this frame 1124 m_variable_list_sp->AddVariable (variable_sp); 1125 1126 // Now make a value object for it so we can track its changes 1127 valobj_sp = GetValueObjectForFrameVariable (variable_sp, use_dynamic); 1128 } 1129 return valobj_sp; 1130 } 1131 1132 bool 1133 StackFrame::IsInlined () 1134 { 1135 if (m_sc.block == NULL) 1136 GetSymbolContext (eSymbolContextBlock); 1137 if (m_sc.block) 1138 return m_sc.block->GetContainingInlinedBlock() != NULL; 1139 return false; 1140 } 1141 1142 Target * 1143 StackFrame::CalculateTarget () 1144 { 1145 return m_thread.CalculateTarget(); 1146 } 1147 1148 Process * 1149 StackFrame::CalculateProcess () 1150 { 1151 return m_thread.CalculateProcess(); 1152 } 1153 1154 Thread * 1155 StackFrame::CalculateThread () 1156 { 1157 return &m_thread; 1158 } 1159 1160 StackFrame * 1161 StackFrame::CalculateStackFrame () 1162 { 1163 return this; 1164 } 1165 1166 1167 void 1168 StackFrame::CalculateExecutionContext (ExecutionContext &exe_ctx) 1169 { 1170 m_thread.CalculateExecutionContext (exe_ctx); 1171 exe_ctx.frame = this; 1172 } 1173 1174 void 1175 StackFrame::DumpUsingSettingsFormat (Stream *strm) 1176 { 1177 if (strm == NULL) 1178 return; 1179 1180 GetSymbolContext(eSymbolContextEverything); 1181 ExecutionContext exe_ctx; 1182 CalculateExecutionContext(exe_ctx); 1183 const char *end = NULL; 1184 StreamString s; 1185 const char *frame_format = m_thread.GetProcess().GetTarget().GetDebugger().GetFrameFormat(); 1186 if (frame_format && Debugger::FormatPrompt (frame_format, &m_sc, &exe_ctx, NULL, s, &end)) 1187 { 1188 strm->Write(s.GetData(), s.GetSize()); 1189 } 1190 else 1191 { 1192 Dump (strm, true, false); 1193 strm->EOL(); 1194 } 1195 } 1196 1197 void 1198 StackFrame::Dump (Stream *strm, bool show_frame_index, bool show_fullpaths) 1199 { 1200 if (strm == NULL) 1201 return; 1202 1203 if (show_frame_index) 1204 strm->Printf("frame #%u: ", m_frame_index); 1205 strm->Printf("0x%0*llx ", m_thread.GetProcess().GetTarget().GetArchitecture().GetAddressByteSize() * 2, GetFrameCodeAddress().GetLoadAddress(&m_thread.GetProcess().GetTarget())); 1206 GetSymbolContext(eSymbolContextEverything); 1207 const bool show_module = true; 1208 const bool show_inline = true; 1209 m_sc.DumpStopContext(strm, &m_thread.GetProcess(), GetFrameCodeAddress(), show_fullpaths, show_module, show_inline); 1210 } 1211 1212 void 1213 StackFrame::UpdateCurrentFrameFromPreviousFrame (StackFrame &prev_frame) 1214 { 1215 assert (GetStackID() == prev_frame.GetStackID()); // TODO: remove this after some testing 1216 m_variable_list_sp = prev_frame.m_variable_list_sp; 1217 m_variable_list_value_objects.Swap (prev_frame.m_variable_list_value_objects); 1218 if (!m_disassembly.GetString().empty()) 1219 m_disassembly.GetString().swap (m_disassembly.GetString()); 1220 } 1221 1222 1223 void 1224 StackFrame::UpdatePreviousFrameFromCurrentFrame (StackFrame &curr_frame) 1225 { 1226 assert (GetStackID() == curr_frame.GetStackID()); // TODO: remove this after some testing 1227 m_id.SetPC (curr_frame.m_id.GetPC()); // Update the Stack ID PC value 1228 assert (&m_thread == &curr_frame.m_thread); 1229 m_frame_index = curr_frame.m_frame_index; 1230 m_concrete_frame_index = curr_frame.m_concrete_frame_index; 1231 m_reg_context_sp = curr_frame.m_reg_context_sp; 1232 m_frame_code_addr = curr_frame.m_frame_code_addr; 1233 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()); 1234 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()); 1235 assert (m_sc.comp_unit == NULL || curr_frame.m_sc.comp_unit == NULL || m_sc.comp_unit == curr_frame.m_sc.comp_unit); 1236 assert (m_sc.function == NULL || curr_frame.m_sc.function == NULL || m_sc.function == curr_frame.m_sc.function); 1237 m_sc = curr_frame.m_sc; 1238 m_flags.Clear(GOT_FRAME_BASE | eSymbolContextEverything); 1239 m_flags.Set (m_sc.GetResolvedMask()); 1240 m_frame_base.Clear(); 1241 m_frame_base_error.Clear(); 1242 } 1243 1244 1245 bool 1246 StackFrame::HasCachedData () const 1247 { 1248 if (m_variable_list_sp.get()) 1249 return true; 1250 if (m_variable_list_value_objects.GetSize() > 0) 1251 return true; 1252 if (!m_disassembly.GetString().empty()) 1253 return true; 1254 return false; 1255 } 1256 1257 lldb::StackFrameSP 1258 StackFrame::GetSP () 1259 { 1260 return m_thread.GetStackFrameSPForStackFramePtr (this); 1261 } 1262 1263 1264 1265 bool 1266 StackFrame::GetStatus (Stream& strm, 1267 bool show_frame_info, 1268 bool show_source, 1269 uint32_t source_lines_before, 1270 uint32_t source_lines_after) 1271 { 1272 if (show_frame_info) 1273 { 1274 strm.Indent(); 1275 DumpUsingSettingsFormat (&strm); 1276 } 1277 1278 if (show_source) 1279 { 1280 GetSymbolContext(eSymbolContextCompUnit | eSymbolContextLineEntry); 1281 1282 if (m_sc.comp_unit && m_sc.line_entry.IsValid()) 1283 { 1284 Target &target = GetThread().GetProcess().GetTarget(); 1285 target.GetSourceManager().DisplaySourceLinesWithLineNumbers ( 1286 m_sc.line_entry.file, 1287 m_sc.line_entry.line, 1288 3, 1289 3, 1290 "->", 1291 &strm); 1292 1293 } 1294 } 1295 return true; 1296 } 1297 1298