1 //===-- ValueObject.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/Core/ValueObject.h" 11 12 // C Includes 13 #include <stdlib.h> 14 15 // C++ Includes 16 // Other libraries and framework includes 17 #include "llvm/Support/raw_ostream.h" 18 #include "clang/AST/Type.h" 19 20 // Project includes 21 #include "lldb/Core/DataBufferHeap.h" 22 #include "lldb/Core/DataVisualization.h" 23 #include "lldb/Core/Debugger.h" 24 #include "lldb/Core/Log.h" 25 #include "lldb/Core/StreamString.h" 26 #include "lldb/Core/ValueObjectChild.h" 27 #include "lldb/Core/ValueObjectConstResult.h" 28 #include "lldb/Core/ValueObjectDynamicValue.h" 29 #include "lldb/Core/ValueObjectList.h" 30 #include "lldb/Core/ValueObjectMemory.h" 31 #include "lldb/Core/ValueObjectSyntheticFilter.h" 32 33 #include "lldb/Host/Endian.h" 34 35 #include "lldb/Interpreter/CommandInterpreter.h" 36 #include "lldb/Interpreter/ScriptInterpreterPython.h" 37 38 #include "lldb/Symbol/ClangASTType.h" 39 #include "lldb/Symbol/ClangASTContext.h" 40 #include "lldb/Symbol/Type.h" 41 42 #include "lldb/Target/ExecutionContext.h" 43 #include "lldb/Target/LanguageRuntime.h" 44 #include "lldb/Target/ObjCLanguageRuntime.h" 45 #include "lldb/Target/Process.h" 46 #include "lldb/Target/RegisterContext.h" 47 #include "lldb/Target/Target.h" 48 #include "lldb/Target/Thread.h" 49 50 #include "lldb/Utility/RefCounter.h" 51 52 using namespace lldb; 53 using namespace lldb_private; 54 using namespace lldb_utility; 55 56 static user_id_t g_value_obj_uid = 0; 57 58 //---------------------------------------------------------------------- 59 // ValueObject constructor 60 //---------------------------------------------------------------------- 61 ValueObject::ValueObject (ValueObject &parent) : 62 UserID (++g_value_obj_uid), // Unique identifier for every value object 63 m_parent (&parent), 64 m_update_point (parent.GetUpdatePoint ()), 65 m_name (), 66 m_data (), 67 m_value (), 68 m_error (), 69 m_value_str (), 70 m_old_value_str (), 71 m_location_str (), 72 m_summary_str (), 73 m_object_desc_str (), 74 m_manager(parent.GetManager()), 75 m_children (), 76 m_synthetic_children (), 77 m_dynamic_value (NULL), 78 m_synthetic_value(NULL), 79 m_deref_valobj(NULL), 80 m_format (eFormatDefault), 81 m_last_format_mgr_revision(0), 82 m_last_format_mgr_dynamic(parent.m_last_format_mgr_dynamic), 83 m_type_summary_sp(), 84 m_type_format_sp(), 85 m_synthetic_children_sp(), 86 m_user_id_of_forced_summary(), 87 m_address_type_of_ptr_or_ref_children(eAddressTypeInvalid), 88 m_value_is_valid (false), 89 m_value_did_change (false), 90 m_children_count_valid (false), 91 m_old_value_valid (false), 92 m_is_deref_of_parent (false), 93 m_is_array_item_for_pointer(false), 94 m_is_bitfield_for_scalar(false), 95 m_is_expression_path_child(false), 96 m_is_child_at_offset(false), 97 m_is_getting_summary(false), 98 m_did_calculate_complete_objc_class_type(false) 99 { 100 m_manager->ManageObject(this); 101 } 102 103 //---------------------------------------------------------------------- 104 // ValueObject constructor 105 //---------------------------------------------------------------------- 106 ValueObject::ValueObject (ExecutionContextScope *exe_scope, 107 AddressType child_ptr_or_ref_addr_type) : 108 UserID (++g_value_obj_uid), // Unique identifier for every value object 109 m_parent (NULL), 110 m_update_point (exe_scope), 111 m_name (), 112 m_data (), 113 m_value (), 114 m_error (), 115 m_value_str (), 116 m_old_value_str (), 117 m_location_str (), 118 m_summary_str (), 119 m_object_desc_str (), 120 m_manager(), 121 m_children (), 122 m_synthetic_children (), 123 m_dynamic_value (NULL), 124 m_synthetic_value(NULL), 125 m_deref_valobj(NULL), 126 m_format (eFormatDefault), 127 m_last_format_mgr_revision(0), 128 m_last_format_mgr_dynamic(eNoDynamicValues), 129 m_type_summary_sp(), 130 m_type_format_sp(), 131 m_synthetic_children_sp(), 132 m_user_id_of_forced_summary(), 133 m_address_type_of_ptr_or_ref_children(child_ptr_or_ref_addr_type), 134 m_value_is_valid (false), 135 m_value_did_change (false), 136 m_children_count_valid (false), 137 m_old_value_valid (false), 138 m_is_deref_of_parent (false), 139 m_is_array_item_for_pointer(false), 140 m_is_bitfield_for_scalar(false), 141 m_is_expression_path_child(false), 142 m_is_child_at_offset(false), 143 m_is_getting_summary(false), 144 m_did_calculate_complete_objc_class_type(false) 145 { 146 m_manager = new ValueObjectManager(); 147 m_manager->ManageObject (this); 148 } 149 150 //---------------------------------------------------------------------- 151 // Destructor 152 //---------------------------------------------------------------------- 153 ValueObject::~ValueObject () 154 { 155 } 156 157 bool 158 ValueObject::UpdateValueIfNeeded (bool update_format) 159 { 160 return UpdateValueIfNeeded(m_last_format_mgr_dynamic, update_format); 161 } 162 163 bool 164 ValueObject::UpdateValueIfNeeded (DynamicValueType use_dynamic, bool update_format) 165 { 166 167 bool did_change_formats = false; 168 169 if (update_format) 170 did_change_formats = UpdateFormatsIfNeeded(use_dynamic); 171 172 // If this is a constant value, then our success is predicated on whether 173 // we have an error or not 174 if (GetIsConstant()) 175 { 176 // if you were asked to update your formatters, but did not get a chance to do it 177 // clear your own values (this serves the purpose of faking a stop-id for frozen 178 // objects (which are regarded as constant, but could have changes behind their backs 179 // because of the frozen-pointer depth limit) 180 // TODO: decouple summary from value and then remove this code and only force-clear the summary 181 if (update_format && !did_change_formats) 182 m_summary_str.clear(); 183 return m_error.Success(); 184 } 185 186 bool first_update = m_update_point.IsFirstEvaluation(); 187 188 if (m_update_point.NeedsUpdating()) 189 { 190 m_update_point.SetUpdated(); 191 192 // Save the old value using swap to avoid a string copy which 193 // also will clear our m_value_str 194 if (m_value_str.empty()) 195 { 196 m_old_value_valid = false; 197 } 198 else 199 { 200 m_old_value_valid = true; 201 m_old_value_str.swap (m_value_str); 202 m_value_str.clear(); 203 } 204 205 ClearUserVisibleData(); 206 207 if (IsInScope()) 208 { 209 const bool value_was_valid = GetValueIsValid(); 210 SetValueDidChange (false); 211 212 m_error.Clear(); 213 214 // Call the pure virtual function to update the value 215 bool success = UpdateValue (); 216 217 SetValueIsValid (success); 218 219 if (first_update) 220 SetValueDidChange (false); 221 else if (!m_value_did_change && success == false) 222 { 223 // The value wasn't gotten successfully, so we mark this 224 // as changed if the value used to be valid and now isn't 225 SetValueDidChange (value_was_valid); 226 } 227 } 228 else 229 { 230 m_error.SetErrorString("out of scope"); 231 } 232 } 233 return m_error.Success(); 234 } 235 236 bool 237 ValueObject::UpdateFormatsIfNeeded(DynamicValueType use_dynamic) 238 { 239 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES)); 240 if (log) 241 log->Printf("checking for FormatManager revisions. VO named %s is at revision %d, while the format manager is at revision %d", 242 GetName().GetCString(), 243 m_last_format_mgr_revision, 244 DataVisualization::GetCurrentRevision()); 245 246 bool any_change = false; 247 248 if ( (m_last_format_mgr_revision != DataVisualization::GetCurrentRevision()) || 249 m_last_format_mgr_dynamic != use_dynamic) 250 { 251 SetValueFormat(DataVisualization::ValueFormats::GetFormat (*this, eNoDynamicValues)); 252 SetSummaryFormat(DataVisualization::GetSummaryFormat (*this, use_dynamic)); 253 SetSyntheticChildren(DataVisualization::GetSyntheticChildren (*this, use_dynamic)); 254 255 m_last_format_mgr_revision = DataVisualization::GetCurrentRevision(); 256 m_last_format_mgr_dynamic = use_dynamic; 257 258 any_change = true; 259 } 260 261 return any_change; 262 263 } 264 265 void 266 ValueObject::SetNeedsUpdate () 267 { 268 m_update_point.SetNeedsUpdate(); 269 // We have to clear the value string here so ConstResult children will notice if their values are 270 // changed by hand (i.e. with SetValueAsCString). 271 m_value_str.clear(); 272 } 273 274 ClangASTType 275 ValueObject::MaybeCalculateCompleteType () 276 { 277 ClangASTType ret(GetClangASTImpl(), GetClangTypeImpl()); 278 279 if (m_did_calculate_complete_objc_class_type) 280 { 281 if (m_override_type.IsValid()) 282 return m_override_type; 283 else 284 return ret; 285 } 286 287 clang_type_t ast_type(GetClangTypeImpl()); 288 clang_type_t class_type; 289 bool is_pointer_type; 290 291 if (ClangASTContext::IsObjCObjectPointerType(ast_type, &class_type)) 292 { 293 is_pointer_type = true; 294 } 295 else if (ClangASTContext::IsObjCClassType(ast_type)) 296 { 297 is_pointer_type = false; 298 class_type = ast_type; 299 } 300 else 301 { 302 return ret; 303 } 304 305 m_did_calculate_complete_objc_class_type = true; 306 307 if (!class_type) 308 return ret; 309 310 std::string class_name; 311 312 if (!ClangASTContext::GetObjCClassName(class_type, class_name)) 313 return ret; 314 315 ProcessSP process_sp(GetUpdatePoint().GetExecutionContextRef().GetProcessSP()); 316 317 if (!process_sp) 318 return ret; 319 320 ObjCLanguageRuntime *objc_language_runtime(process_sp->GetObjCLanguageRuntime()); 321 322 if (!objc_language_runtime) 323 return ret; 324 325 ConstString class_name_cs(class_name.c_str()); 326 327 TypeSP complete_objc_class_type_sp = objc_language_runtime->LookupInCompleteClassCache(class_name_cs); 328 329 if (!complete_objc_class_type_sp) 330 return ret; 331 332 ClangASTType complete_class(complete_objc_class_type_sp->GetClangAST(), 333 complete_objc_class_type_sp->GetClangFullType()); 334 335 if (!ClangASTContext::GetCompleteType(complete_class.GetASTContext(), 336 complete_class.GetOpaqueQualType())) 337 return ret; 338 339 if (is_pointer_type) 340 { 341 clang_type_t pointer_type = ClangASTContext::CreatePointerType(complete_class.GetASTContext(), 342 complete_class.GetOpaqueQualType()); 343 344 m_override_type = ClangASTType(complete_class.GetASTContext(), 345 pointer_type); 346 } 347 else 348 { 349 m_override_type = complete_class; 350 } 351 352 return m_override_type; 353 } 354 355 clang::ASTContext * 356 ValueObject::GetClangAST () 357 { 358 ClangASTType type = MaybeCalculateCompleteType(); 359 360 return type.GetASTContext(); 361 } 362 363 lldb::clang_type_t 364 ValueObject::GetClangType () 365 { 366 ClangASTType type = MaybeCalculateCompleteType(); 367 368 return type.GetOpaqueQualType(); 369 } 370 371 DataExtractor & 372 ValueObject::GetDataExtractor () 373 { 374 UpdateValueIfNeeded(false); 375 return m_data; 376 } 377 378 const Error & 379 ValueObject::GetError() 380 { 381 UpdateValueIfNeeded(false); 382 return m_error; 383 } 384 385 const ConstString & 386 ValueObject::GetName() const 387 { 388 return m_name; 389 } 390 391 const char * 392 ValueObject::GetLocationAsCString () 393 { 394 if (UpdateValueIfNeeded(false)) 395 { 396 if (m_location_str.empty()) 397 { 398 StreamString sstr; 399 400 switch (m_value.GetValueType()) 401 { 402 default: 403 break; 404 405 case Value::eValueTypeScalar: 406 if (m_value.GetContextType() == Value::eContextTypeRegisterInfo) 407 { 408 RegisterInfo *reg_info = m_value.GetRegisterInfo(); 409 if (reg_info) 410 { 411 if (reg_info->name) 412 m_location_str = reg_info->name; 413 else if (reg_info->alt_name) 414 m_location_str = reg_info->alt_name; 415 break; 416 } 417 } 418 m_location_str = "scalar"; 419 break; 420 421 case Value::eValueTypeLoadAddress: 422 case Value::eValueTypeFileAddress: 423 case Value::eValueTypeHostAddress: 424 { 425 uint32_t addr_nibble_size = m_data.GetAddressByteSize() * 2; 426 sstr.Printf("0x%*.*llx", addr_nibble_size, addr_nibble_size, m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS)); 427 m_location_str.swap(sstr.GetString()); 428 } 429 break; 430 } 431 } 432 } 433 return m_location_str.c_str(); 434 } 435 436 Value & 437 ValueObject::GetValue() 438 { 439 return m_value; 440 } 441 442 const Value & 443 ValueObject::GetValue() const 444 { 445 return m_value; 446 } 447 448 bool 449 ValueObject::ResolveValue (Scalar &scalar) 450 { 451 if (UpdateValueIfNeeded(false)) // make sure that you are up to date before returning anything 452 { 453 ExecutionContext exe_ctx (GetExecutionContextRef()); 454 Value tmp_value(m_value); 455 scalar = tmp_value.ResolveValue(&exe_ctx, GetClangAST ()); 456 if (scalar.IsValid()) 457 { 458 const uint32_t bitfield_bit_size = GetBitfieldBitSize(); 459 if (bitfield_bit_size) 460 return scalar.ExtractBitfield (bitfield_bit_size, GetBitfieldBitOffset()); 461 return true; 462 } 463 } 464 return false; 465 } 466 467 bool 468 ValueObject::GetValueIsValid () const 469 { 470 return m_value_is_valid; 471 } 472 473 474 void 475 ValueObject::SetValueIsValid (bool b) 476 { 477 m_value_is_valid = b; 478 } 479 480 bool 481 ValueObject::GetValueDidChange () 482 { 483 GetValueAsCString (); 484 return m_value_did_change; 485 } 486 487 void 488 ValueObject::SetValueDidChange (bool value_changed) 489 { 490 m_value_did_change = value_changed; 491 } 492 493 ValueObjectSP 494 ValueObject::GetChildAtIndex (uint32_t idx, bool can_create) 495 { 496 ValueObjectSP child_sp; 497 // We may need to update our value if we are dynamic 498 if (IsPossibleDynamicType ()) 499 UpdateValueIfNeeded(false); 500 if (idx < GetNumChildren()) 501 { 502 // Check if we have already made the child value object? 503 if (can_create && !m_children.HasChildAtIndex(idx)) 504 { 505 // No we haven't created the child at this index, so lets have our 506 // subclass do it and cache the result for quick future access. 507 m_children.SetChildAtIndex(idx,CreateChildAtIndex (idx, false, 0)); 508 } 509 510 ValueObject* child = m_children.GetChildAtIndex(idx); 511 if (child != NULL) 512 return child->GetSP(); 513 } 514 return child_sp; 515 } 516 517 uint32_t 518 ValueObject::GetIndexOfChildWithName (const ConstString &name) 519 { 520 bool omit_empty_base_classes = true; 521 return ClangASTContext::GetIndexOfChildWithName (GetClangAST(), 522 GetClangType(), 523 name.GetCString(), 524 omit_empty_base_classes); 525 } 526 527 ValueObjectSP 528 ValueObject::GetChildMemberWithName (const ConstString &name, bool can_create) 529 { 530 // when getting a child by name, it could be buried inside some base 531 // classes (which really aren't part of the expression path), so we 532 // need a vector of indexes that can get us down to the correct child 533 ValueObjectSP child_sp; 534 535 // We may need to update our value if we are dynamic 536 if (IsPossibleDynamicType ()) 537 UpdateValueIfNeeded(false); 538 539 std::vector<uint32_t> child_indexes; 540 clang::ASTContext *clang_ast = GetClangAST(); 541 void *clang_type = GetClangType(); 542 bool omit_empty_base_classes = true; 543 const size_t num_child_indexes = ClangASTContext::GetIndexOfChildMemberWithName (clang_ast, 544 clang_type, 545 name.GetCString(), 546 omit_empty_base_classes, 547 child_indexes); 548 if (num_child_indexes > 0) 549 { 550 std::vector<uint32_t>::const_iterator pos = child_indexes.begin (); 551 std::vector<uint32_t>::const_iterator end = child_indexes.end (); 552 553 child_sp = GetChildAtIndex(*pos, can_create); 554 for (++pos; pos != end; ++pos) 555 { 556 if (child_sp) 557 { 558 ValueObjectSP new_child_sp(child_sp->GetChildAtIndex (*pos, can_create)); 559 child_sp = new_child_sp; 560 } 561 else 562 { 563 child_sp.reset(); 564 } 565 566 } 567 } 568 return child_sp; 569 } 570 571 572 uint32_t 573 ValueObject::GetNumChildren () 574 { 575 if (!m_children_count_valid) 576 { 577 SetNumChildren (CalculateNumChildren()); 578 } 579 return m_children.GetChildrenCount(); 580 } 581 void 582 ValueObject::SetNumChildren (uint32_t num_children) 583 { 584 m_children_count_valid = true; 585 m_children.SetChildrenCount(num_children); 586 } 587 588 void 589 ValueObject::SetName (const ConstString &name) 590 { 591 m_name = name; 592 } 593 594 ValueObject * 595 ValueObject::CreateChildAtIndex (uint32_t idx, bool synthetic_array_member, int32_t synthetic_index) 596 { 597 ValueObject *valobj = NULL; 598 599 bool omit_empty_base_classes = true; 600 bool ignore_array_bounds = synthetic_array_member; 601 std::string child_name_str; 602 uint32_t child_byte_size = 0; 603 int32_t child_byte_offset = 0; 604 uint32_t child_bitfield_bit_size = 0; 605 uint32_t child_bitfield_bit_offset = 0; 606 bool child_is_base_class = false; 607 bool child_is_deref_of_parent = false; 608 609 const bool transparent_pointers = synthetic_array_member == false; 610 clang::ASTContext *clang_ast = GetClangAST(); 611 clang_type_t clang_type = GetClangType(); 612 clang_type_t child_clang_type; 613 614 ExecutionContext exe_ctx (GetExecutionContextRef()); 615 616 child_clang_type = ClangASTContext::GetChildClangTypeAtIndex (&exe_ctx, 617 clang_ast, 618 GetName().GetCString(), 619 clang_type, 620 idx, 621 transparent_pointers, 622 omit_empty_base_classes, 623 ignore_array_bounds, 624 child_name_str, 625 child_byte_size, 626 child_byte_offset, 627 child_bitfield_bit_size, 628 child_bitfield_bit_offset, 629 child_is_base_class, 630 child_is_deref_of_parent); 631 if (child_clang_type && child_byte_size) 632 { 633 if (synthetic_index) 634 child_byte_offset += child_byte_size * synthetic_index; 635 636 ConstString child_name; 637 if (!child_name_str.empty()) 638 child_name.SetCString (child_name_str.c_str()); 639 640 valobj = new ValueObjectChild (*this, 641 clang_ast, 642 child_clang_type, 643 child_name, 644 child_byte_size, 645 child_byte_offset, 646 child_bitfield_bit_size, 647 child_bitfield_bit_offset, 648 child_is_base_class, 649 child_is_deref_of_parent, 650 eAddressTypeInvalid); 651 //if (valobj) 652 // valobj->SetAddressTypeOfChildren(eAddressTypeInvalid); 653 } 654 655 return valobj; 656 } 657 658 bool 659 ValueObject::GetSummaryAsCString (TypeSummaryImpl* summary_ptr, 660 std::string& destination) 661 { 662 destination.clear(); 663 664 // ideally we would like to bail out if passing NULL, but if we do so 665 // we end up not providing the summary for function pointers anymore 666 if (/*summary_ptr == NULL ||*/ m_is_getting_summary) 667 return false; 668 669 m_is_getting_summary = true; 670 if (UpdateValueIfNeeded (false)) 671 { 672 if (summary_ptr) 673 { 674 summary_ptr->FormatObject(GetSP(), destination); 675 } 676 else 677 { 678 clang_type_t clang_type = GetClangType(); 679 680 // Do some default printout for function pointers 681 if (clang_type) 682 { 683 StreamString sstr; 684 clang_type_t elem_or_pointee_clang_type; 685 const Flags type_flags (ClangASTContext::GetTypeInfo (clang_type, 686 GetClangAST(), 687 &elem_or_pointee_clang_type)); 688 689 if (ClangASTContext::IsFunctionPointerType (clang_type)) 690 { 691 AddressType func_ptr_address_type = eAddressTypeInvalid; 692 addr_t func_ptr_address = GetPointerValue (&func_ptr_address_type); 693 if (func_ptr_address != 0 && func_ptr_address != LLDB_INVALID_ADDRESS) 694 { 695 switch (func_ptr_address_type) 696 { 697 case eAddressTypeInvalid: 698 case eAddressTypeFile: 699 break; 700 701 case eAddressTypeLoad: 702 { 703 ExecutionContext exe_ctx (GetExecutionContextRef()); 704 705 Address so_addr; 706 Target *target = exe_ctx.GetTargetPtr(); 707 if (target && target->GetSectionLoadList().IsEmpty() == false) 708 { 709 if (target->GetSectionLoadList().ResolveLoadAddress(func_ptr_address, so_addr)) 710 { 711 so_addr.Dump (&sstr, 712 exe_ctx.GetBestExecutionContextScope(), 713 Address::DumpStyleResolvedDescription, 714 Address::DumpStyleSectionNameOffset); 715 } 716 } 717 } 718 break; 719 720 case eAddressTypeHost: 721 break; 722 } 723 } 724 if (sstr.GetSize() > 0) 725 { 726 destination.assign (1, '('); 727 destination.append (sstr.GetData(), sstr.GetSize()); 728 destination.append (1, ')'); 729 } 730 } 731 } 732 } 733 } 734 m_is_getting_summary = false; 735 return !destination.empty(); 736 } 737 738 const char * 739 ValueObject::GetSummaryAsCString () 740 { 741 if (UpdateValueIfNeeded(true) && m_summary_str.empty()) 742 { 743 GetSummaryAsCString(GetSummaryFormat().get(), 744 m_summary_str); 745 } 746 if (m_summary_str.empty()) 747 return NULL; 748 return m_summary_str.c_str(); 749 } 750 751 bool 752 ValueObject::IsCStringContainer(bool check_pointer) 753 { 754 clang_type_t elem_or_pointee_clang_type; 755 const Flags type_flags (ClangASTContext::GetTypeInfo (GetClangType(), 756 GetClangAST(), 757 &elem_or_pointee_clang_type)); 758 bool is_char_arr_ptr (type_flags.AnySet (ClangASTContext::eTypeIsArray | ClangASTContext::eTypeIsPointer) && 759 ClangASTContext::IsCharType (elem_or_pointee_clang_type)); 760 if (!is_char_arr_ptr) 761 return false; 762 if (!check_pointer) 763 return true; 764 if (type_flags.Test(ClangASTContext::eTypeIsArray)) 765 return true; 766 addr_t cstr_address = LLDB_INVALID_ADDRESS; 767 AddressType cstr_address_type = eAddressTypeInvalid; 768 cstr_address = GetAddressOf (true, &cstr_address_type); 769 return (cstr_address != LLDB_INVALID_ADDRESS); 770 } 771 772 size_t 773 ValueObject::GetPointeeData (DataExtractor& data, 774 uint32_t item_idx, 775 uint32_t item_count) 776 { 777 if (!IsPointerType() && !IsArrayType()) 778 return 0; 779 780 if (item_count == 0) 781 return 0; 782 783 uint32_t stride = 0; 784 785 ClangASTType type(GetClangAST(), 786 GetClangType()); 787 788 const uint64_t item_type_size = (IsPointerType() ? ClangASTType::GetTypeByteSize(GetClangAST(), type.GetPointeeType()) : 789 ClangASTType::GetTypeByteSize(GetClangAST(), type.GetArrayElementType(stride))); 790 791 const uint64_t bytes = item_count * item_type_size; 792 793 const uint64_t offset = item_idx * item_type_size; 794 795 if (item_idx == 0 && item_count == 1) // simply a deref 796 { 797 if (IsPointerType()) 798 { 799 Error error; 800 ValueObjectSP pointee_sp = Dereference(error); 801 if (error.Fail() || pointee_sp.get() == NULL) 802 return 0; 803 return pointee_sp->GetDataExtractor().Copy(data); 804 } 805 else 806 { 807 ValueObjectSP child_sp = GetChildAtIndex(0, true); 808 if (child_sp.get() == NULL) 809 return 0; 810 return child_sp->GetDataExtractor().Copy(data); 811 } 812 return true; 813 } 814 else /* (items > 1) */ 815 { 816 Error error; 817 lldb_private::DataBufferHeap* heap_buf_ptr = NULL; 818 lldb::DataBufferSP data_sp(heap_buf_ptr = new lldb_private::DataBufferHeap()); 819 820 AddressType addr_type; 821 lldb::addr_t addr = IsPointerType() ? GetPointerValue(&addr_type) : GetAddressOf(true, &addr_type); 822 823 switch (addr_type) 824 { 825 case eAddressTypeFile: 826 { 827 ModuleSP module_sp (GetModule()); 828 if (module_sp) 829 { 830 Address so_addr; 831 module_sp->ResolveFileAddress(addr, so_addr); 832 ExecutionContext exe_ctx (GetExecutionContextRef()); 833 Target* target = exe_ctx.GetTargetPtr(); 834 if (target) 835 { 836 heap_buf_ptr->SetByteSize(bytes); 837 size_t bytes_read = target->ReadMemory(so_addr, false, heap_buf_ptr->GetBytes(), bytes, error); 838 if (error.Success()) 839 { 840 data.SetData(data_sp); 841 return bytes_read; 842 } 843 } 844 } 845 } 846 break; 847 case eAddressTypeLoad: 848 { 849 ExecutionContext exe_ctx (GetExecutionContextRef()); 850 Process *process = exe_ctx.GetProcessPtr(); 851 if (process) 852 { 853 heap_buf_ptr->SetByteSize(bytes); 854 size_t bytes_read = process->ReadMemory(addr + offset, heap_buf_ptr->GetBytes(), bytes, error); 855 if (error.Success()) 856 { 857 data.SetData(data_sp); 858 return bytes_read; 859 } 860 } 861 } 862 break; 863 case eAddressTypeHost: 864 { 865 heap_buf_ptr->CopyData((uint8_t*)(addr + offset), bytes); 866 data.SetData(data_sp); 867 return bytes; 868 } 869 break; 870 case eAddressTypeInvalid: 871 default: 872 break; 873 } 874 } 875 return 0; 876 } 877 878 size_t 879 ValueObject::GetData (DataExtractor& data) 880 { 881 UpdateValueIfNeeded(false); 882 ExecutionContext exe_ctx (GetExecutionContextRef()); 883 Error error = m_value.GetValueAsData(&exe_ctx, GetClangAST(), data, 0, GetModule().get()); 884 if (error.Fail()) 885 return 0; 886 data.SetAddressByteSize(m_data.GetAddressByteSize()); 887 data.SetByteOrder(m_data.GetByteOrder()); 888 return data.GetByteSize(); 889 } 890 891 // will compute strlen(str), but without consuming more than 892 // maxlen bytes out of str (this serves the purpose of reading 893 // chunks of a string without having to worry about 894 // missing NULL terminators in the chunk) 895 // of course, if strlen(str) > maxlen, the function will return 896 // maxlen_value (which should be != maxlen, because that allows you 897 // to know whether strlen(str) == maxlen or strlen(str) > maxlen) 898 static uint32_t 899 strlen_or_inf (const char* str, 900 uint32_t maxlen, 901 uint32_t maxlen_value) 902 { 903 uint32_t len = 0; 904 if (str) 905 { 906 while(*str) 907 { 908 len++;str++; 909 if (len > maxlen) 910 return maxlen_value; 911 } 912 } 913 return len; 914 } 915 916 void 917 ValueObject::ReadPointedString (Stream& s, 918 Error& error, 919 uint32_t max_length, 920 bool honor_array, 921 Format item_format) 922 { 923 ExecutionContext exe_ctx (GetExecutionContextRef()); 924 Target* target = exe_ctx.GetTargetPtr(); 925 926 if (target && max_length == 0) 927 max_length = target->GetMaximumSizeOfStringSummary(); 928 929 clang_type_t clang_type = GetClangType(); 930 clang_type_t elem_or_pointee_clang_type; 931 const Flags type_flags (ClangASTContext::GetTypeInfo (clang_type, 932 GetClangAST(), 933 &elem_or_pointee_clang_type)); 934 if (type_flags.AnySet (ClangASTContext::eTypeIsArray | ClangASTContext::eTypeIsPointer) && 935 ClangASTContext::IsCharType (elem_or_pointee_clang_type)) 936 { 937 if (target == NULL) 938 { 939 s << "<no target to read from>"; 940 } 941 else 942 { 943 addr_t cstr_address = LLDB_INVALID_ADDRESS; 944 AddressType cstr_address_type = eAddressTypeInvalid; 945 946 size_t cstr_len = 0; 947 bool capped_data = false; 948 if (type_flags.Test (ClangASTContext::eTypeIsArray)) 949 { 950 // We have an array 951 cstr_len = ClangASTContext::GetArraySize (clang_type); 952 if (cstr_len > max_length) 953 { 954 capped_data = true; 955 cstr_len = max_length; 956 } 957 cstr_address = GetAddressOf (true, &cstr_address_type); 958 } 959 else 960 { 961 // We have a pointer 962 cstr_address = GetPointerValue (&cstr_address_type); 963 } 964 if (cstr_address != 0 && cstr_address != LLDB_INVALID_ADDRESS) 965 { 966 Address cstr_so_addr (cstr_address); 967 DataExtractor data; 968 size_t bytes_read = 0; 969 if (cstr_len > 0 && honor_array) 970 { 971 // I am using GetPointeeData() here to abstract the fact that some ValueObjects are actually frozen pointers in the host 972 // but the pointed-to data lives in the debuggee, and GetPointeeData() automatically takes care of this 973 GetPointeeData(data, 0, cstr_len); 974 975 if ((bytes_read = data.GetByteSize()) > 0) 976 { 977 s << '"'; 978 data.Dump (&s, 979 0, // Start offset in "data" 980 item_format, 981 1, // Size of item (1 byte for a char!) 982 bytes_read, // How many bytes to print? 983 UINT32_MAX, // num per line 984 LLDB_INVALID_ADDRESS,// base address 985 0, // bitfield bit size 986 0); // bitfield bit offset 987 if (capped_data) 988 s << "..."; 989 s << '"'; 990 } 991 } 992 else 993 { 994 cstr_len = max_length; 995 const size_t k_max_buf_size = 64; 996 997 size_t offset = 0; 998 999 int cstr_len_displayed = -1; 1000 bool capped_cstr = false; 1001 // I am using GetPointeeData() here to abstract the fact that some ValueObjects are actually frozen pointers in the host 1002 // but the pointed-to data lives in the debuggee, and GetPointeeData() automatically takes care of this 1003 while ((bytes_read = GetPointeeData(data, offset, k_max_buf_size)) > 0) 1004 { 1005 const char *cstr = data.PeekCStr(0); 1006 size_t len = strlen_or_inf (cstr, k_max_buf_size, k_max_buf_size+1); 1007 if (len > k_max_buf_size) 1008 len = k_max_buf_size; 1009 if (cstr && cstr_len_displayed < 0) 1010 s << '"'; 1011 1012 if (cstr_len_displayed < 0) 1013 cstr_len_displayed = len; 1014 1015 if (len == 0) 1016 break; 1017 cstr_len_displayed += len; 1018 if (len > bytes_read) 1019 len = bytes_read; 1020 if (len > cstr_len) 1021 len = cstr_len; 1022 1023 data.Dump (&s, 1024 0, // Start offset in "data" 1025 item_format, 1026 1, // Size of item (1 byte for a char!) 1027 len, // How many bytes to print? 1028 UINT32_MAX, // num per line 1029 LLDB_INVALID_ADDRESS,// base address 1030 0, // bitfield bit size 1031 0); // bitfield bit offset 1032 1033 if (len < k_max_buf_size) 1034 break; 1035 1036 if (len >= cstr_len) 1037 { 1038 capped_cstr = true; 1039 break; 1040 } 1041 1042 cstr_len -= len; 1043 offset += len; 1044 } 1045 1046 if (cstr_len_displayed >= 0) 1047 { 1048 s << '"'; 1049 if (capped_cstr) 1050 s << "..."; 1051 } 1052 } 1053 } 1054 } 1055 } 1056 else 1057 { 1058 error.SetErrorString("impossible to read a string from this object"); 1059 s << "<not a string object>"; 1060 } 1061 } 1062 1063 const char * 1064 ValueObject::GetObjectDescription () 1065 { 1066 1067 if (!UpdateValueIfNeeded (true)) 1068 return NULL; 1069 1070 if (!m_object_desc_str.empty()) 1071 return m_object_desc_str.c_str(); 1072 1073 ExecutionContext exe_ctx (GetExecutionContextRef()); 1074 Process *process = exe_ctx.GetProcessPtr(); 1075 if (process == NULL) 1076 return NULL; 1077 1078 StreamString s; 1079 1080 LanguageType language = GetObjectRuntimeLanguage(); 1081 LanguageRuntime *runtime = process->GetLanguageRuntime(language); 1082 1083 if (runtime == NULL) 1084 { 1085 // Aw, hell, if the things a pointer, or even just an integer, let's try ObjC anyway... 1086 clang_type_t opaque_qual_type = GetClangType(); 1087 if (opaque_qual_type != NULL) 1088 { 1089 bool is_signed; 1090 if (ClangASTContext::IsIntegerType (opaque_qual_type, is_signed) 1091 || ClangASTContext::IsPointerType (opaque_qual_type)) 1092 { 1093 runtime = process->GetLanguageRuntime(eLanguageTypeObjC); 1094 } 1095 } 1096 } 1097 1098 if (runtime && runtime->GetObjectDescription(s, *this)) 1099 { 1100 m_object_desc_str.append (s.GetData()); 1101 } 1102 1103 if (m_object_desc_str.empty()) 1104 return NULL; 1105 else 1106 return m_object_desc_str.c_str(); 1107 } 1108 1109 bool 1110 ValueObject::GetValueAsCString (lldb::Format format, 1111 std::string& destination) 1112 { 1113 if (ClangASTContext::IsAggregateType (GetClangType()) == false && 1114 UpdateValueIfNeeded(false)) 1115 { 1116 const Value::ContextType context_type = m_value.GetContextType(); 1117 1118 switch (context_type) 1119 { 1120 case Value::eContextTypeClangType: 1121 case Value::eContextTypeLLDBType: 1122 case Value::eContextTypeVariable: 1123 { 1124 clang_type_t clang_type = GetClangType (); 1125 if (clang_type) 1126 { 1127 StreamString sstr; 1128 ExecutionContext exe_ctx (GetExecutionContextRef()); 1129 ClangASTType::DumpTypeValue (GetClangAST(), // The clang AST 1130 clang_type, // The clang type to display 1131 &sstr, 1132 format, // Format to display this type with 1133 m_data, // Data to extract from 1134 0, // Byte offset into "m_data" 1135 GetByteSize(), // Byte size of item in "m_data" 1136 GetBitfieldBitSize(), // Bitfield bit size 1137 GetBitfieldBitOffset(), // Bitfield bit offset 1138 exe_ctx.GetBestExecutionContextScope()); 1139 // Don't set the m_error to anything here otherwise 1140 // we won't be able to re-format as anything else. The 1141 // code for ClangASTType::DumpTypeValue() should always 1142 // return something, even if that something contains 1143 // an error messsage. "m_error" is used to detect errors 1144 // when reading the valid object, not for formatting errors. 1145 if (sstr.GetString().empty()) 1146 destination.clear(); 1147 else 1148 destination.swap(sstr.GetString()); 1149 } 1150 } 1151 break; 1152 1153 case Value::eContextTypeRegisterInfo: 1154 { 1155 const RegisterInfo *reg_info = m_value.GetRegisterInfo(); 1156 if (reg_info) 1157 { 1158 ExecutionContext exe_ctx (GetExecutionContextRef()); 1159 1160 StreamString reg_sstr; 1161 m_data.Dump (®_sstr, 1162 0, 1163 format, 1164 reg_info->byte_size, 1165 1, 1166 UINT32_MAX, 1167 LLDB_INVALID_ADDRESS, 1168 0, 1169 0, 1170 exe_ctx.GetBestExecutionContextScope()); 1171 destination.swap(reg_sstr.GetString()); 1172 } 1173 } 1174 break; 1175 1176 default: 1177 break; 1178 } 1179 return !destination.empty(); 1180 } 1181 else 1182 return false; 1183 } 1184 1185 const char * 1186 ValueObject::GetValueAsCString () 1187 { 1188 if (UpdateValueIfNeeded(true) && m_value_str.empty()) 1189 { 1190 lldb::Format my_format = GetFormat(); 1191 if (m_format == lldb::eFormatDefault) 1192 { 1193 if (m_type_format_sp) 1194 my_format = m_type_format_sp->GetFormat(); 1195 else 1196 { 1197 if (m_is_bitfield_for_scalar) 1198 my_format = eFormatUnsigned; 1199 else 1200 { 1201 if (m_value.GetContextType() == Value::eContextTypeRegisterInfo) 1202 { 1203 const RegisterInfo *reg_info = m_value.GetRegisterInfo(); 1204 if (reg_info) 1205 my_format = reg_info->format; 1206 } 1207 else 1208 { 1209 clang_type_t clang_type = GetClangType (); 1210 my_format = ClangASTType::GetFormat(clang_type); 1211 } 1212 } 1213 } 1214 } 1215 if (GetValueAsCString(my_format, m_value_str)) 1216 { 1217 if (!m_value_did_change && m_old_value_valid) 1218 { 1219 // The value was gotten successfully, so we consider the 1220 // value as changed if the value string differs 1221 SetValueDidChange (m_old_value_str != m_value_str); 1222 } 1223 } 1224 } 1225 if (m_value_str.empty()) 1226 return NULL; 1227 return m_value_str.c_str(); 1228 } 1229 1230 // if > 8bytes, 0 is returned. this method should mostly be used 1231 // to read address values out of pointers 1232 uint64_t 1233 ValueObject::GetValueAsUnsigned (uint64_t fail_value) 1234 { 1235 // If our byte size is zero this is an aggregate type that has children 1236 if (ClangASTContext::IsAggregateType (GetClangType()) == false) 1237 { 1238 Scalar scalar; 1239 if (ResolveValue (scalar)) 1240 return scalar.GetRawBits64(fail_value); 1241 } 1242 return fail_value; 1243 } 1244 1245 bool 1246 ValueObject::GetPrintableRepresentation(Stream& s, 1247 ValueObjectRepresentationStyle val_obj_display, 1248 Format custom_format) 1249 { 1250 1251 if (custom_format != eFormatInvalid) 1252 SetFormat(custom_format); 1253 1254 const char * return_value; 1255 std::string alloc_mem; 1256 1257 switch(val_obj_display) 1258 { 1259 case eDisplayValue: 1260 return_value = GetValueAsCString(); 1261 break; 1262 1263 case eDisplaySummary: 1264 return_value = GetSummaryAsCString(); 1265 break; 1266 1267 case eDisplayLanguageSpecific: 1268 return_value = GetObjectDescription(); 1269 break; 1270 1271 case eDisplayLocation: 1272 return_value = GetLocationAsCString(); 1273 break; 1274 1275 case eDisplayChildrenCount: 1276 { 1277 alloc_mem.resize(512); 1278 return_value = &alloc_mem[0]; 1279 int count = GetNumChildren(); 1280 snprintf((char*)return_value, 512, "%d", count); 1281 } 1282 break; 1283 1284 case eDisplayType: 1285 return_value = GetTypeName().AsCString(); 1286 break; 1287 1288 default: 1289 break; 1290 } 1291 1292 if (!return_value) 1293 { 1294 if (val_obj_display == eDisplayValue) 1295 return_value = GetSummaryAsCString(); 1296 else if (val_obj_display == eDisplaySummary) 1297 { 1298 if (ClangASTContext::IsAggregateType (GetClangType()) == true) 1299 { 1300 // this thing has no value, and it seems to have no summary 1301 // some combination of unitialized data and other factors can also 1302 // raise this condition, so let's print a nice generic description 1303 { 1304 alloc_mem.resize(684); 1305 return_value = &alloc_mem[0]; 1306 snprintf((char*)return_value, 684, "%s @ %s", GetTypeName().AsCString(), GetLocationAsCString()); 1307 } 1308 } 1309 else 1310 return_value = GetValueAsCString(); 1311 } 1312 } 1313 1314 if (return_value) 1315 s.PutCString(return_value); 1316 else 1317 { 1318 if (m_error.Fail()) 1319 s.Printf("<%s>", m_error.AsCString()); 1320 else if (val_obj_display == eDisplaySummary) 1321 s.PutCString("<no summary available>"); 1322 else if (val_obj_display == eDisplayValue) 1323 s.PutCString("<no value available>"); 1324 else if (val_obj_display == eDisplayLanguageSpecific) 1325 s.PutCString("<not a valid Objective-C object>"); // edit this if we have other runtimes that support a description 1326 else 1327 s.PutCString("<no printable representation>"); 1328 } 1329 1330 // we should only return false here if we could not do *anything* 1331 // even if we have an error message as output, that's a success 1332 // from our callers' perspective, so return true 1333 return true; 1334 1335 } 1336 1337 // if any more "special cases" are added to ValueObject::DumpPrintableRepresentation() please keep 1338 // this call up to date by returning true for your new special cases. We will eventually move 1339 // to checking this call result before trying to display special cases 1340 bool 1341 ValueObject::HasSpecialCasesForPrintableRepresentation(ValueObjectRepresentationStyle val_obj_display, 1342 Format custom_format) 1343 { 1344 clang_type_t elem_or_pointee_type; 1345 Flags flags(ClangASTContext::GetTypeInfo(GetClangType(), GetClangAST(), &elem_or_pointee_type)); 1346 1347 if (flags.AnySet(ClangASTContext::eTypeIsArray | ClangASTContext::eTypeIsPointer) 1348 && val_obj_display == ValueObject::eDisplayValue) 1349 { 1350 if (IsCStringContainer(true) && 1351 (custom_format == eFormatCString || 1352 custom_format == eFormatCharArray || 1353 custom_format == eFormatChar || 1354 custom_format == eFormatVectorOfChar)) 1355 return true; 1356 1357 if (flags.Test(ClangASTContext::eTypeIsArray)) 1358 { 1359 if ((custom_format == eFormatBytes) || 1360 (custom_format == eFormatBytesWithASCII)) 1361 return true; 1362 1363 if ((custom_format == eFormatVectorOfChar) || 1364 (custom_format == eFormatVectorOfFloat32) || 1365 (custom_format == eFormatVectorOfFloat64) || 1366 (custom_format == eFormatVectorOfSInt16) || 1367 (custom_format == eFormatVectorOfSInt32) || 1368 (custom_format == eFormatVectorOfSInt64) || 1369 (custom_format == eFormatVectorOfSInt8) || 1370 (custom_format == eFormatVectorOfUInt128) || 1371 (custom_format == eFormatVectorOfUInt16) || 1372 (custom_format == eFormatVectorOfUInt32) || 1373 (custom_format == eFormatVectorOfUInt64) || 1374 (custom_format == eFormatVectorOfUInt8)) 1375 return true; 1376 } 1377 } 1378 return false; 1379 } 1380 1381 bool 1382 ValueObject::DumpPrintableRepresentation(Stream& s, 1383 ValueObjectRepresentationStyle val_obj_display, 1384 Format custom_format, 1385 bool only_special) 1386 { 1387 1388 clang_type_t elem_or_pointee_type; 1389 Flags flags(ClangASTContext::GetTypeInfo(GetClangType(), GetClangAST(), &elem_or_pointee_type)); 1390 1391 if (flags.AnySet(ClangASTContext::eTypeIsArray | ClangASTContext::eTypeIsPointer) 1392 && val_obj_display == ValueObject::eDisplayValue) 1393 { 1394 // when being asked to get a printable display an array or pointer type directly, 1395 // try to "do the right thing" 1396 1397 if (IsCStringContainer(true) && 1398 (custom_format == eFormatCString || 1399 custom_format == eFormatCharArray || 1400 custom_format == eFormatChar || 1401 custom_format == eFormatVectorOfChar)) // print char[] & char* directly 1402 { 1403 Error error; 1404 ReadPointedString(s, 1405 error, 1406 0, 1407 (custom_format == eFormatVectorOfChar) || 1408 (custom_format == eFormatCharArray)); 1409 return !error.Fail(); 1410 } 1411 1412 if (custom_format == eFormatEnum) 1413 return false; 1414 1415 // this only works for arrays, because I have no way to know when 1416 // the pointed memory ends, and no special \0 end of data marker 1417 if (flags.Test(ClangASTContext::eTypeIsArray)) 1418 { 1419 if ((custom_format == eFormatBytes) || 1420 (custom_format == eFormatBytesWithASCII)) 1421 { 1422 uint32_t count = GetNumChildren(); 1423 1424 s << '['; 1425 for (uint32_t low = 0; low < count; low++) 1426 { 1427 1428 if (low) 1429 s << ','; 1430 1431 ValueObjectSP child = GetChildAtIndex(low,true); 1432 if (!child.get()) 1433 { 1434 s << "<invalid child>"; 1435 continue; 1436 } 1437 child->DumpPrintableRepresentation(s, ValueObject::eDisplayValue, custom_format); 1438 } 1439 1440 s << ']'; 1441 1442 return true; 1443 } 1444 1445 if ((custom_format == eFormatVectorOfChar) || 1446 (custom_format == eFormatVectorOfFloat32) || 1447 (custom_format == eFormatVectorOfFloat64) || 1448 (custom_format == eFormatVectorOfSInt16) || 1449 (custom_format == eFormatVectorOfSInt32) || 1450 (custom_format == eFormatVectorOfSInt64) || 1451 (custom_format == eFormatVectorOfSInt8) || 1452 (custom_format == eFormatVectorOfUInt128) || 1453 (custom_format == eFormatVectorOfUInt16) || 1454 (custom_format == eFormatVectorOfUInt32) || 1455 (custom_format == eFormatVectorOfUInt64) || 1456 (custom_format == eFormatVectorOfUInt8)) // arrays of bytes, bytes with ASCII or any vector format should be printed directly 1457 { 1458 uint32_t count = GetNumChildren(); 1459 1460 Format format = FormatManager::GetSingleItemFormat(custom_format); 1461 1462 s << '['; 1463 for (uint32_t low = 0; low < count; low++) 1464 { 1465 1466 if (low) 1467 s << ','; 1468 1469 ValueObjectSP child = GetChildAtIndex(low,true); 1470 if (!child.get()) 1471 { 1472 s << "<invalid child>"; 1473 continue; 1474 } 1475 child->DumpPrintableRepresentation(s, ValueObject::eDisplayValue, format); 1476 } 1477 1478 s << ']'; 1479 1480 return true; 1481 } 1482 } 1483 1484 if ((custom_format == eFormatBoolean) || 1485 (custom_format == eFormatBinary) || 1486 (custom_format == eFormatChar) || 1487 (custom_format == eFormatCharPrintable) || 1488 (custom_format == eFormatComplexFloat) || 1489 (custom_format == eFormatDecimal) || 1490 (custom_format == eFormatHex) || 1491 (custom_format == eFormatFloat) || 1492 (custom_format == eFormatOctal) || 1493 (custom_format == eFormatOSType) || 1494 (custom_format == eFormatUnicode16) || 1495 (custom_format == eFormatUnicode32) || 1496 (custom_format == eFormatUnsigned) || 1497 (custom_format == eFormatPointer) || 1498 (custom_format == eFormatComplexInteger) || 1499 (custom_format == eFormatComplex) || 1500 (custom_format == eFormatDefault)) // use the [] operator 1501 return false; 1502 } 1503 1504 if (only_special) 1505 return false; 1506 1507 bool var_success = GetPrintableRepresentation(s, val_obj_display, custom_format); 1508 if (custom_format != eFormatInvalid) 1509 SetFormat(eFormatDefault); 1510 return var_success; 1511 } 1512 1513 addr_t 1514 ValueObject::GetAddressOf (bool scalar_is_load_address, AddressType *address_type) 1515 { 1516 if (!UpdateValueIfNeeded(false)) 1517 return LLDB_INVALID_ADDRESS; 1518 1519 switch (m_value.GetValueType()) 1520 { 1521 case Value::eValueTypeScalar: 1522 if (scalar_is_load_address) 1523 { 1524 if(address_type) 1525 *address_type = eAddressTypeLoad; 1526 return m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS); 1527 } 1528 break; 1529 1530 case Value::eValueTypeLoadAddress: 1531 case Value::eValueTypeFileAddress: 1532 case Value::eValueTypeHostAddress: 1533 { 1534 if(address_type) 1535 *address_type = m_value.GetValueAddressType (); 1536 return m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS); 1537 } 1538 break; 1539 } 1540 if (address_type) 1541 *address_type = eAddressTypeInvalid; 1542 return LLDB_INVALID_ADDRESS; 1543 } 1544 1545 addr_t 1546 ValueObject::GetPointerValue (AddressType *address_type) 1547 { 1548 addr_t address = LLDB_INVALID_ADDRESS; 1549 if(address_type) 1550 *address_type = eAddressTypeInvalid; 1551 1552 if (!UpdateValueIfNeeded(false)) 1553 return address; 1554 1555 switch (m_value.GetValueType()) 1556 { 1557 case Value::eValueTypeScalar: 1558 address = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS); 1559 break; 1560 1561 case Value::eValueTypeHostAddress: 1562 case Value::eValueTypeLoadAddress: 1563 case Value::eValueTypeFileAddress: 1564 { 1565 uint32_t data_offset = 0; 1566 address = m_data.GetPointer(&data_offset); 1567 } 1568 break; 1569 } 1570 1571 if (address_type) 1572 *address_type = GetAddressTypeOfChildren(); 1573 1574 return address; 1575 } 1576 1577 bool 1578 ValueObject::SetValueFromCString (const char *value_str) 1579 { 1580 // Make sure our value is up to date first so that our location and location 1581 // type is valid. 1582 if (!UpdateValueIfNeeded(false)) 1583 return false; 1584 1585 uint32_t count = 0; 1586 Encoding encoding = ClangASTType::GetEncoding (GetClangType(), count); 1587 1588 const size_t byte_size = GetByteSize(); 1589 1590 Value::ValueType value_type = m_value.GetValueType(); 1591 1592 if (value_type == Value::eValueTypeScalar) 1593 { 1594 // If the value is already a scalar, then let the scalar change itself: 1595 m_value.GetScalar().SetValueFromCString (value_str, encoding, byte_size); 1596 } 1597 else if (byte_size <= Scalar::GetMaxByteSize()) 1598 { 1599 // If the value fits in a scalar, then make a new scalar and again let the 1600 // scalar code do the conversion, then figure out where to put the new value. 1601 Scalar new_scalar; 1602 Error error; 1603 error = new_scalar.SetValueFromCString (value_str, encoding, byte_size); 1604 if (error.Success()) 1605 { 1606 switch (value_type) 1607 { 1608 case Value::eValueTypeLoadAddress: 1609 { 1610 // If it is a load address, then the scalar value is the storage location 1611 // of the data, and we have to shove this value down to that load location. 1612 ExecutionContext exe_ctx (GetExecutionContextRef()); 1613 Process *process = exe_ctx.GetProcessPtr(); 1614 if (process) 1615 { 1616 addr_t target_addr = m_value.GetScalar().GetRawBits64(LLDB_INVALID_ADDRESS); 1617 size_t bytes_written = process->WriteScalarToMemory (target_addr, 1618 new_scalar, 1619 byte_size, 1620 error); 1621 if (!error.Success() || bytes_written != byte_size) 1622 return false; 1623 } 1624 } 1625 break; 1626 case Value::eValueTypeHostAddress: 1627 { 1628 // If it is a host address, then we stuff the scalar as a DataBuffer into the Value's data. 1629 DataExtractor new_data; 1630 new_data.SetByteOrder (m_data.GetByteOrder()); 1631 1632 DataBufferSP buffer_sp (new DataBufferHeap(byte_size, 0)); 1633 m_data.SetData(buffer_sp, 0); 1634 bool success = new_scalar.GetData(new_data); 1635 if (success) 1636 { 1637 new_data.CopyByteOrderedData (0, 1638 byte_size, 1639 const_cast<uint8_t *>(m_data.GetDataStart()), 1640 byte_size, 1641 m_data.GetByteOrder()); 1642 } 1643 m_value.GetScalar() = (uintptr_t)m_data.GetDataStart(); 1644 1645 } 1646 break; 1647 case Value::eValueTypeFileAddress: 1648 case Value::eValueTypeScalar: 1649 break; 1650 } 1651 } 1652 else 1653 { 1654 return false; 1655 } 1656 } 1657 else 1658 { 1659 // We don't support setting things bigger than a scalar at present. 1660 return false; 1661 } 1662 1663 // If we have reached this point, then we have successfully changed the value. 1664 SetNeedsUpdate(); 1665 return true; 1666 } 1667 1668 bool 1669 ValueObject::GetDeclaration (Declaration &decl) 1670 { 1671 decl.Clear(); 1672 return false; 1673 } 1674 1675 LanguageType 1676 ValueObject::GetObjectRuntimeLanguage () 1677 { 1678 return ClangASTType::GetMinimumLanguage (GetClangAST(), 1679 GetClangType()); 1680 } 1681 1682 void 1683 ValueObject::AddSyntheticChild (const ConstString &key, ValueObject *valobj) 1684 { 1685 m_synthetic_children[key] = valobj; 1686 } 1687 1688 ValueObjectSP 1689 ValueObject::GetSyntheticChild (const ConstString &key) const 1690 { 1691 ValueObjectSP synthetic_child_sp; 1692 std::map<ConstString, ValueObject *>::const_iterator pos = m_synthetic_children.find (key); 1693 if (pos != m_synthetic_children.end()) 1694 synthetic_child_sp = pos->second->GetSP(); 1695 return synthetic_child_sp; 1696 } 1697 1698 bool 1699 ValueObject::IsPointerType () 1700 { 1701 return ClangASTContext::IsPointerType (GetClangType()); 1702 } 1703 1704 bool 1705 ValueObject::IsArrayType () 1706 { 1707 return ClangASTContext::IsArrayType (GetClangType()); 1708 } 1709 1710 bool 1711 ValueObject::IsScalarType () 1712 { 1713 return ClangASTContext::IsScalarType (GetClangType()); 1714 } 1715 1716 bool 1717 ValueObject::IsIntegerType (bool &is_signed) 1718 { 1719 return ClangASTContext::IsIntegerType (GetClangType(), is_signed); 1720 } 1721 1722 bool 1723 ValueObject::IsPointerOrReferenceType () 1724 { 1725 return ClangASTContext::IsPointerOrReferenceType (GetClangType()); 1726 } 1727 1728 bool 1729 ValueObject::IsPossibleCPlusPlusDynamicType () 1730 { 1731 return ClangASTContext::IsPossibleCPlusPlusDynamicType (GetClangAST (), GetClangType()); 1732 } 1733 1734 bool 1735 ValueObject::IsPossibleDynamicType () 1736 { 1737 return ClangASTContext::IsPossibleDynamicType (GetClangAST (), GetClangType()); 1738 } 1739 1740 ValueObjectSP 1741 ValueObject::GetSyntheticArrayMember (int32_t index, bool can_create) 1742 { 1743 if (IsArrayType()) 1744 return GetSyntheticArrayMemberFromArray(index, can_create); 1745 1746 if (IsPointerType()) 1747 return GetSyntheticArrayMemberFromPointer(index, can_create); 1748 1749 return ValueObjectSP(); 1750 1751 } 1752 1753 ValueObjectSP 1754 ValueObject::GetSyntheticArrayMemberFromPointer (int32_t index, bool can_create) 1755 { 1756 ValueObjectSP synthetic_child_sp; 1757 if (IsPointerType ()) 1758 { 1759 char index_str[64]; 1760 snprintf(index_str, sizeof(index_str), "[%i]", index); 1761 ConstString index_const_str(index_str); 1762 // Check if we have already created a synthetic array member in this 1763 // valid object. If we have we will re-use it. 1764 synthetic_child_sp = GetSyntheticChild (index_const_str); 1765 if (!synthetic_child_sp) 1766 { 1767 ValueObject *synthetic_child; 1768 // We haven't made a synthetic array member for INDEX yet, so 1769 // lets make one and cache it for any future reference. 1770 synthetic_child = CreateChildAtIndex(0, true, index); 1771 1772 // Cache the value if we got one back... 1773 if (synthetic_child) 1774 { 1775 AddSyntheticChild(index_const_str, synthetic_child); 1776 synthetic_child_sp = synthetic_child->GetSP(); 1777 synthetic_child_sp->SetName(ConstString(index_str)); 1778 synthetic_child_sp->m_is_array_item_for_pointer = true; 1779 } 1780 } 1781 } 1782 return synthetic_child_sp; 1783 } 1784 1785 // This allows you to create an array member using and index 1786 // that doesn't not fall in the normal bounds of the array. 1787 // Many times structure can be defined as: 1788 // struct Collection 1789 // { 1790 // uint32_t item_count; 1791 // Item item_array[0]; 1792 // }; 1793 // The size of the "item_array" is 1, but many times in practice 1794 // there are more items in "item_array". 1795 1796 ValueObjectSP 1797 ValueObject::GetSyntheticArrayMemberFromArray (int32_t index, bool can_create) 1798 { 1799 ValueObjectSP synthetic_child_sp; 1800 if (IsArrayType ()) 1801 { 1802 char index_str[64]; 1803 snprintf(index_str, sizeof(index_str), "[%i]", index); 1804 ConstString index_const_str(index_str); 1805 // Check if we have already created a synthetic array member in this 1806 // valid object. If we have we will re-use it. 1807 synthetic_child_sp = GetSyntheticChild (index_const_str); 1808 if (!synthetic_child_sp) 1809 { 1810 ValueObject *synthetic_child; 1811 // We haven't made a synthetic array member for INDEX yet, so 1812 // lets make one and cache it for any future reference. 1813 synthetic_child = CreateChildAtIndex(0, true, index); 1814 1815 // Cache the value if we got one back... 1816 if (synthetic_child) 1817 { 1818 AddSyntheticChild(index_const_str, synthetic_child); 1819 synthetic_child_sp = synthetic_child->GetSP(); 1820 synthetic_child_sp->SetName(ConstString(index_str)); 1821 synthetic_child_sp->m_is_array_item_for_pointer = true; 1822 } 1823 } 1824 } 1825 return synthetic_child_sp; 1826 } 1827 1828 ValueObjectSP 1829 ValueObject::GetSyntheticBitFieldChild (uint32_t from, uint32_t to, bool can_create) 1830 { 1831 ValueObjectSP synthetic_child_sp; 1832 if (IsScalarType ()) 1833 { 1834 char index_str[64]; 1835 snprintf(index_str, sizeof(index_str), "[%i-%i]", from, to); 1836 ConstString index_const_str(index_str); 1837 // Check if we have already created a synthetic array member in this 1838 // valid object. If we have we will re-use it. 1839 synthetic_child_sp = GetSyntheticChild (index_const_str); 1840 if (!synthetic_child_sp) 1841 { 1842 ValueObjectChild *synthetic_child; 1843 // We haven't made a synthetic array member for INDEX yet, so 1844 // lets make one and cache it for any future reference. 1845 synthetic_child = new ValueObjectChild(*this, 1846 GetClangAST(), 1847 GetClangType(), 1848 index_const_str, 1849 GetByteSize(), 1850 0, 1851 to-from+1, 1852 from, 1853 false, 1854 false, 1855 eAddressTypeInvalid); 1856 1857 // Cache the value if we got one back... 1858 if (synthetic_child) 1859 { 1860 AddSyntheticChild(index_const_str, synthetic_child); 1861 synthetic_child_sp = synthetic_child->GetSP(); 1862 synthetic_child_sp->SetName(ConstString(index_str)); 1863 synthetic_child_sp->m_is_bitfield_for_scalar = true; 1864 } 1865 } 1866 } 1867 return synthetic_child_sp; 1868 } 1869 1870 ValueObjectSP 1871 ValueObject::GetSyntheticArrayRangeChild (uint32_t from, uint32_t to, bool can_create) 1872 { 1873 ValueObjectSP synthetic_child_sp; 1874 if (IsArrayType () || IsPointerType ()) 1875 { 1876 char index_str[64]; 1877 snprintf(index_str, sizeof(index_str), "[%i-%i]", from, to); 1878 ConstString index_const_str(index_str); 1879 // Check if we have already created a synthetic array member in this 1880 // valid object. If we have we will re-use it. 1881 synthetic_child_sp = GetSyntheticChild (index_const_str); 1882 if (!synthetic_child_sp) 1883 { 1884 ValueObjectSynthetic *synthetic_child; 1885 1886 // We haven't made a synthetic array member for INDEX yet, so 1887 // lets make one and cache it for any future reference. 1888 SyntheticArrayView *view = new SyntheticArrayView(SyntheticChildren::Flags()); 1889 view->AddRange(from,to); 1890 SyntheticChildrenSP view_sp(view); 1891 synthetic_child = new ValueObjectSynthetic(*this, view_sp); 1892 1893 // Cache the value if we got one back... 1894 if (synthetic_child) 1895 { 1896 AddSyntheticChild(index_const_str, synthetic_child); 1897 synthetic_child_sp = synthetic_child->GetSP(); 1898 synthetic_child_sp->SetName(ConstString(index_str)); 1899 synthetic_child_sp->m_is_bitfield_for_scalar = true; 1900 } 1901 } 1902 } 1903 return synthetic_child_sp; 1904 } 1905 1906 ValueObjectSP 1907 ValueObject::GetSyntheticChildAtOffset(uint32_t offset, const ClangASTType& type, bool can_create) 1908 { 1909 1910 ValueObjectSP synthetic_child_sp; 1911 1912 char name_str[64]; 1913 snprintf(name_str, sizeof(name_str), "@%i", offset); 1914 ConstString name_const_str(name_str); 1915 1916 // Check if we have already created a synthetic array member in this 1917 // valid object. If we have we will re-use it. 1918 synthetic_child_sp = GetSyntheticChild (name_const_str); 1919 1920 if (synthetic_child_sp.get()) 1921 return synthetic_child_sp; 1922 1923 if (!can_create) 1924 return ValueObjectSP(); 1925 1926 ValueObjectChild *synthetic_child = new ValueObjectChild(*this, 1927 type.GetASTContext(), 1928 type.GetOpaqueQualType(), 1929 name_const_str, 1930 type.GetTypeByteSize(), 1931 offset, 1932 0, 1933 0, 1934 false, 1935 false, 1936 eAddressTypeInvalid); 1937 if (synthetic_child) 1938 { 1939 AddSyntheticChild(name_const_str, synthetic_child); 1940 synthetic_child_sp = synthetic_child->GetSP(); 1941 synthetic_child_sp->SetName(name_const_str); 1942 synthetic_child_sp->m_is_child_at_offset = true; 1943 } 1944 return synthetic_child_sp; 1945 } 1946 1947 // your expression path needs to have a leading . or -> 1948 // (unless it somehow "looks like" an array, in which case it has 1949 // a leading [ symbol). while the [ is meaningful and should be shown 1950 // to the user, . and -> are just parser design, but by no means 1951 // added information for the user.. strip them off 1952 static const char* 1953 SkipLeadingExpressionPathSeparators(const char* expression) 1954 { 1955 if (!expression || !expression[0]) 1956 return expression; 1957 if (expression[0] == '.') 1958 return expression+1; 1959 if (expression[0] == '-' && expression[1] == '>') 1960 return expression+2; 1961 return expression; 1962 } 1963 1964 ValueObjectSP 1965 ValueObject::GetSyntheticExpressionPathChild(const char* expression, bool can_create) 1966 { 1967 ValueObjectSP synthetic_child_sp; 1968 ConstString name_const_string(expression); 1969 // Check if we have already created a synthetic array member in this 1970 // valid object. If we have we will re-use it. 1971 synthetic_child_sp = GetSyntheticChild (name_const_string); 1972 if (!synthetic_child_sp) 1973 { 1974 // We haven't made a synthetic array member for expression yet, so 1975 // lets make one and cache it for any future reference. 1976 synthetic_child_sp = GetValueForExpressionPath(expression); 1977 1978 // Cache the value if we got one back... 1979 if (synthetic_child_sp.get()) 1980 { 1981 AddSyntheticChild(name_const_string, synthetic_child_sp.get()); 1982 synthetic_child_sp->SetName(ConstString(SkipLeadingExpressionPathSeparators(expression))); 1983 synthetic_child_sp->m_is_expression_path_child = true; 1984 } 1985 } 1986 return synthetic_child_sp; 1987 } 1988 1989 void 1990 ValueObject::CalculateSyntheticValue (SyntheticValueType use_synthetic) 1991 { 1992 if (use_synthetic == eNoSyntheticFilter) 1993 return; 1994 1995 UpdateFormatsIfNeeded(m_last_format_mgr_dynamic); 1996 1997 if (m_synthetic_children_sp.get() == NULL) 1998 return; 1999 2000 if (m_synthetic_value == NULL) 2001 m_synthetic_value = new ValueObjectSynthetic(*this, m_synthetic_children_sp); 2002 2003 } 2004 2005 void 2006 ValueObject::CalculateDynamicValue (DynamicValueType use_dynamic) 2007 { 2008 if (use_dynamic == eNoDynamicValues) 2009 return; 2010 2011 if (!m_dynamic_value && !IsDynamic()) 2012 { 2013 ExecutionContext exe_ctx (GetExecutionContextRef()); 2014 Process *process = exe_ctx.GetProcessPtr(); 2015 if (process) 2016 { 2017 bool worth_having_dynamic_value = false; 2018 2019 2020 // FIXME: Process should have some kind of "map over Runtimes" so we don't have to 2021 // hard code this everywhere. 2022 LanguageType known_type = GetObjectRuntimeLanguage(); 2023 if (known_type != eLanguageTypeUnknown && known_type != eLanguageTypeC) 2024 { 2025 LanguageRuntime *runtime = process->GetLanguageRuntime (known_type); 2026 if (runtime) 2027 worth_having_dynamic_value = runtime->CouldHaveDynamicValue(*this); 2028 } 2029 else 2030 { 2031 LanguageRuntime *cpp_runtime = process->GetLanguageRuntime (eLanguageTypeC_plus_plus); 2032 if (cpp_runtime) 2033 worth_having_dynamic_value = cpp_runtime->CouldHaveDynamicValue(*this); 2034 2035 if (!worth_having_dynamic_value) 2036 { 2037 LanguageRuntime *objc_runtime = process->GetLanguageRuntime (eLanguageTypeObjC); 2038 if (objc_runtime) 2039 worth_having_dynamic_value = objc_runtime->CouldHaveDynamicValue(*this); 2040 } 2041 } 2042 2043 if (worth_having_dynamic_value) 2044 m_dynamic_value = new ValueObjectDynamicValue (*this, use_dynamic); 2045 } 2046 } 2047 } 2048 2049 ValueObjectSP 2050 ValueObject::GetDynamicValue (DynamicValueType use_dynamic) 2051 { 2052 if (use_dynamic == eNoDynamicValues) 2053 return ValueObjectSP(); 2054 2055 if (!IsDynamic() && m_dynamic_value == NULL) 2056 { 2057 CalculateDynamicValue(use_dynamic); 2058 } 2059 if (m_dynamic_value) 2060 return m_dynamic_value->GetSP(); 2061 else 2062 return ValueObjectSP(); 2063 } 2064 2065 ValueObjectSP 2066 ValueObject::GetStaticValue() 2067 { 2068 return GetSP(); 2069 } 2070 2071 // GetDynamicValue() returns a NULL SharedPointer if the object is not dynamic 2072 // or we do not really want a dynamic VO. this method instead returns this object 2073 // itself when making it synthetic has no meaning. this makes it much simpler 2074 // to replace the SyntheticValue for the ValueObject 2075 ValueObjectSP 2076 ValueObject::GetSyntheticValue (SyntheticValueType use_synthetic) 2077 { 2078 if (use_synthetic == eNoSyntheticFilter) 2079 return GetSP(); 2080 2081 UpdateFormatsIfNeeded(m_last_format_mgr_dynamic); 2082 2083 if (m_synthetic_children_sp.get() == NULL) 2084 return GetSP(); 2085 2086 CalculateSyntheticValue(use_synthetic); 2087 2088 if (m_synthetic_value) 2089 return m_synthetic_value->GetSP(); 2090 else 2091 return GetSP(); 2092 } 2093 2094 bool 2095 ValueObject::HasSyntheticValue() 2096 { 2097 UpdateFormatsIfNeeded(m_last_format_mgr_dynamic); 2098 2099 if (m_synthetic_children_sp.get() == NULL) 2100 return false; 2101 2102 CalculateSyntheticValue(eUseSyntheticFilter); 2103 2104 if (m_synthetic_value) 2105 return true; 2106 else 2107 return false; 2108 } 2109 2110 bool 2111 ValueObject::GetBaseClassPath (Stream &s) 2112 { 2113 if (IsBaseClass()) 2114 { 2115 bool parent_had_base_class = GetParent() && GetParent()->GetBaseClassPath (s); 2116 clang_type_t clang_type = GetClangType(); 2117 std::string cxx_class_name; 2118 bool this_had_base_class = ClangASTContext::GetCXXClassName (clang_type, cxx_class_name); 2119 if (this_had_base_class) 2120 { 2121 if (parent_had_base_class) 2122 s.PutCString("::"); 2123 s.PutCString(cxx_class_name.c_str()); 2124 } 2125 return parent_had_base_class || this_had_base_class; 2126 } 2127 return false; 2128 } 2129 2130 2131 ValueObject * 2132 ValueObject::GetNonBaseClassParent() 2133 { 2134 if (GetParent()) 2135 { 2136 if (GetParent()->IsBaseClass()) 2137 return GetParent()->GetNonBaseClassParent(); 2138 else 2139 return GetParent(); 2140 } 2141 return NULL; 2142 } 2143 2144 void 2145 ValueObject::GetExpressionPath (Stream &s, bool qualify_cxx_base_classes, GetExpressionPathFormat epformat) 2146 { 2147 const bool is_deref_of_parent = IsDereferenceOfParent (); 2148 2149 if (is_deref_of_parent && epformat == eDereferencePointers) 2150 { 2151 // this is the original format of GetExpressionPath() producing code like *(a_ptr).memberName, which is entirely 2152 // fine, until you put this into StackFrame::GetValueForVariableExpressionPath() which prefers to see a_ptr->memberName. 2153 // the eHonorPointers mode is meant to produce strings in this latter format 2154 s.PutCString("*("); 2155 } 2156 2157 ValueObject* parent = GetParent(); 2158 2159 if (parent) 2160 parent->GetExpressionPath (s, qualify_cxx_base_classes, epformat); 2161 2162 // if we are a deref_of_parent just because we are synthetic array 2163 // members made up to allow ptr[%d] syntax to work in variable 2164 // printing, then add our name ([%d]) to the expression path 2165 if (m_is_array_item_for_pointer && epformat == eHonorPointers) 2166 s.PutCString(m_name.AsCString()); 2167 2168 if (!IsBaseClass()) 2169 { 2170 if (!is_deref_of_parent) 2171 { 2172 ValueObject *non_base_class_parent = GetNonBaseClassParent(); 2173 if (non_base_class_parent) 2174 { 2175 clang_type_t non_base_class_parent_clang_type = non_base_class_parent->GetClangType(); 2176 if (non_base_class_parent_clang_type) 2177 { 2178 const uint32_t non_base_class_parent_type_info = ClangASTContext::GetTypeInfo (non_base_class_parent_clang_type, NULL, NULL); 2179 2180 if (parent && parent->IsDereferenceOfParent() && epformat == eHonorPointers) 2181 { 2182 s.PutCString("->"); 2183 } 2184 else 2185 { 2186 if (non_base_class_parent_type_info & ClangASTContext::eTypeIsPointer) 2187 { 2188 s.PutCString("->"); 2189 } 2190 else if ((non_base_class_parent_type_info & ClangASTContext::eTypeHasChildren) && 2191 !(non_base_class_parent_type_info & ClangASTContext::eTypeIsArray)) 2192 { 2193 s.PutChar('.'); 2194 } 2195 } 2196 } 2197 } 2198 2199 const char *name = GetName().GetCString(); 2200 if (name) 2201 { 2202 if (qualify_cxx_base_classes) 2203 { 2204 if (GetBaseClassPath (s)) 2205 s.PutCString("::"); 2206 } 2207 s.PutCString(name); 2208 } 2209 } 2210 } 2211 2212 if (is_deref_of_parent && epformat == eDereferencePointers) 2213 { 2214 s.PutChar(')'); 2215 } 2216 } 2217 2218 ValueObjectSP 2219 ValueObject::GetValueForExpressionPath(const char* expression, 2220 const char** first_unparsed, 2221 ExpressionPathScanEndReason* reason_to_stop, 2222 ExpressionPathEndResultType* final_value_type, 2223 const GetValueForExpressionPathOptions& options, 2224 ExpressionPathAftermath* final_task_on_target) 2225 { 2226 2227 const char* dummy_first_unparsed; 2228 ExpressionPathScanEndReason dummy_reason_to_stop; 2229 ExpressionPathEndResultType dummy_final_value_type; 2230 ExpressionPathAftermath dummy_final_task_on_target = ValueObject::eNothing; 2231 2232 ValueObjectSP ret_val = GetValueForExpressionPath_Impl(expression, 2233 first_unparsed ? first_unparsed : &dummy_first_unparsed, 2234 reason_to_stop ? reason_to_stop : &dummy_reason_to_stop, 2235 final_value_type ? final_value_type : &dummy_final_value_type, 2236 options, 2237 final_task_on_target ? final_task_on_target : &dummy_final_task_on_target); 2238 2239 if (!final_task_on_target || *final_task_on_target == ValueObject::eNothing) 2240 return ret_val; 2241 2242 if (ret_val.get() && ((final_value_type ? *final_value_type : dummy_final_value_type) == ePlain)) // I can only deref and takeaddress of plain objects 2243 { 2244 if ( (final_task_on_target ? *final_task_on_target : dummy_final_task_on_target) == ValueObject::eDereference) 2245 { 2246 Error error; 2247 ValueObjectSP final_value = ret_val->Dereference(error); 2248 if (error.Fail() || !final_value.get()) 2249 { 2250 if (reason_to_stop) 2251 *reason_to_stop = ValueObject::eDereferencingFailed; 2252 if (final_value_type) 2253 *final_value_type = ValueObject::eInvalid; 2254 return ValueObjectSP(); 2255 } 2256 else 2257 { 2258 if (final_task_on_target) 2259 *final_task_on_target = ValueObject::eNothing; 2260 return final_value; 2261 } 2262 } 2263 if (*final_task_on_target == ValueObject::eTakeAddress) 2264 { 2265 Error error; 2266 ValueObjectSP final_value = ret_val->AddressOf(error); 2267 if (error.Fail() || !final_value.get()) 2268 { 2269 if (reason_to_stop) 2270 *reason_to_stop = ValueObject::eTakingAddressFailed; 2271 if (final_value_type) 2272 *final_value_type = ValueObject::eInvalid; 2273 return ValueObjectSP(); 2274 } 2275 else 2276 { 2277 if (final_task_on_target) 2278 *final_task_on_target = ValueObject::eNothing; 2279 return final_value; 2280 } 2281 } 2282 } 2283 return ret_val; // final_task_on_target will still have its original value, so you know I did not do it 2284 } 2285 2286 int 2287 ValueObject::GetValuesForExpressionPath(const char* expression, 2288 ValueObjectListSP& list, 2289 const char** first_unparsed, 2290 ExpressionPathScanEndReason* reason_to_stop, 2291 ExpressionPathEndResultType* final_value_type, 2292 const GetValueForExpressionPathOptions& options, 2293 ExpressionPathAftermath* final_task_on_target) 2294 { 2295 const char* dummy_first_unparsed; 2296 ExpressionPathScanEndReason dummy_reason_to_stop; 2297 ExpressionPathEndResultType dummy_final_value_type; 2298 ExpressionPathAftermath dummy_final_task_on_target = ValueObject::eNothing; 2299 2300 ValueObjectSP ret_val = GetValueForExpressionPath_Impl(expression, 2301 first_unparsed ? first_unparsed : &dummy_first_unparsed, 2302 reason_to_stop ? reason_to_stop : &dummy_reason_to_stop, 2303 final_value_type ? final_value_type : &dummy_final_value_type, 2304 options, 2305 final_task_on_target ? final_task_on_target : &dummy_final_task_on_target); 2306 2307 if (!ret_val.get()) // if there are errors, I add nothing to the list 2308 return 0; 2309 2310 if (*reason_to_stop != eArrayRangeOperatorMet) 2311 { 2312 // I need not expand a range, just post-process the final value and return 2313 if (!final_task_on_target || *final_task_on_target == ValueObject::eNothing) 2314 { 2315 list->Append(ret_val); 2316 return 1; 2317 } 2318 if (ret_val.get() && *final_value_type == ePlain) // I can only deref and takeaddress of plain objects 2319 { 2320 if (*final_task_on_target == ValueObject::eDereference) 2321 { 2322 Error error; 2323 ValueObjectSP final_value = ret_val->Dereference(error); 2324 if (error.Fail() || !final_value.get()) 2325 { 2326 *reason_to_stop = ValueObject::eDereferencingFailed; 2327 *final_value_type = ValueObject::eInvalid; 2328 return 0; 2329 } 2330 else 2331 { 2332 *final_task_on_target = ValueObject::eNothing; 2333 list->Append(final_value); 2334 return 1; 2335 } 2336 } 2337 if (*final_task_on_target == ValueObject::eTakeAddress) 2338 { 2339 Error error; 2340 ValueObjectSP final_value = ret_val->AddressOf(error); 2341 if (error.Fail() || !final_value.get()) 2342 { 2343 *reason_to_stop = ValueObject::eTakingAddressFailed; 2344 *final_value_type = ValueObject::eInvalid; 2345 return 0; 2346 } 2347 else 2348 { 2349 *final_task_on_target = ValueObject::eNothing; 2350 list->Append(final_value); 2351 return 1; 2352 } 2353 } 2354 } 2355 } 2356 else 2357 { 2358 return ExpandArraySliceExpression(first_unparsed ? *first_unparsed : dummy_first_unparsed, 2359 first_unparsed ? first_unparsed : &dummy_first_unparsed, 2360 ret_val, 2361 list, 2362 reason_to_stop ? reason_to_stop : &dummy_reason_to_stop, 2363 final_value_type ? final_value_type : &dummy_final_value_type, 2364 options, 2365 final_task_on_target ? final_task_on_target : &dummy_final_task_on_target); 2366 } 2367 // in any non-covered case, just do the obviously right thing 2368 list->Append(ret_val); 2369 return 1; 2370 } 2371 2372 ValueObjectSP 2373 ValueObject::GetValueForExpressionPath_Impl(const char* expression_cstr, 2374 const char** first_unparsed, 2375 ExpressionPathScanEndReason* reason_to_stop, 2376 ExpressionPathEndResultType* final_result, 2377 const GetValueForExpressionPathOptions& options, 2378 ExpressionPathAftermath* what_next) 2379 { 2380 ValueObjectSP root = GetSP(); 2381 2382 if (!root.get()) 2383 return ValueObjectSP(); 2384 2385 *first_unparsed = expression_cstr; 2386 2387 while (true) 2388 { 2389 2390 const char* expression_cstr = *first_unparsed; // hide the top level expression_cstr 2391 2392 clang_type_t root_clang_type = root->GetClangType(); 2393 clang_type_t pointee_clang_type; 2394 Flags root_clang_type_info,pointee_clang_type_info; 2395 2396 root_clang_type_info = Flags(ClangASTContext::GetTypeInfo(root_clang_type, GetClangAST(), &pointee_clang_type)); 2397 if (pointee_clang_type) 2398 pointee_clang_type_info = Flags(ClangASTContext::GetTypeInfo(pointee_clang_type, GetClangAST(), NULL)); 2399 2400 if (!expression_cstr || *expression_cstr == '\0') 2401 { 2402 *reason_to_stop = ValueObject::eEndOfString; 2403 return root; 2404 } 2405 2406 switch (*expression_cstr) 2407 { 2408 case '-': 2409 { 2410 if (options.m_check_dot_vs_arrow_syntax && 2411 root_clang_type_info.Test(ClangASTContext::eTypeIsPointer) ) // if you are trying to use -> on a non-pointer and I must catch the error 2412 { 2413 *first_unparsed = expression_cstr; 2414 *reason_to_stop = ValueObject::eArrowInsteadOfDot; 2415 *final_result = ValueObject::eInvalid; 2416 return ValueObjectSP(); 2417 } 2418 if (root_clang_type_info.Test(ClangASTContext::eTypeIsObjC) && // if yo are trying to extract an ObjC IVar when this is forbidden 2419 root_clang_type_info.Test(ClangASTContext::eTypeIsPointer) && 2420 options.m_no_fragile_ivar) 2421 { 2422 *first_unparsed = expression_cstr; 2423 *reason_to_stop = ValueObject::eFragileIVarNotAllowed; 2424 *final_result = ValueObject::eInvalid; 2425 return ValueObjectSP(); 2426 } 2427 if (expression_cstr[1] != '>') 2428 { 2429 *first_unparsed = expression_cstr; 2430 *reason_to_stop = ValueObject::eUnexpectedSymbol; 2431 *final_result = ValueObject::eInvalid; 2432 return ValueObjectSP(); 2433 } 2434 expression_cstr++; // skip the - 2435 } 2436 case '.': // or fallthrough from -> 2437 { 2438 if (options.m_check_dot_vs_arrow_syntax && *expression_cstr == '.' && 2439 root_clang_type_info.Test(ClangASTContext::eTypeIsPointer)) // if you are trying to use . on a pointer and I must catch the error 2440 { 2441 *first_unparsed = expression_cstr; 2442 *reason_to_stop = ValueObject::eDotInsteadOfArrow; 2443 *final_result = ValueObject::eInvalid; 2444 return ValueObjectSP(); 2445 } 2446 expression_cstr++; // skip . 2447 const char *next_separator = strpbrk(expression_cstr+1,"-.["); 2448 ConstString child_name; 2449 if (!next_separator) // if no other separator just expand this last layer 2450 { 2451 child_name.SetCString (expression_cstr); 2452 ValueObjectSP child_valobj_sp = root->GetChildMemberWithName(child_name, true); 2453 2454 if (child_valobj_sp.get()) // we know we are done, so just return 2455 { 2456 *first_unparsed = '\0'; 2457 *reason_to_stop = ValueObject::eEndOfString; 2458 *final_result = ValueObject::ePlain; 2459 return child_valobj_sp; 2460 } 2461 else if (options.m_no_synthetic_children == false) // let's try with synthetic children 2462 { 2463 child_valobj_sp = root->GetSyntheticValue(eNoSyntheticFilter)->GetChildMemberWithName(child_name, true); 2464 } 2465 2466 // if we are here and options.m_no_synthetic_children is true, child_valobj_sp is going to be a NULL SP, 2467 // so we hit the "else" branch, and return an error 2468 if(child_valobj_sp.get()) // if it worked, just return 2469 { 2470 *first_unparsed = '\0'; 2471 *reason_to_stop = ValueObject::eEndOfString; 2472 *final_result = ValueObject::ePlain; 2473 return child_valobj_sp; 2474 } 2475 else 2476 { 2477 *first_unparsed = expression_cstr; 2478 *reason_to_stop = ValueObject::eNoSuchChild; 2479 *final_result = ValueObject::eInvalid; 2480 return ValueObjectSP(); 2481 } 2482 } 2483 else // other layers do expand 2484 { 2485 child_name.SetCStringWithLength(expression_cstr, next_separator - expression_cstr); 2486 ValueObjectSP child_valobj_sp = root->GetChildMemberWithName(child_name, true); 2487 if (child_valobj_sp.get()) // store the new root and move on 2488 { 2489 root = child_valobj_sp; 2490 *first_unparsed = next_separator; 2491 *final_result = ValueObject::ePlain; 2492 continue; 2493 } 2494 else if (options.m_no_synthetic_children == false) // let's try with synthetic children 2495 { 2496 child_valobj_sp = root->GetSyntheticValue(eUseSyntheticFilter)->GetChildMemberWithName(child_name, true); 2497 } 2498 2499 // if we are here and options.m_no_synthetic_children is true, child_valobj_sp is going to be a NULL SP, 2500 // so we hit the "else" branch, and return an error 2501 if(child_valobj_sp.get()) // if it worked, move on 2502 { 2503 root = child_valobj_sp; 2504 *first_unparsed = next_separator; 2505 *final_result = ValueObject::ePlain; 2506 continue; 2507 } 2508 else 2509 { 2510 *first_unparsed = expression_cstr; 2511 *reason_to_stop = ValueObject::eNoSuchChild; 2512 *final_result = ValueObject::eInvalid; 2513 return ValueObjectSP(); 2514 } 2515 } 2516 break; 2517 } 2518 case '[': 2519 { 2520 if (!root_clang_type_info.Test(ClangASTContext::eTypeIsArray) && !root_clang_type_info.Test(ClangASTContext::eTypeIsPointer)) // if this is not a T[] nor a T* 2521 { 2522 if (!root_clang_type_info.Test(ClangASTContext::eTypeIsScalar)) // if this is not even a scalar... 2523 { 2524 if (options.m_no_synthetic_children) // ...only chance left is synthetic 2525 { 2526 *first_unparsed = expression_cstr; 2527 *reason_to_stop = ValueObject::eRangeOperatorInvalid; 2528 *final_result = ValueObject::eInvalid; 2529 return ValueObjectSP(); 2530 } 2531 } 2532 else if (!options.m_allow_bitfields_syntax) // if this is a scalar, check that we can expand bitfields 2533 { 2534 *first_unparsed = expression_cstr; 2535 *reason_to_stop = ValueObject::eRangeOperatorNotAllowed; 2536 *final_result = ValueObject::eInvalid; 2537 return ValueObjectSP(); 2538 } 2539 } 2540 if (*(expression_cstr+1) == ']') // if this is an unbounded range it only works for arrays 2541 { 2542 if (!root_clang_type_info.Test(ClangASTContext::eTypeIsArray)) 2543 { 2544 *first_unparsed = expression_cstr; 2545 *reason_to_stop = ValueObject::eEmptyRangeNotAllowed; 2546 *final_result = ValueObject::eInvalid; 2547 return ValueObjectSP(); 2548 } 2549 else // even if something follows, we cannot expand unbounded ranges, just let the caller do it 2550 { 2551 *first_unparsed = expression_cstr+2; 2552 *reason_to_stop = ValueObject::eArrayRangeOperatorMet; 2553 *final_result = ValueObject::eUnboundedRange; 2554 return root; 2555 } 2556 } 2557 const char *separator_position = ::strchr(expression_cstr+1,'-'); 2558 const char *close_bracket_position = ::strchr(expression_cstr+1,']'); 2559 if (!close_bracket_position) // if there is no ], this is a syntax error 2560 { 2561 *first_unparsed = expression_cstr; 2562 *reason_to_stop = ValueObject::eUnexpectedSymbol; 2563 *final_result = ValueObject::eInvalid; 2564 return ValueObjectSP(); 2565 } 2566 if (!separator_position || separator_position > close_bracket_position) // if no separator, this is either [] or [N] 2567 { 2568 char *end = NULL; 2569 unsigned long index = ::strtoul (expression_cstr+1, &end, 0); 2570 if (!end || end != close_bracket_position) // if something weird is in our way return an error 2571 { 2572 *first_unparsed = expression_cstr; 2573 *reason_to_stop = ValueObject::eUnexpectedSymbol; 2574 *final_result = ValueObject::eInvalid; 2575 return ValueObjectSP(); 2576 } 2577 if (end - expression_cstr == 1) // if this is [], only return a valid value for arrays 2578 { 2579 if (root_clang_type_info.Test(ClangASTContext::eTypeIsArray)) 2580 { 2581 *first_unparsed = expression_cstr+2; 2582 *reason_to_stop = ValueObject::eArrayRangeOperatorMet; 2583 *final_result = ValueObject::eUnboundedRange; 2584 return root; 2585 } 2586 else 2587 { 2588 *first_unparsed = expression_cstr; 2589 *reason_to_stop = ValueObject::eEmptyRangeNotAllowed; 2590 *final_result = ValueObject::eInvalid; 2591 return ValueObjectSP(); 2592 } 2593 } 2594 // from here on we do have a valid index 2595 if (root_clang_type_info.Test(ClangASTContext::eTypeIsArray)) 2596 { 2597 ValueObjectSP child_valobj_sp = root->GetChildAtIndex(index, true); 2598 if (!child_valobj_sp) 2599 child_valobj_sp = root->GetSyntheticArrayMemberFromArray(index, true); 2600 if (!child_valobj_sp) 2601 if (root->HasSyntheticValue() && root->GetSyntheticValue(eUseSyntheticFilter)->GetNumChildren() > index) 2602 child_valobj_sp = root->GetSyntheticValue(eUseSyntheticFilter)->GetChildAtIndex(index, true); 2603 if (child_valobj_sp) 2604 { 2605 root = child_valobj_sp; 2606 *first_unparsed = end+1; // skip ] 2607 *final_result = ValueObject::ePlain; 2608 continue; 2609 } 2610 else 2611 { 2612 *first_unparsed = expression_cstr; 2613 *reason_to_stop = ValueObject::eNoSuchChild; 2614 *final_result = ValueObject::eInvalid; 2615 return ValueObjectSP(); 2616 } 2617 } 2618 else if (root_clang_type_info.Test(ClangASTContext::eTypeIsPointer)) 2619 { 2620 if (*what_next == ValueObject::eDereference && // if this is a ptr-to-scalar, I am accessing it by index and I would have deref'ed anyway, then do it now and use this as a bitfield 2621 pointee_clang_type_info.Test(ClangASTContext::eTypeIsScalar)) 2622 { 2623 Error error; 2624 root = root->Dereference(error); 2625 if (error.Fail() || !root.get()) 2626 { 2627 *first_unparsed = expression_cstr; 2628 *reason_to_stop = ValueObject::eDereferencingFailed; 2629 *final_result = ValueObject::eInvalid; 2630 return ValueObjectSP(); 2631 } 2632 else 2633 { 2634 *what_next = eNothing; 2635 continue; 2636 } 2637 } 2638 else 2639 { 2640 if (ClangASTType::GetMinimumLanguage(root->GetClangAST(), 2641 root->GetClangType()) == eLanguageTypeObjC 2642 && 2643 ClangASTContext::IsPointerType(ClangASTType::GetPointeeType(root->GetClangType())) == false 2644 && 2645 root->HasSyntheticValue() 2646 && 2647 options.m_no_synthetic_children == false) 2648 { 2649 root = root->GetSyntheticValue(eUseSyntheticFilter)->GetChildAtIndex(index, true); 2650 } 2651 else 2652 root = root->GetSyntheticArrayMemberFromPointer(index, true); 2653 if (!root.get()) 2654 { 2655 *first_unparsed = expression_cstr; 2656 *reason_to_stop = ValueObject::eNoSuchChild; 2657 *final_result = ValueObject::eInvalid; 2658 return ValueObjectSP(); 2659 } 2660 else 2661 { 2662 *first_unparsed = end+1; // skip ] 2663 *final_result = ValueObject::ePlain; 2664 continue; 2665 } 2666 } 2667 } 2668 else if (ClangASTContext::IsScalarType(root_clang_type)) 2669 { 2670 root = root->GetSyntheticBitFieldChild(index, index, true); 2671 if (!root.get()) 2672 { 2673 *first_unparsed = expression_cstr; 2674 *reason_to_stop = ValueObject::eNoSuchChild; 2675 *final_result = ValueObject::eInvalid; 2676 return ValueObjectSP(); 2677 } 2678 else // we do not know how to expand members of bitfields, so we just return and let the caller do any further processing 2679 { 2680 *first_unparsed = end+1; // skip ] 2681 *reason_to_stop = ValueObject::eBitfieldRangeOperatorMet; 2682 *final_result = ValueObject::eBitfield; 2683 return root; 2684 } 2685 } 2686 else if (root->HasSyntheticValue() && options.m_no_synthetic_children == false) 2687 { 2688 root = root->GetSyntheticValue(eUseSyntheticFilter)->GetChildAtIndex(index, true); 2689 if (!root.get()) 2690 { 2691 *first_unparsed = expression_cstr; 2692 *reason_to_stop = ValueObject::eNoSuchChild; 2693 *final_result = ValueObject::eInvalid; 2694 return ValueObjectSP(); 2695 } 2696 else 2697 { 2698 *first_unparsed = end+1; // skip ] 2699 *final_result = ValueObject::ePlain; 2700 continue; 2701 } 2702 } 2703 else 2704 { 2705 *first_unparsed = expression_cstr; 2706 *reason_to_stop = ValueObject::eNoSuchChild; 2707 *final_result = ValueObject::eInvalid; 2708 return ValueObjectSP(); 2709 } 2710 } 2711 else // we have a low and a high index 2712 { 2713 char *end = NULL; 2714 unsigned long index_lower = ::strtoul (expression_cstr+1, &end, 0); 2715 if (!end || end != separator_position) // if something weird is in our way return an error 2716 { 2717 *first_unparsed = expression_cstr; 2718 *reason_to_stop = ValueObject::eUnexpectedSymbol; 2719 *final_result = ValueObject::eInvalid; 2720 return ValueObjectSP(); 2721 } 2722 unsigned long index_higher = ::strtoul (separator_position+1, &end, 0); 2723 if (!end || end != close_bracket_position) // if something weird is in our way return an error 2724 { 2725 *first_unparsed = expression_cstr; 2726 *reason_to_stop = ValueObject::eUnexpectedSymbol; 2727 *final_result = ValueObject::eInvalid; 2728 return ValueObjectSP(); 2729 } 2730 if (index_lower > index_higher) // swap indices if required 2731 { 2732 unsigned long temp = index_lower; 2733 index_lower = index_higher; 2734 index_higher = temp; 2735 } 2736 if (root_clang_type_info.Test(ClangASTContext::eTypeIsScalar)) // expansion only works for scalars 2737 { 2738 root = root->GetSyntheticBitFieldChild(index_lower, index_higher, true); 2739 if (!root.get()) 2740 { 2741 *first_unparsed = expression_cstr; 2742 *reason_to_stop = ValueObject::eNoSuchChild; 2743 *final_result = ValueObject::eInvalid; 2744 return ValueObjectSP(); 2745 } 2746 else 2747 { 2748 *first_unparsed = end+1; // skip ] 2749 *reason_to_stop = ValueObject::eBitfieldRangeOperatorMet; 2750 *final_result = ValueObject::eBitfield; 2751 return root; 2752 } 2753 } 2754 else if (root_clang_type_info.Test(ClangASTContext::eTypeIsPointer) && // if this is a ptr-to-scalar, I am accessing it by index and I would have deref'ed anyway, then do it now and use this as a bitfield 2755 *what_next == ValueObject::eDereference && 2756 pointee_clang_type_info.Test(ClangASTContext::eTypeIsScalar)) 2757 { 2758 Error error; 2759 root = root->Dereference(error); 2760 if (error.Fail() || !root.get()) 2761 { 2762 *first_unparsed = expression_cstr; 2763 *reason_to_stop = ValueObject::eDereferencingFailed; 2764 *final_result = ValueObject::eInvalid; 2765 return ValueObjectSP(); 2766 } 2767 else 2768 { 2769 *what_next = ValueObject::eNothing; 2770 continue; 2771 } 2772 } 2773 else 2774 { 2775 *first_unparsed = expression_cstr; 2776 *reason_to_stop = ValueObject::eArrayRangeOperatorMet; 2777 *final_result = ValueObject::eBoundedRange; 2778 return root; 2779 } 2780 } 2781 break; 2782 } 2783 default: // some non-separator is in the way 2784 { 2785 *first_unparsed = expression_cstr; 2786 *reason_to_stop = ValueObject::eUnexpectedSymbol; 2787 *final_result = ValueObject::eInvalid; 2788 return ValueObjectSP(); 2789 break; 2790 } 2791 } 2792 } 2793 } 2794 2795 int 2796 ValueObject::ExpandArraySliceExpression(const char* expression_cstr, 2797 const char** first_unparsed, 2798 ValueObjectSP root, 2799 ValueObjectListSP& list, 2800 ExpressionPathScanEndReason* reason_to_stop, 2801 ExpressionPathEndResultType* final_result, 2802 const GetValueForExpressionPathOptions& options, 2803 ExpressionPathAftermath* what_next) 2804 { 2805 if (!root.get()) 2806 return 0; 2807 2808 *first_unparsed = expression_cstr; 2809 2810 while (true) 2811 { 2812 2813 const char* expression_cstr = *first_unparsed; // hide the top level expression_cstr 2814 2815 clang_type_t root_clang_type = root->GetClangType(); 2816 clang_type_t pointee_clang_type; 2817 Flags root_clang_type_info,pointee_clang_type_info; 2818 2819 root_clang_type_info = Flags(ClangASTContext::GetTypeInfo(root_clang_type, GetClangAST(), &pointee_clang_type)); 2820 if (pointee_clang_type) 2821 pointee_clang_type_info = Flags(ClangASTContext::GetTypeInfo(pointee_clang_type, GetClangAST(), NULL)); 2822 2823 if (!expression_cstr || *expression_cstr == '\0') 2824 { 2825 *reason_to_stop = ValueObject::eEndOfString; 2826 list->Append(root); 2827 return 1; 2828 } 2829 2830 switch (*expression_cstr) 2831 { 2832 case '[': 2833 { 2834 if (!root_clang_type_info.Test(ClangASTContext::eTypeIsArray) && !root_clang_type_info.Test(ClangASTContext::eTypeIsPointer)) // if this is not a T[] nor a T* 2835 { 2836 if (!root_clang_type_info.Test(ClangASTContext::eTypeIsScalar)) // if this is not even a scalar, this syntax is just plain wrong! 2837 { 2838 *first_unparsed = expression_cstr; 2839 *reason_to_stop = ValueObject::eRangeOperatorInvalid; 2840 *final_result = ValueObject::eInvalid; 2841 return 0; 2842 } 2843 else if (!options.m_allow_bitfields_syntax) // if this is a scalar, check that we can expand bitfields 2844 { 2845 *first_unparsed = expression_cstr; 2846 *reason_to_stop = ValueObject::eRangeOperatorNotAllowed; 2847 *final_result = ValueObject::eInvalid; 2848 return 0; 2849 } 2850 } 2851 if (*(expression_cstr+1) == ']') // if this is an unbounded range it only works for arrays 2852 { 2853 if (!root_clang_type_info.Test(ClangASTContext::eTypeIsArray)) 2854 { 2855 *first_unparsed = expression_cstr; 2856 *reason_to_stop = ValueObject::eEmptyRangeNotAllowed; 2857 *final_result = ValueObject::eInvalid; 2858 return 0; 2859 } 2860 else // expand this into list 2861 { 2862 int max_index = root->GetNumChildren() - 1; 2863 for (int index = 0; index < max_index; index++) 2864 { 2865 ValueObjectSP child = 2866 root->GetChildAtIndex(index, true); 2867 list->Append(child); 2868 } 2869 *first_unparsed = expression_cstr+2; 2870 *reason_to_stop = ValueObject::eRangeOperatorExpanded; 2871 *final_result = ValueObject::eValueObjectList; 2872 return max_index; // tell me number of items I added to the VOList 2873 } 2874 } 2875 const char *separator_position = ::strchr(expression_cstr+1,'-'); 2876 const char *close_bracket_position = ::strchr(expression_cstr+1,']'); 2877 if (!close_bracket_position) // if there is no ], this is a syntax error 2878 { 2879 *first_unparsed = expression_cstr; 2880 *reason_to_stop = ValueObject::eUnexpectedSymbol; 2881 *final_result = ValueObject::eInvalid; 2882 return 0; 2883 } 2884 if (!separator_position || separator_position > close_bracket_position) // if no separator, this is either [] or [N] 2885 { 2886 char *end = NULL; 2887 unsigned long index = ::strtoul (expression_cstr+1, &end, 0); 2888 if (!end || end != close_bracket_position) // if something weird is in our way return an error 2889 { 2890 *first_unparsed = expression_cstr; 2891 *reason_to_stop = ValueObject::eUnexpectedSymbol; 2892 *final_result = ValueObject::eInvalid; 2893 return 0; 2894 } 2895 if (end - expression_cstr == 1) // if this is [], only return a valid value for arrays 2896 { 2897 if (root_clang_type_info.Test(ClangASTContext::eTypeIsArray)) 2898 { 2899 int max_index = root->GetNumChildren() - 1; 2900 for (int index = 0; index < max_index; index++) 2901 { 2902 ValueObjectSP child = 2903 root->GetChildAtIndex(index, true); 2904 list->Append(child); 2905 } 2906 *first_unparsed = expression_cstr+2; 2907 *reason_to_stop = ValueObject::eRangeOperatorExpanded; 2908 *final_result = ValueObject::eValueObjectList; 2909 return max_index; // tell me number of items I added to the VOList 2910 } 2911 else 2912 { 2913 *first_unparsed = expression_cstr; 2914 *reason_to_stop = ValueObject::eEmptyRangeNotAllowed; 2915 *final_result = ValueObject::eInvalid; 2916 return 0; 2917 } 2918 } 2919 // from here on we do have a valid index 2920 if (root_clang_type_info.Test(ClangASTContext::eTypeIsArray)) 2921 { 2922 root = root->GetChildAtIndex(index, true); 2923 if (!root.get()) 2924 { 2925 *first_unparsed = expression_cstr; 2926 *reason_to_stop = ValueObject::eNoSuchChild; 2927 *final_result = ValueObject::eInvalid; 2928 return 0; 2929 } 2930 else 2931 { 2932 list->Append(root); 2933 *first_unparsed = end+1; // skip ] 2934 *reason_to_stop = ValueObject::eRangeOperatorExpanded; 2935 *final_result = ValueObject::eValueObjectList; 2936 return 1; 2937 } 2938 } 2939 else if (root_clang_type_info.Test(ClangASTContext::eTypeIsPointer)) 2940 { 2941 if (*what_next == ValueObject::eDereference && // if this is a ptr-to-scalar, I am accessing it by index and I would have deref'ed anyway, then do it now and use this as a bitfield 2942 pointee_clang_type_info.Test(ClangASTContext::eTypeIsScalar)) 2943 { 2944 Error error; 2945 root = root->Dereference(error); 2946 if (error.Fail() || !root.get()) 2947 { 2948 *first_unparsed = expression_cstr; 2949 *reason_to_stop = ValueObject::eDereferencingFailed; 2950 *final_result = ValueObject::eInvalid; 2951 return 0; 2952 } 2953 else 2954 { 2955 *what_next = eNothing; 2956 continue; 2957 } 2958 } 2959 else 2960 { 2961 root = root->GetSyntheticArrayMemberFromPointer(index, true); 2962 if (!root.get()) 2963 { 2964 *first_unparsed = expression_cstr; 2965 *reason_to_stop = ValueObject::eNoSuchChild; 2966 *final_result = ValueObject::eInvalid; 2967 return 0; 2968 } 2969 else 2970 { 2971 list->Append(root); 2972 *first_unparsed = end+1; // skip ] 2973 *reason_to_stop = ValueObject::eRangeOperatorExpanded; 2974 *final_result = ValueObject::eValueObjectList; 2975 return 1; 2976 } 2977 } 2978 } 2979 else /*if (ClangASTContext::IsScalarType(root_clang_type))*/ 2980 { 2981 root = root->GetSyntheticBitFieldChild(index, index, true); 2982 if (!root.get()) 2983 { 2984 *first_unparsed = expression_cstr; 2985 *reason_to_stop = ValueObject::eNoSuchChild; 2986 *final_result = ValueObject::eInvalid; 2987 return 0; 2988 } 2989 else // we do not know how to expand members of bitfields, so we just return and let the caller do any further processing 2990 { 2991 list->Append(root); 2992 *first_unparsed = end+1; // skip ] 2993 *reason_to_stop = ValueObject::eRangeOperatorExpanded; 2994 *final_result = ValueObject::eValueObjectList; 2995 return 1; 2996 } 2997 } 2998 } 2999 else // we have a low and a high index 3000 { 3001 char *end = NULL; 3002 unsigned long index_lower = ::strtoul (expression_cstr+1, &end, 0); 3003 if (!end || end != separator_position) // if something weird is in our way return an error 3004 { 3005 *first_unparsed = expression_cstr; 3006 *reason_to_stop = ValueObject::eUnexpectedSymbol; 3007 *final_result = ValueObject::eInvalid; 3008 return 0; 3009 } 3010 unsigned long index_higher = ::strtoul (separator_position+1, &end, 0); 3011 if (!end || end != close_bracket_position) // if something weird is in our way return an error 3012 { 3013 *first_unparsed = expression_cstr; 3014 *reason_to_stop = ValueObject::eUnexpectedSymbol; 3015 *final_result = ValueObject::eInvalid; 3016 return 0; 3017 } 3018 if (index_lower > index_higher) // swap indices if required 3019 { 3020 unsigned long temp = index_lower; 3021 index_lower = index_higher; 3022 index_higher = temp; 3023 } 3024 if (root_clang_type_info.Test(ClangASTContext::eTypeIsScalar)) // expansion only works for scalars 3025 { 3026 root = root->GetSyntheticBitFieldChild(index_lower, index_higher, true); 3027 if (!root.get()) 3028 { 3029 *first_unparsed = expression_cstr; 3030 *reason_to_stop = ValueObject::eNoSuchChild; 3031 *final_result = ValueObject::eInvalid; 3032 return 0; 3033 } 3034 else 3035 { 3036 list->Append(root); 3037 *first_unparsed = end+1; // skip ] 3038 *reason_to_stop = ValueObject::eRangeOperatorExpanded; 3039 *final_result = ValueObject::eValueObjectList; 3040 return 1; 3041 } 3042 } 3043 else if (root_clang_type_info.Test(ClangASTContext::eTypeIsPointer) && // if this is a ptr-to-scalar, I am accessing it by index and I would have deref'ed anyway, then do it now and use this as a bitfield 3044 *what_next == ValueObject::eDereference && 3045 pointee_clang_type_info.Test(ClangASTContext::eTypeIsScalar)) 3046 { 3047 Error error; 3048 root = root->Dereference(error); 3049 if (error.Fail() || !root.get()) 3050 { 3051 *first_unparsed = expression_cstr; 3052 *reason_to_stop = ValueObject::eDereferencingFailed; 3053 *final_result = ValueObject::eInvalid; 3054 return 0; 3055 } 3056 else 3057 { 3058 *what_next = ValueObject::eNothing; 3059 continue; 3060 } 3061 } 3062 else 3063 { 3064 for (unsigned long index = index_lower; 3065 index <= index_higher; index++) 3066 { 3067 ValueObjectSP child = 3068 root->GetChildAtIndex(index, true); 3069 list->Append(child); 3070 } 3071 *first_unparsed = end+1; 3072 *reason_to_stop = ValueObject::eRangeOperatorExpanded; 3073 *final_result = ValueObject::eValueObjectList; 3074 return index_higher-index_lower+1; // tell me number of items I added to the VOList 3075 } 3076 } 3077 break; 3078 } 3079 default: // some non-[ separator, or something entirely wrong, is in the way 3080 { 3081 *first_unparsed = expression_cstr; 3082 *reason_to_stop = ValueObject::eUnexpectedSymbol; 3083 *final_result = ValueObject::eInvalid; 3084 return 0; 3085 break; 3086 } 3087 } 3088 } 3089 } 3090 3091 static void 3092 DumpValueObject_Impl (Stream &s, 3093 ValueObject *valobj, 3094 const ValueObject::DumpValueObjectOptions& options, 3095 uint32_t ptr_depth, 3096 uint32_t curr_depth) 3097 { 3098 if (valobj) 3099 { 3100 bool update_success = valobj->UpdateValueIfNeeded (options.m_use_dynamic, true); 3101 3102 const char *root_valobj_name = 3103 options.m_root_valobj_name.empty() ? 3104 valobj->GetName().AsCString() : 3105 options.m_root_valobj_name.c_str(); 3106 3107 if (update_success && options.m_use_dynamic != eNoDynamicValues) 3108 { 3109 ValueObject *dynamic_value = valobj->GetDynamicValue(options.m_use_dynamic).get(); 3110 if (dynamic_value) 3111 valobj = dynamic_value; 3112 } 3113 3114 clang_type_t clang_type = valobj->GetClangType(); 3115 3116 const Flags type_flags (ClangASTContext::GetTypeInfo (clang_type, NULL, NULL)); 3117 const char *err_cstr = NULL; 3118 const bool has_children = type_flags.Test (ClangASTContext::eTypeHasChildren); 3119 const bool has_value = type_flags.Test (ClangASTContext::eTypeHasValue); 3120 3121 const bool print_valobj = options.m_flat_output == false || has_value; 3122 3123 if (print_valobj) 3124 { 3125 if (options.m_show_location) 3126 { 3127 s.Printf("%s: ", valobj->GetLocationAsCString()); 3128 } 3129 3130 s.Indent(); 3131 3132 // Always show the type for the top level items. 3133 if (options.m_show_types || (curr_depth == 0 && !options.m_flat_output)) 3134 { 3135 const char* typeName = valobj->GetTypeName().AsCString("<invalid type>"); 3136 s.Printf("(%s", typeName); 3137 // only show dynamic types if the user really wants to see types 3138 if (options.m_show_types && options.m_use_dynamic != eNoDynamicValues && 3139 (/*strstr(typeName, "id") == typeName ||*/ 3140 ClangASTType::GetMinimumLanguage(valobj->GetClangAST(), valobj->GetClangType()) == eLanguageTypeObjC)) 3141 { 3142 ExecutionContext exe_ctx (valobj->GetExecutionContextRef()); 3143 Process *process = exe_ctx.GetProcessPtr(); 3144 if (process == NULL) 3145 s.Printf(", dynamic type: unknown) "); 3146 else 3147 { 3148 ObjCLanguageRuntime *runtime = process->GetObjCLanguageRuntime(); 3149 if (runtime == NULL) 3150 s.Printf(", dynamic type: unknown) "); 3151 else 3152 { 3153 ObjCLanguageRuntime::ObjCISA isa = runtime->GetISA(*valobj); 3154 if (!runtime->IsValidISA(isa)) 3155 s.Printf(", dynamic type: unknown) "); 3156 else 3157 s.Printf(", dynamic type: %s) ", 3158 runtime->GetActualTypeName(isa).GetCString()); 3159 } 3160 } 3161 } 3162 else 3163 s.Printf(") "); 3164 } 3165 3166 3167 if (options.m_flat_output) 3168 { 3169 // If we are showing types, also qualify the C++ base classes 3170 const bool qualify_cxx_base_classes = options.m_show_types; 3171 valobj->GetExpressionPath(s, qualify_cxx_base_classes); 3172 s.PutCString(" ="); 3173 } 3174 else 3175 { 3176 const char *name_cstr = root_valobj_name ? root_valobj_name : valobj->GetName().AsCString(""); 3177 s.Printf ("%s =", name_cstr); 3178 } 3179 3180 if (!options.m_scope_already_checked && !valobj->IsInScope()) 3181 { 3182 err_cstr = "out of scope"; 3183 } 3184 } 3185 3186 std::string summary_str; 3187 std::string value_str; 3188 const char *val_cstr = NULL; 3189 const char *sum_cstr = NULL; 3190 TypeSummaryImpl* entry = options.m_summary_sp ? options.m_summary_sp.get() : valobj->GetSummaryFormat().get(); 3191 3192 if (options.m_omit_summary_depth > 0) 3193 entry = NULL; 3194 3195 if (err_cstr == NULL) 3196 { 3197 if (options.m_format != eFormatDefault && options.m_format != valobj->GetFormat()) 3198 { 3199 valobj->GetValueAsCString(options.m_format, 3200 value_str); 3201 } 3202 else 3203 { 3204 val_cstr = valobj->GetValueAsCString(); 3205 if (val_cstr) 3206 value_str = val_cstr; 3207 } 3208 err_cstr = valobj->GetError().AsCString(); 3209 } 3210 3211 if (err_cstr) 3212 { 3213 s.Printf (" <%s>\n", err_cstr); 3214 } 3215 else 3216 { 3217 const bool is_ref = type_flags.Test (ClangASTContext::eTypeIsReference); 3218 if (print_valobj) 3219 { 3220 if (options.m_omit_summary_depth == 0) 3221 { 3222 if (options.m_summary_sp) 3223 { 3224 valobj->GetSummaryAsCString(entry, summary_str); 3225 sum_cstr = summary_str.c_str(); 3226 } 3227 else 3228 sum_cstr = valobj->GetSummaryAsCString(); 3229 } 3230 3231 // Make sure we have a value and make sure the summary didn't 3232 // specify that the value should not be printed 3233 if (!value_str.empty() && (entry == NULL || entry->DoesPrintValue() || sum_cstr == NULL)) 3234 s.Printf(" %s", value_str.c_str()); 3235 3236 if (sum_cstr) 3237 s.Printf(" %s", sum_cstr); 3238 3239 if (options.m_use_objc) 3240 { 3241 const char *object_desc = valobj->GetObjectDescription(); 3242 if (object_desc) 3243 s.Printf(" %s\n", object_desc); 3244 else 3245 s.Printf (" [no Objective-C description available]\n"); 3246 return; 3247 } 3248 } 3249 3250 if (curr_depth < options.m_max_depth) 3251 { 3252 // We will show children for all concrete types. We won't show 3253 // pointer contents unless a pointer depth has been specified. 3254 // We won't reference contents unless the reference is the 3255 // root object (depth of zero). 3256 bool print_children = true; 3257 3258 // Use a new temporary pointer depth in case we override the 3259 // current pointer depth below... 3260 uint32_t curr_ptr_depth = ptr_depth; 3261 3262 const bool is_ptr = type_flags.Test (ClangASTContext::eTypeIsPointer); 3263 if (is_ptr || is_ref) 3264 { 3265 // We have a pointer or reference whose value is an address. 3266 // Make sure that address is not NULL 3267 AddressType ptr_address_type; 3268 if (valobj->GetPointerValue (&ptr_address_type) == 0) 3269 print_children = false; 3270 3271 else if (is_ref && curr_depth == 0) 3272 { 3273 // If this is the root object (depth is zero) that we are showing 3274 // and it is a reference, and no pointer depth has been supplied 3275 // print out what it references. Don't do this at deeper depths 3276 // otherwise we can end up with infinite recursion... 3277 curr_ptr_depth = 1; 3278 } 3279 3280 if (curr_ptr_depth == 0) 3281 print_children = false; 3282 } 3283 3284 if (print_children && (!entry || entry->DoesPrintChildren() || !sum_cstr)) 3285 { 3286 ValueObjectSP synth_valobj = valobj->GetSyntheticValue (options.m_use_synthetic ? 3287 eUseSyntheticFilter : 3288 eNoSyntheticFilter); 3289 uint32_t num_children = synth_valobj->GetNumChildren(); 3290 bool print_dotdotdot = false; 3291 if (num_children) 3292 { 3293 if (options.m_flat_output) 3294 { 3295 if (print_valobj) 3296 s.EOL(); 3297 } 3298 else 3299 { 3300 if (print_valobj) 3301 s.PutCString(is_ref ? ": {\n" : " {\n"); 3302 s.IndentMore(); 3303 } 3304 3305 uint32_t max_num_children = valobj->GetTargetSP()->GetMaximumNumberOfChildrenToDisplay(); 3306 3307 if (num_children > max_num_children && !options.m_ignore_cap) 3308 { 3309 num_children = max_num_children; 3310 print_dotdotdot = true; 3311 } 3312 3313 ValueObject::DumpValueObjectOptions child_options(options); 3314 child_options.SetFormat().SetSummary().SetRootValueObjectName(); 3315 child_options.SetScopeChecked(true) 3316 .SetOmitSummaryDepth(child_options.m_omit_summary_depth > 1 ? child_options.m_omit_summary_depth - 1 : 0); 3317 for (uint32_t idx=0; idx<num_children; ++idx) 3318 { 3319 ValueObjectSP child_sp(synth_valobj->GetChildAtIndex(idx, true)); 3320 if (child_sp.get()) 3321 { 3322 DumpValueObject_Impl (s, 3323 child_sp.get(), 3324 child_options, 3325 (is_ptr || is_ref) ? curr_ptr_depth - 1 : curr_ptr_depth, 3326 curr_depth + 1); 3327 } 3328 } 3329 3330 if (!options.m_flat_output) 3331 { 3332 if (print_dotdotdot) 3333 { 3334 ExecutionContext exe_ctx (valobj->GetExecutionContextRef()); 3335 Target *target = exe_ctx.GetTargetPtr(); 3336 if (target) 3337 target->GetDebugger().GetCommandInterpreter().ChildrenTruncated(); 3338 s.Indent("...\n"); 3339 } 3340 s.IndentLess(); 3341 s.Indent("}\n"); 3342 } 3343 } 3344 else if (has_children) 3345 { 3346 // Aggregate, no children... 3347 if (print_valobj) 3348 s.PutCString(" {}\n"); 3349 } 3350 else 3351 { 3352 if (print_valobj) 3353 s.EOL(); 3354 } 3355 3356 } 3357 else 3358 { 3359 s.EOL(); 3360 } 3361 } 3362 else 3363 { 3364 if (has_children && print_valobj) 3365 { 3366 s.PutCString("{...}\n"); 3367 } 3368 } 3369 } 3370 } 3371 } 3372 3373 void 3374 ValueObject::DumpValueObject (Stream &s, 3375 ValueObject *valobj) 3376 { 3377 3378 if (!valobj) 3379 return; 3380 3381 DumpValueObject_Impl(s, 3382 valobj, 3383 DumpValueObjectOptions::DefaultOptions(), 3384 0, 3385 0); 3386 } 3387 3388 void 3389 ValueObject::DumpValueObject (Stream &s, 3390 ValueObject *valobj, 3391 const DumpValueObjectOptions& options) 3392 { 3393 DumpValueObject_Impl(s, 3394 valobj, 3395 options, 3396 options.m_max_ptr_depth, // max pointer depth allowed, we will go down from here 3397 0 // current object depth is 0 since we are just starting 3398 ); 3399 } 3400 3401 ValueObjectSP 3402 ValueObject::CreateConstantValue (const ConstString &name) 3403 { 3404 ValueObjectSP valobj_sp; 3405 3406 if (UpdateValueIfNeeded(false) && m_error.Success()) 3407 { 3408 ExecutionContext exe_ctx (GetExecutionContextRef()); 3409 clang::ASTContext *ast = GetClangAST (); 3410 3411 DataExtractor data; 3412 data.SetByteOrder (m_data.GetByteOrder()); 3413 data.SetAddressByteSize(m_data.GetAddressByteSize()); 3414 3415 m_error = m_value.GetValueAsData (&exe_ctx, ast, data, 0, GetModule().get()); 3416 3417 valobj_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(), 3418 ast, 3419 GetClangType(), 3420 name, 3421 data, 3422 GetAddressOf()); 3423 } 3424 3425 if (!valobj_sp) 3426 { 3427 valobj_sp = ValueObjectConstResult::Create (NULL, m_error); 3428 } 3429 return valobj_sp; 3430 } 3431 3432 ValueObjectSP 3433 ValueObject::Dereference (Error &error) 3434 { 3435 if (m_deref_valobj) 3436 return m_deref_valobj->GetSP(); 3437 3438 const bool is_pointer_type = IsPointerType(); 3439 if (is_pointer_type) 3440 { 3441 bool omit_empty_base_classes = true; 3442 bool ignore_array_bounds = false; 3443 3444 std::string child_name_str; 3445 uint32_t child_byte_size = 0; 3446 int32_t child_byte_offset = 0; 3447 uint32_t child_bitfield_bit_size = 0; 3448 uint32_t child_bitfield_bit_offset = 0; 3449 bool child_is_base_class = false; 3450 bool child_is_deref_of_parent = false; 3451 const bool transparent_pointers = false; 3452 clang::ASTContext *clang_ast = GetClangAST(); 3453 clang_type_t clang_type = GetClangType(); 3454 clang_type_t child_clang_type; 3455 3456 ExecutionContext exe_ctx (GetExecutionContextRef()); 3457 3458 child_clang_type = ClangASTContext::GetChildClangTypeAtIndex (&exe_ctx, 3459 clang_ast, 3460 GetName().GetCString(), 3461 clang_type, 3462 0, 3463 transparent_pointers, 3464 omit_empty_base_classes, 3465 ignore_array_bounds, 3466 child_name_str, 3467 child_byte_size, 3468 child_byte_offset, 3469 child_bitfield_bit_size, 3470 child_bitfield_bit_offset, 3471 child_is_base_class, 3472 child_is_deref_of_parent); 3473 if (child_clang_type && child_byte_size) 3474 { 3475 ConstString child_name; 3476 if (!child_name_str.empty()) 3477 child_name.SetCString (child_name_str.c_str()); 3478 3479 m_deref_valobj = new ValueObjectChild (*this, 3480 clang_ast, 3481 child_clang_type, 3482 child_name, 3483 child_byte_size, 3484 child_byte_offset, 3485 child_bitfield_bit_size, 3486 child_bitfield_bit_offset, 3487 child_is_base_class, 3488 child_is_deref_of_parent, 3489 eAddressTypeInvalid); 3490 } 3491 } 3492 3493 if (m_deref_valobj) 3494 { 3495 error.Clear(); 3496 return m_deref_valobj->GetSP(); 3497 } 3498 else 3499 { 3500 StreamString strm; 3501 GetExpressionPath(strm, true); 3502 3503 if (is_pointer_type) 3504 error.SetErrorStringWithFormat("dereference failed: (%s) %s", GetTypeName().AsCString("<invalid type>"), strm.GetString().c_str()); 3505 else 3506 error.SetErrorStringWithFormat("not a pointer type: (%s) %s", GetTypeName().AsCString("<invalid type>"), strm.GetString().c_str()); 3507 return ValueObjectSP(); 3508 } 3509 } 3510 3511 ValueObjectSP 3512 ValueObject::AddressOf (Error &error) 3513 { 3514 if (m_addr_of_valobj_sp) 3515 return m_addr_of_valobj_sp; 3516 3517 AddressType address_type = eAddressTypeInvalid; 3518 const bool scalar_is_load_address = false; 3519 addr_t addr = GetAddressOf (scalar_is_load_address, &address_type); 3520 error.Clear(); 3521 if (addr != LLDB_INVALID_ADDRESS) 3522 { 3523 switch (address_type) 3524 { 3525 default: 3526 case eAddressTypeInvalid: 3527 { 3528 StreamString expr_path_strm; 3529 GetExpressionPath(expr_path_strm, true); 3530 error.SetErrorStringWithFormat("'%s' is not in memory", expr_path_strm.GetString().c_str()); 3531 } 3532 break; 3533 3534 case eAddressTypeFile: 3535 case eAddressTypeLoad: 3536 case eAddressTypeHost: 3537 { 3538 clang::ASTContext *ast = GetClangAST(); 3539 clang_type_t clang_type = GetClangType(); 3540 if (ast && clang_type) 3541 { 3542 std::string name (1, '&'); 3543 name.append (m_name.AsCString("")); 3544 ExecutionContext exe_ctx (GetExecutionContextRef()); 3545 m_addr_of_valobj_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(), 3546 ast, 3547 ClangASTContext::CreatePointerType (ast, clang_type), 3548 ConstString (name.c_str()), 3549 addr, 3550 eAddressTypeInvalid, 3551 m_data.GetAddressByteSize()); 3552 } 3553 } 3554 break; 3555 } 3556 } 3557 return m_addr_of_valobj_sp; 3558 } 3559 3560 ValueObjectSP 3561 ValueObject::Cast (const ClangASTType &clang_ast_type) 3562 { 3563 return ValueObjectCast::Create (*this, GetName(), clang_ast_type); 3564 } 3565 3566 ValueObjectSP 3567 ValueObject::CastPointerType (const char *name, ClangASTType &clang_ast_type) 3568 { 3569 ValueObjectSP valobj_sp; 3570 AddressType address_type; 3571 addr_t ptr_value = GetPointerValue (&address_type); 3572 3573 if (ptr_value != LLDB_INVALID_ADDRESS) 3574 { 3575 Address ptr_addr (ptr_value); 3576 ExecutionContext exe_ctx (GetExecutionContextRef()); 3577 valobj_sp = ValueObjectMemory::Create (exe_ctx.GetBestExecutionContextScope(), 3578 name, 3579 ptr_addr, 3580 clang_ast_type); 3581 } 3582 return valobj_sp; 3583 } 3584 3585 ValueObjectSP 3586 ValueObject::CastPointerType (const char *name, TypeSP &type_sp) 3587 { 3588 ValueObjectSP valobj_sp; 3589 AddressType address_type; 3590 addr_t ptr_value = GetPointerValue (&address_type); 3591 3592 if (ptr_value != LLDB_INVALID_ADDRESS) 3593 { 3594 Address ptr_addr (ptr_value); 3595 ExecutionContext exe_ctx (GetExecutionContextRef()); 3596 valobj_sp = ValueObjectMemory::Create (exe_ctx.GetBestExecutionContextScope(), 3597 name, 3598 ptr_addr, 3599 type_sp); 3600 } 3601 return valobj_sp; 3602 } 3603 3604 ValueObject::EvaluationPoint::EvaluationPoint () : 3605 m_mod_id(), 3606 m_exe_ctx_ref(), 3607 m_needs_update (true), 3608 m_first_update (true) 3609 { 3610 } 3611 3612 ValueObject::EvaluationPoint::EvaluationPoint (ExecutionContextScope *exe_scope, bool use_selected): 3613 m_mod_id(), 3614 m_exe_ctx_ref(), 3615 m_needs_update (true), 3616 m_first_update (true) 3617 { 3618 ExecutionContext exe_ctx(exe_scope); 3619 TargetSP target_sp (exe_ctx.GetTargetSP()); 3620 if (target_sp) 3621 { 3622 m_exe_ctx_ref.SetTargetSP (target_sp); 3623 ProcessSP process_sp (exe_ctx.GetProcessSP()); 3624 if (!process_sp) 3625 process_sp = target_sp->GetProcessSP(); 3626 3627 if (process_sp) 3628 { 3629 m_mod_id = process_sp->GetModID(); 3630 m_exe_ctx_ref.SetProcessSP (process_sp); 3631 3632 ThreadSP thread_sp (exe_ctx.GetThreadSP()); 3633 3634 if (!thread_sp) 3635 { 3636 if (use_selected) 3637 thread_sp = process_sp->GetThreadList().GetSelectedThread(); 3638 } 3639 3640 if (thread_sp) 3641 { 3642 m_exe_ctx_ref.SetThreadSP(thread_sp); 3643 3644 StackFrameSP frame_sp (exe_ctx.GetFrameSP()); 3645 if (!frame_sp) 3646 { 3647 if (use_selected) 3648 frame_sp = thread_sp->GetSelectedFrame(); 3649 } 3650 if (frame_sp) 3651 m_exe_ctx_ref.SetFrameSP(frame_sp); 3652 } 3653 } 3654 } 3655 } 3656 3657 ValueObject::EvaluationPoint::EvaluationPoint (const ValueObject::EvaluationPoint &rhs) : 3658 m_mod_id(), 3659 m_exe_ctx_ref(rhs.m_exe_ctx_ref), 3660 m_needs_update (true), 3661 m_first_update (true) 3662 { 3663 } 3664 3665 ValueObject::EvaluationPoint::~EvaluationPoint () 3666 { 3667 } 3668 3669 // This function checks the EvaluationPoint against the current process state. If the current 3670 // state matches the evaluation point, or the evaluation point is already invalid, then we return 3671 // false, meaning "no change". If the current state is different, we update our state, and return 3672 // true meaning "yes, change". If we did see a change, we also set m_needs_update to true, so 3673 // future calls to NeedsUpdate will return true. 3674 // exe_scope will be set to the current execution context scope. 3675 3676 bool 3677 ValueObject::EvaluationPoint::SyncWithProcessState() 3678 { 3679 3680 // Start with the target, if it is NULL, then we're obviously not going to get any further: 3681 ExecutionContext exe_ctx(m_exe_ctx_ref.Lock()); 3682 3683 if (exe_ctx.GetTargetPtr() == NULL) 3684 return false; 3685 3686 // If we don't have a process nothing can change. 3687 Process *process = exe_ctx.GetProcessPtr(); 3688 if (process == NULL) 3689 return false; 3690 3691 // If our stop id is the current stop ID, nothing has changed: 3692 ProcessModID current_mod_id = process->GetModID(); 3693 3694 // If the current stop id is 0, either we haven't run yet, or the process state has been cleared. 3695 // In either case, we aren't going to be able to sync with the process state. 3696 if (current_mod_id.GetStopID() == 0) 3697 return false; 3698 3699 bool changed; 3700 3701 if (m_mod_id.IsValid()) 3702 { 3703 if (m_mod_id == current_mod_id) 3704 { 3705 // Everything is already up to date in this object, no need to 3706 // update the execution context scope. 3707 changed = false; 3708 } 3709 else 3710 { 3711 m_mod_id = current_mod_id; 3712 m_needs_update = true; 3713 changed = true; 3714 } 3715 } 3716 3717 // Now re-look up the thread and frame in case the underlying objects have gone away & been recreated. 3718 // That way we'll be sure to return a valid exe_scope. 3719 // If we used to have a thread or a frame but can't find it anymore, then mark ourselves as invalid. 3720 3721 if (m_exe_ctx_ref.HasThreadRef()) 3722 { 3723 ThreadSP thread_sp (m_exe_ctx_ref.GetThreadSP()); 3724 if (thread_sp) 3725 { 3726 if (m_exe_ctx_ref.HasFrameRef()) 3727 { 3728 StackFrameSP frame_sp (m_exe_ctx_ref.GetFrameSP()); 3729 if (!frame_sp) 3730 { 3731 // We used to have a frame, but now it is gone 3732 SetInvalid(); 3733 } 3734 } 3735 } 3736 else 3737 { 3738 // We used to have a thread, but now it is gone 3739 SetInvalid(); 3740 } 3741 3742 } 3743 return changed; 3744 } 3745 3746 void 3747 ValueObject::EvaluationPoint::SetUpdated () 3748 { 3749 ProcessSP process_sp(m_exe_ctx_ref.GetProcessSP()); 3750 if (process_sp) 3751 m_mod_id = process_sp->GetModID(); 3752 m_first_update = false; 3753 m_needs_update = false; 3754 } 3755 3756 3757 //bool 3758 //ValueObject::EvaluationPoint::SetContext (ExecutionContextScope *exe_scope) 3759 //{ 3760 // if (!IsValid()) 3761 // return false; 3762 // 3763 // bool needs_update = false; 3764 // 3765 // // The target has to be non-null, and the 3766 // Target *target = exe_scope->CalculateTarget(); 3767 // if (target != NULL) 3768 // { 3769 // Target *old_target = m_target_sp.get(); 3770 // assert (target == old_target); 3771 // Process *process = exe_scope->CalculateProcess(); 3772 // if (process != NULL) 3773 // { 3774 // // FOR NOW - assume you can't update variable objects across process boundaries. 3775 // Process *old_process = m_process_sp.get(); 3776 // assert (process == old_process); 3777 // ProcessModID current_mod_id = process->GetModID(); 3778 // if (m_mod_id != current_mod_id) 3779 // { 3780 // needs_update = true; 3781 // m_mod_id = current_mod_id; 3782 // } 3783 // // See if we're switching the thread or stack context. If no thread is given, this is 3784 // // being evaluated in a global context. 3785 // Thread *thread = exe_scope->CalculateThread(); 3786 // if (thread != NULL) 3787 // { 3788 // user_id_t new_thread_index = thread->GetIndexID(); 3789 // if (new_thread_index != m_thread_id) 3790 // { 3791 // needs_update = true; 3792 // m_thread_id = new_thread_index; 3793 // m_stack_id.Clear(); 3794 // } 3795 // 3796 // StackFrame *new_frame = exe_scope->CalculateStackFrame(); 3797 // if (new_frame != NULL) 3798 // { 3799 // if (new_frame->GetStackID() != m_stack_id) 3800 // { 3801 // needs_update = true; 3802 // m_stack_id = new_frame->GetStackID(); 3803 // } 3804 // } 3805 // else 3806 // { 3807 // m_stack_id.Clear(); 3808 // needs_update = true; 3809 // } 3810 // } 3811 // else 3812 // { 3813 // // If this had been given a thread, and now there is none, we should update. 3814 // // Otherwise we don't have to do anything. 3815 // if (m_thread_id != LLDB_INVALID_UID) 3816 // { 3817 // m_thread_id = LLDB_INVALID_UID; 3818 // m_stack_id.Clear(); 3819 // needs_update = true; 3820 // } 3821 // } 3822 // } 3823 // else 3824 // { 3825 // // If there is no process, then we don't need to update anything. 3826 // // But if we're switching from having a process to not, we should try to update. 3827 // if (m_process_sp.get() != NULL) 3828 // { 3829 // needs_update = true; 3830 // m_process_sp.reset(); 3831 // m_thread_id = LLDB_INVALID_UID; 3832 // m_stack_id.Clear(); 3833 // } 3834 // } 3835 // } 3836 // else 3837 // { 3838 // // If there's no target, nothing can change so we don't need to update anything. 3839 // // But if we're switching from having a target to not, we should try to update. 3840 // if (m_target_sp.get() != NULL) 3841 // { 3842 // needs_update = true; 3843 // m_target_sp.reset(); 3844 // m_process_sp.reset(); 3845 // m_thread_id = LLDB_INVALID_UID; 3846 // m_stack_id.Clear(); 3847 // } 3848 // } 3849 // if (!m_needs_update) 3850 // m_needs_update = needs_update; 3851 // 3852 // return needs_update; 3853 //} 3854 3855 void 3856 ValueObject::ClearUserVisibleData() 3857 { 3858 m_location_str.clear(); 3859 m_value_str.clear(); 3860 m_summary_str.clear(); 3861 m_object_desc_str.clear(); 3862 m_synthetic_value = NULL; 3863 m_is_getting_summary = false; 3864 } 3865 3866 SymbolContextScope * 3867 ValueObject::GetSymbolContextScope() 3868 { 3869 if (m_parent) 3870 { 3871 if (!m_parent->IsPointerOrReferenceType()) 3872 return m_parent->GetSymbolContextScope(); 3873 } 3874 return NULL; 3875 } 3876