1 //===-- SBValue.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/lldb-python.h" 11 12 #include "lldb/API/SBValue.h" 13 14 #include "lldb/API/SBDeclaration.h" 15 #include "lldb/API/SBStream.h" 16 #include "lldb/API/SBTypeFilter.h" 17 #include "lldb/API/SBTypeFormat.h" 18 #include "lldb/API/SBTypeSummary.h" 19 #include "lldb/API/SBTypeSynthetic.h" 20 21 #include "lldb/Breakpoint/Watchpoint.h" 22 #include "lldb/Core/DataExtractor.h" 23 #include "lldb/Core/Log.h" 24 #include "lldb/Core/Module.h" 25 #include "lldb/Core/Scalar.h" 26 #include "lldb/Core/Section.h" 27 #include "lldb/Core/Stream.h" 28 #include "lldb/Core/StreamFile.h" 29 #include "lldb/Core/Value.h" 30 #include "lldb/Core/ValueObject.h" 31 #include "lldb/Core/ValueObjectConstResult.h" 32 #include "lldb/DataFormatters/DataVisualization.h" 33 #include "lldb/Symbol/Block.h" 34 #include "lldb/Symbol/Declaration.h" 35 #include "lldb/Symbol/ObjectFile.h" 36 #include "lldb/Symbol/Type.h" 37 #include "lldb/Symbol/Variable.h" 38 #include "lldb/Symbol/VariableList.h" 39 #include "lldb/Target/ExecutionContext.h" 40 #include "lldb/Target/Process.h" 41 #include "lldb/Target/StackFrame.h" 42 #include "lldb/Target/Target.h" 43 #include "lldb/Target/Thread.h" 44 45 #include "lldb/API/SBDebugger.h" 46 #include "lldb/API/SBExpressionOptions.h" 47 #include "lldb/API/SBFrame.h" 48 #include "lldb/API/SBProcess.h" 49 #include "lldb/API/SBTarget.h" 50 #include "lldb/API/SBThread.h" 51 52 using namespace lldb; 53 using namespace lldb_private; 54 55 namespace { 56 class ValueImpl 57 { 58 public: 59 ValueImpl () 60 { 61 } 62 63 ValueImpl (lldb::ValueObjectSP opaque_sp, 64 lldb::DynamicValueType use_dynamic, 65 bool use_synthetic) : 66 m_opaque_sp(opaque_sp), 67 m_use_dynamic(use_dynamic), 68 m_use_synthetic(use_synthetic) 69 { 70 } 71 72 ValueImpl (const ValueImpl& rhs) : 73 m_opaque_sp(rhs.m_opaque_sp), 74 m_use_dynamic(rhs.m_use_dynamic), 75 m_use_synthetic(rhs.m_use_synthetic) 76 { 77 } 78 79 ValueImpl & 80 operator = (const ValueImpl &rhs) 81 { 82 if (this != &rhs) 83 { 84 m_opaque_sp = rhs.m_opaque_sp; 85 m_use_dynamic = rhs.m_use_dynamic; 86 m_use_synthetic = rhs.m_use_synthetic; 87 } 88 return *this; 89 } 90 91 bool 92 IsValid () 93 { 94 return m_opaque_sp.get() != NULL; 95 } 96 97 lldb::ValueObjectSP 98 GetRootSP () 99 { 100 return m_opaque_sp; 101 } 102 103 lldb::ValueObjectSP 104 GetSP () 105 { 106 if (!m_opaque_sp) 107 return m_opaque_sp; 108 lldb::ValueObjectSP value_sp = m_opaque_sp; 109 if (value_sp->GetDynamicValue(m_use_dynamic)) 110 value_sp = value_sp->GetDynamicValue(m_use_dynamic); 111 if (value_sp->GetSyntheticValue(m_use_synthetic)) 112 value_sp = value_sp->GetSyntheticValue(m_use_synthetic); 113 return value_sp; 114 } 115 116 void 117 SetUseDynamic (lldb::DynamicValueType use_dynamic) 118 { 119 m_use_dynamic = use_dynamic; 120 } 121 122 void 123 SetUseSynthetic (bool use_synthetic) 124 { 125 m_use_synthetic = use_synthetic; 126 } 127 128 lldb::DynamicValueType 129 GetUseDynamic () 130 { 131 return m_use_dynamic; 132 } 133 134 bool 135 GetUseSynthetic () 136 { 137 return m_use_synthetic; 138 } 139 140 private: 141 lldb::ValueObjectSP m_opaque_sp; 142 lldb::DynamicValueType m_use_dynamic; 143 bool m_use_synthetic; 144 }; 145 } 146 147 SBValue::SBValue () : 148 m_opaque_sp () 149 { 150 } 151 152 SBValue::SBValue (const lldb::ValueObjectSP &value_sp) 153 { 154 SetSP(value_sp); 155 } 156 157 SBValue::SBValue(const SBValue &rhs) 158 { 159 SetSP(rhs.m_opaque_sp); 160 } 161 162 SBValue & 163 SBValue::operator = (const SBValue &rhs) 164 { 165 if (this != &rhs) 166 { 167 SetSP(rhs.m_opaque_sp); 168 } 169 return *this; 170 } 171 172 SBValue::~SBValue() 173 { 174 } 175 176 bool 177 SBValue::IsValid () 178 { 179 // If this function ever changes to anything that does more than just 180 // check if the opaque shared pointer is non NULL, then we need to update 181 // all "if (m_opaque_sp)" code in this file. 182 return m_opaque_sp.get() != NULL && m_opaque_sp->GetRootSP().get() != NULL; 183 } 184 185 void 186 SBValue::Clear() 187 { 188 m_opaque_sp.reset(); 189 } 190 191 SBError 192 SBValue::GetError() 193 { 194 SBError sb_error; 195 196 lldb::ValueObjectSP value_sp(GetSP()); 197 if (value_sp) 198 sb_error.SetError(value_sp->GetError()); 199 else 200 sb_error.SetErrorString("error: invalid value"); 201 202 return sb_error; 203 } 204 205 user_id_t 206 SBValue::GetID() 207 { 208 lldb::ValueObjectSP value_sp(GetSP()); 209 if (value_sp) 210 return value_sp->GetID(); 211 return LLDB_INVALID_UID; 212 } 213 214 const char * 215 SBValue::GetName() 216 { 217 218 const char *name = NULL; 219 lldb::ValueObjectSP value_sp(GetSP()); 220 if (value_sp) 221 name = value_sp->GetName().GetCString(); 222 223 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 224 if (log) 225 { 226 if (name) 227 log->Printf ("SBValue(%p)::GetName () => \"%s\"", value_sp.get(), name); 228 else 229 log->Printf ("SBValue(%p)::GetName () => NULL", value_sp.get()); 230 } 231 232 return name; 233 } 234 235 const char * 236 SBValue::GetTypeName () 237 { 238 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 239 const char *name = NULL; 240 lldb::ValueObjectSP value_sp(GetSP()); 241 if (value_sp) 242 { 243 // For a dynamic type we might have to run code to determine the type we are going to report, 244 // and we might not have updated the type before we get asked this. So make sure to get the API lock. 245 246 ProcessSP process_sp(value_sp->GetProcessSP()); 247 Process::StopLocker stop_locker; 248 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 249 { 250 if (log) 251 log->Printf ("SBValue(%p)::GetTypeName() => error: process is running", value_sp.get()); 252 } 253 else 254 { 255 TargetSP target_sp(value_sp->GetTargetSP()); 256 if (target_sp) 257 { 258 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 259 name = value_sp->GetQualifiedTypeName().GetCString(); 260 } 261 } 262 } 263 264 if (log) 265 { 266 if (name) 267 log->Printf ("SBValue(%p)::GetTypeName () => \"%s\"", value_sp.get(), name); 268 else 269 log->Printf ("SBValue(%p)::GetTypeName () => NULL", value_sp.get()); 270 } 271 272 return name; 273 } 274 275 size_t 276 SBValue::GetByteSize () 277 { 278 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 279 size_t result = 0; 280 281 lldb::ValueObjectSP value_sp(GetSP()); 282 if (value_sp) 283 { 284 // For a dynamic type we might have to run code to determine the type we are going to report, 285 // and we might not have updated the type before we get asked this. So make sure to get the API lock. 286 287 ProcessSP process_sp(value_sp->GetProcessSP()); 288 Process::StopLocker stop_locker; 289 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 290 { 291 if (log) 292 log->Printf ("SBValue(%p)::GetTypeName() => error: process is running", value_sp.get()); 293 } 294 else 295 { 296 TargetSP target_sp(value_sp->GetTargetSP()); 297 if (target_sp) 298 { 299 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 300 result = value_sp->GetByteSize(); 301 } 302 } 303 } 304 305 if (log) 306 log->Printf ("SBValue(%p)::GetByteSize () => %" PRIu64, value_sp.get(), (uint64_t)result); 307 308 return result; 309 } 310 311 bool 312 SBValue::IsInScope () 313 { 314 bool result = false; 315 316 lldb::ValueObjectSP value_sp(GetSP()); 317 if (value_sp) 318 { 319 TargetSP target_sp(value_sp->GetTargetSP()); 320 if (target_sp) 321 { 322 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 323 result = value_sp->IsInScope (); 324 } 325 } 326 327 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 328 if (log) 329 log->Printf ("SBValue(%p)::IsInScope () => %i", value_sp.get(), result); 330 331 return result; 332 } 333 334 const char * 335 SBValue::GetValue () 336 { 337 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 338 339 const char *cstr = NULL; 340 lldb::ValueObjectSP value_sp(GetSP()); 341 if (value_sp) 342 { 343 ProcessSP process_sp(value_sp->GetProcessSP()); 344 Process::StopLocker stop_locker; 345 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 346 { 347 if (log) 348 log->Printf ("SBValue(%p)::GetValue() => error: process is running", value_sp.get()); 349 } 350 else 351 { 352 TargetSP target_sp(value_sp->GetTargetSP()); 353 if (target_sp) 354 { 355 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 356 cstr = value_sp->GetValueAsCString (); 357 } 358 } 359 } 360 if (log) 361 { 362 if (cstr) 363 log->Printf ("SBValue(%p)::GetValue() => \"%s\"", value_sp.get(), cstr); 364 else 365 log->Printf ("SBValue(%p)::GetValue() => NULL", value_sp.get()); 366 } 367 368 return cstr; 369 } 370 371 ValueType 372 SBValue::GetValueType () 373 { 374 ValueType result = eValueTypeInvalid; 375 lldb::ValueObjectSP value_sp(GetSP()); 376 if (value_sp) 377 result = value_sp->GetValueType(); 378 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 379 if (log) 380 { 381 switch (result) 382 { 383 case eValueTypeInvalid: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeInvalid", value_sp.get()); break; 384 case eValueTypeVariableGlobal: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableGlobal", value_sp.get()); break; 385 case eValueTypeVariableStatic: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableStatic", value_sp.get()); break; 386 case eValueTypeVariableArgument:log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableArgument", value_sp.get()); break; 387 case eValueTypeVariableLocal: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableLocal", value_sp.get()); break; 388 case eValueTypeRegister: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeRegister", value_sp.get()); break; 389 case eValueTypeRegisterSet: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeRegisterSet", value_sp.get()); break; 390 case eValueTypeConstResult: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeConstResult", value_sp.get()); break; 391 } 392 } 393 return result; 394 } 395 396 const char * 397 SBValue::GetObjectDescription () 398 { 399 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 400 const char *cstr = NULL; 401 lldb::ValueObjectSP value_sp(GetSP()); 402 if (value_sp) 403 { 404 ProcessSP process_sp(value_sp->GetProcessSP()); 405 Process::StopLocker stop_locker; 406 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 407 { 408 if (log) 409 log->Printf ("SBValue(%p)::GetObjectDescription() => error: process is running", value_sp.get()); 410 } 411 else 412 { 413 TargetSP target_sp(value_sp->GetTargetSP()); 414 if (target_sp) 415 { 416 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 417 cstr = value_sp->GetObjectDescription (); 418 } 419 } 420 } 421 if (log) 422 { 423 if (cstr) 424 log->Printf ("SBValue(%p)::GetObjectDescription() => \"%s\"", value_sp.get(), cstr); 425 else 426 log->Printf ("SBValue(%p)::GetObjectDescription() => NULL", value_sp.get()); 427 } 428 return cstr; 429 } 430 431 SBType 432 SBValue::GetType() 433 { 434 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 435 SBType sb_type; 436 lldb::ValueObjectSP value_sp(GetSP()); 437 TypeImplSP type_sp; 438 if (value_sp) 439 { 440 ProcessSP process_sp(value_sp->GetProcessSP()); 441 Process::StopLocker stop_locker; 442 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 443 { 444 if (log) 445 log->Printf ("SBValue(%p)::GetType() => error: process is running", value_sp.get()); 446 } 447 else 448 { 449 TargetSP target_sp(value_sp->GetTargetSP()); 450 if (target_sp) 451 { 452 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 453 type_sp.reset (new TypeImpl(ClangASTType (value_sp->GetClangAST(), value_sp->GetClangType()))); 454 sb_type.SetSP(type_sp); 455 } 456 } 457 } 458 if (log) 459 { 460 if (type_sp) 461 log->Printf ("SBValue(%p)::GetType => SBType(%p)", value_sp.get(), type_sp.get()); 462 else 463 log->Printf ("SBValue(%p)::GetType => NULL", value_sp.get()); 464 } 465 return sb_type; 466 } 467 468 bool 469 SBValue::GetValueDidChange () 470 { 471 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 472 bool result = false; 473 lldb::ValueObjectSP value_sp(GetSP()); 474 if (value_sp) 475 { 476 ProcessSP process_sp(value_sp->GetProcessSP()); 477 Process::StopLocker stop_locker; 478 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 479 { 480 if (log) 481 log->Printf ("SBValue(%p)::GetValueDidChange() => error: process is running", value_sp.get()); 482 } 483 else 484 { 485 TargetSP target_sp(value_sp->GetTargetSP()); 486 if (target_sp) 487 { 488 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 489 result = value_sp->GetValueDidChange (); 490 } 491 } 492 } 493 if (log) 494 log->Printf ("SBValue(%p)::GetValueDidChange() => %i", value_sp.get(), result); 495 496 return result; 497 } 498 499 #ifndef LLDB_DISABLE_PYTHON 500 const char * 501 SBValue::GetSummary () 502 { 503 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 504 const char *cstr = NULL; 505 lldb::ValueObjectSP value_sp(GetSP()); 506 if (value_sp) 507 { 508 ProcessSP process_sp(value_sp->GetProcessSP()); 509 Process::StopLocker stop_locker; 510 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 511 { 512 if (log) 513 log->Printf ("SBValue(%p)::GetSummary() => error: process is running", value_sp.get()); 514 } 515 else 516 { 517 TargetSP target_sp(value_sp->GetTargetSP()); 518 if (target_sp) 519 { 520 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 521 cstr = value_sp->GetSummaryAsCString(); 522 } 523 } 524 } 525 if (log) 526 { 527 if (cstr) 528 log->Printf ("SBValue(%p)::GetSummary() => \"%s\"", value_sp.get(), cstr); 529 else 530 log->Printf ("SBValue(%p)::GetSummary() => NULL", value_sp.get()); 531 } 532 return cstr; 533 } 534 #endif // LLDB_DISABLE_PYTHON 535 536 const char * 537 SBValue::GetLocation () 538 { 539 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 540 const char *cstr = NULL; 541 lldb::ValueObjectSP value_sp(GetSP()); 542 if (value_sp) 543 { 544 ProcessSP process_sp(value_sp->GetProcessSP()); 545 Process::StopLocker stop_locker; 546 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 547 { 548 if (log) 549 log->Printf ("SBValue(%p)::GetLocation() => error: process is running", value_sp.get()); 550 } 551 else 552 { 553 TargetSP target_sp(value_sp->GetTargetSP()); 554 if (target_sp) 555 { 556 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 557 cstr = value_sp->GetLocationAsCString(); 558 } 559 } 560 } 561 if (log) 562 { 563 if (cstr) 564 log->Printf ("SBValue(%p)::GetLocation() => \"%s\"", value_sp.get(), cstr); 565 else 566 log->Printf ("SBValue(%p)::GetLocation() => NULL", value_sp.get()); 567 } 568 return cstr; 569 } 570 571 // Deprecated - use the one that takes an lldb::SBError 572 bool 573 SBValue::SetValueFromCString (const char *value_str) 574 { 575 lldb::SBError dummy; 576 return SetValueFromCString(value_str,dummy); 577 } 578 579 bool 580 SBValue::SetValueFromCString (const char *value_str, lldb::SBError& error) 581 { 582 bool success = false; 583 lldb::ValueObjectSP value_sp(GetSP()); 584 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 585 if (value_sp) 586 { 587 ProcessSP process_sp(value_sp->GetProcessSP()); 588 Process::StopLocker stop_locker; 589 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 590 { 591 if (log) 592 log->Printf ("SBValue(%p)::SetValueFromCString() => error: process is running", value_sp.get()); 593 } 594 else 595 { 596 TargetSP target_sp(value_sp->GetTargetSP()); 597 if (target_sp) 598 { 599 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 600 success = value_sp->SetValueFromCString (value_str,error.ref()); 601 } 602 } 603 } 604 if (log) 605 log->Printf ("SBValue(%p)::SetValueFromCString(\"%s\") => %i", value_sp.get(), value_str, success); 606 607 return success; 608 } 609 610 lldb::SBTypeFormat 611 SBValue::GetTypeFormat () 612 { 613 lldb::SBTypeFormat format; 614 lldb::ValueObjectSP value_sp(GetSP()); 615 if (value_sp) 616 { 617 ProcessSP process_sp(value_sp->GetProcessSP()); 618 Process::StopLocker stop_locker; 619 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 620 { 621 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 622 if (log) 623 log->Printf ("SBValue(%p)::GetTypeFormat() => error: process is running", value_sp.get()); 624 } 625 else 626 { 627 TargetSP target_sp(value_sp->GetTargetSP()); 628 if (target_sp) 629 { 630 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 631 if (value_sp->UpdateValueIfNeeded(true)) 632 { 633 lldb::TypeFormatImplSP format_sp = value_sp->GetValueFormat(); 634 if (format_sp) 635 format.SetSP(format_sp); 636 } 637 } 638 } 639 } 640 return format; 641 } 642 643 #ifndef LLDB_DISABLE_PYTHON 644 lldb::SBTypeSummary 645 SBValue::GetTypeSummary () 646 { 647 lldb::SBTypeSummary summary; 648 lldb::ValueObjectSP value_sp(GetSP()); 649 if (value_sp) 650 { 651 ProcessSP process_sp(value_sp->GetProcessSP()); 652 Process::StopLocker stop_locker; 653 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 654 { 655 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 656 if (log) 657 log->Printf ("SBValue(%p)::GetTypeSummary() => error: process is running", value_sp.get()); 658 } 659 else 660 { 661 TargetSP target_sp(value_sp->GetTargetSP()); 662 if (target_sp) 663 { 664 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 665 if (value_sp->UpdateValueIfNeeded(true)) 666 { 667 lldb::TypeSummaryImplSP summary_sp = value_sp->GetSummaryFormat(); 668 if (summary_sp) 669 summary.SetSP(summary_sp); 670 } 671 } 672 } 673 } 674 return summary; 675 } 676 #endif // LLDB_DISABLE_PYTHON 677 678 lldb::SBTypeFilter 679 SBValue::GetTypeFilter () 680 { 681 lldb::SBTypeFilter filter; 682 lldb::ValueObjectSP value_sp(GetSP()); 683 if (value_sp) 684 { 685 ProcessSP process_sp(value_sp->GetProcessSP()); 686 Process::StopLocker stop_locker; 687 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 688 { 689 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 690 if (log) 691 log->Printf ("SBValue(%p)::GetTypeFilter() => error: process is running", value_sp.get()); 692 } 693 else 694 { 695 TargetSP target_sp(value_sp->GetTargetSP()); 696 if (target_sp) 697 { 698 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 699 if (value_sp->UpdateValueIfNeeded(true)) 700 { 701 lldb::SyntheticChildrenSP synthetic_sp = value_sp->GetSyntheticChildren(); 702 703 if (synthetic_sp && !synthetic_sp->IsScripted()) 704 { 705 TypeFilterImplSP filter_sp = STD_STATIC_POINTER_CAST(TypeFilterImpl,synthetic_sp); 706 filter.SetSP(filter_sp); 707 } 708 } 709 } 710 } 711 } 712 return filter; 713 } 714 715 #ifndef LLDB_DISABLE_PYTHON 716 lldb::SBTypeSynthetic 717 SBValue::GetTypeSynthetic () 718 { 719 lldb::SBTypeSynthetic synthetic; 720 lldb::ValueObjectSP value_sp(GetSP()); 721 if (value_sp) 722 { 723 ProcessSP process_sp(value_sp->GetProcessSP()); 724 Process::StopLocker stop_locker; 725 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 726 { 727 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 728 if (log) 729 log->Printf ("SBValue(%p)::GetTypeSynthetic() => error: process is running", value_sp.get()); 730 } 731 else 732 { 733 TargetSP target_sp(value_sp->GetTargetSP()); 734 if (target_sp) 735 { 736 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 737 if (value_sp->UpdateValueIfNeeded(true)) 738 { 739 lldb::SyntheticChildrenSP children_sp = value_sp->GetSyntheticChildren(); 740 741 if (children_sp && children_sp->IsScripted()) 742 { 743 ScriptedSyntheticChildrenSP synth_sp = STD_STATIC_POINTER_CAST(ScriptedSyntheticChildren,children_sp); 744 synthetic.SetSP(synth_sp); 745 } 746 } 747 } 748 } 749 } 750 return synthetic; 751 } 752 #endif 753 754 lldb::SBValue 755 SBValue::CreateChildAtOffset (const char *name, uint32_t offset, SBType type) 756 { 757 lldb::SBValue sb_value; 758 lldb::ValueObjectSP value_sp(GetSP()); 759 lldb::ValueObjectSP new_value_sp; 760 if (value_sp) 761 { 762 ProcessSP process_sp(value_sp->GetProcessSP()); 763 Process::StopLocker stop_locker; 764 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 765 { 766 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 767 if (log) 768 log->Printf ("SBValue(%p)::CreateChildAtOffset() => error: process is running", value_sp.get()); 769 } 770 else 771 { 772 TargetSP target_sp(value_sp->GetTargetSP()); 773 if (target_sp) 774 { 775 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 776 TypeImplSP type_sp (type.GetSP()); 777 if (type.IsValid()) 778 { 779 sb_value.SetSP(value_sp->GetSyntheticChildAtOffset(offset, type_sp->GetClangASTType(), true),GetPreferDynamicValue(),GetPreferSyntheticValue()); 780 new_value_sp = sb_value.GetSP(); 781 if (new_value_sp) 782 new_value_sp->SetName(ConstString(name)); 783 } 784 } 785 } 786 } 787 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 788 if (log) 789 { 790 if (new_value_sp) 791 log->Printf ("SBValue(%p)::CreateChildAtOffset => \"%s\"", 792 value_sp.get(), 793 new_value_sp->GetName().AsCString()); 794 else 795 log->Printf ("SBValue(%p)::CreateChildAtOffset => NULL", 796 value_sp.get()); 797 } 798 return sb_value; 799 } 800 801 lldb::SBValue 802 SBValue::Cast (SBType type) 803 { 804 lldb::SBValue sb_value; 805 lldb::ValueObjectSP value_sp(GetSP()); 806 TypeImplSP type_sp (type.GetSP()); 807 if (value_sp && type_sp) 808 sb_value.SetSP(value_sp->Cast(type_sp->GetClangASTType()),GetPreferDynamicValue(),GetPreferSyntheticValue()); 809 return sb_value; 810 } 811 812 lldb::SBValue 813 SBValue::CreateValueFromExpression (const char *name, const char* expression) 814 { 815 SBExpressionOptions options; 816 options.ref().SetKeepInMemory(true); 817 return CreateValueFromExpression (name, expression, options); 818 } 819 820 lldb::SBValue 821 SBValue::CreateValueFromExpression (const char *name, const char *expression, SBExpressionOptions &options) 822 { 823 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 824 lldb::SBValue sb_value; 825 lldb::ValueObjectSP value_sp(GetSP()); 826 lldb::ValueObjectSP new_value_sp; 827 if (value_sp) 828 { 829 ExecutionContext exe_ctx (value_sp->GetExecutionContextRef()); 830 ProcessSP process_sp(exe_ctx.GetProcessSP()); 831 Process::StopLocker stop_locker; 832 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 833 { 834 if (log) 835 log->Printf ("SBValue(%p)::CreateValueFromExpression() => error: process is running", value_sp.get()); 836 } 837 else 838 { 839 Target* target = exe_ctx.GetTargetPtr(); 840 if (target) 841 { 842 options.ref().SetKeepInMemory(true); 843 target->EvaluateExpression (expression, 844 exe_ctx.GetFramePtr(), 845 new_value_sp, 846 options.ref()); 847 if (new_value_sp) 848 { 849 new_value_sp->SetName(ConstString(name)); 850 sb_value.SetSP(new_value_sp); 851 } 852 } 853 } 854 } 855 if (log) 856 { 857 if (new_value_sp) 858 log->Printf ("SBValue(%p)::CreateValueFromExpression(name=\"%s\", expression=\"%s\") => SBValue (%p)", 859 value_sp.get(), 860 name, 861 expression, 862 new_value_sp.get()); 863 else 864 log->Printf ("SBValue(%p)::CreateValueFromExpression(name=\"%s\", expression=\"%s\") => NULL", 865 value_sp.get(), 866 name, 867 expression); 868 } 869 return sb_value; 870 } 871 872 lldb::SBValue 873 SBValue::CreateValueFromAddress(const char* name, lldb::addr_t address, SBType sb_type) 874 { 875 lldb::SBValue sb_value; 876 lldb::ValueObjectSP value_sp(GetSP()); 877 lldb::ValueObjectSP new_value_sp; 878 lldb::TypeImplSP type_impl_sp (sb_type.GetSP()); 879 if (value_sp && type_impl_sp) 880 { 881 ClangASTType pointee_ast_type(type_impl_sp->GetASTContext(), type_impl_sp->GetClangASTType().GetPointerType ()); 882 lldb::TypeImplSP pointee_type_impl_sp (new TypeImpl(pointee_ast_type)); 883 if (pointee_type_impl_sp) 884 { 885 886 lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(&address,sizeof(lldb::addr_t))); 887 888 ExecutionContext exe_ctx (value_sp->GetExecutionContextRef()); 889 ValueObjectSP ptr_result_valobj_sp(ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(), 890 pointee_type_impl_sp->GetASTContext(), 891 pointee_type_impl_sp->GetOpaqueQualType(), 892 ConstString(name), 893 buffer, 894 lldb::endian::InlHostByteOrder(), 895 exe_ctx.GetAddressByteSize())); 896 897 if (ptr_result_valobj_sp) 898 { 899 ptr_result_valobj_sp->GetValue().SetValueType(Value::eValueTypeLoadAddress); 900 Error err; 901 new_value_sp = ptr_result_valobj_sp->Dereference(err); 902 if (new_value_sp) 903 new_value_sp->SetName(ConstString(name)); 904 } 905 sb_value.SetSP(new_value_sp); 906 } 907 } 908 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 909 if (log) 910 { 911 if (new_value_sp) 912 log->Printf ("SBValue(%p)::CreateValueFromAddress => \"%s\"", value_sp.get(), new_value_sp->GetName().AsCString()); 913 else 914 log->Printf ("SBValue(%p)::CreateValueFromAddress => NULL", value_sp.get()); 915 } 916 return sb_value; 917 } 918 919 lldb::SBValue 920 SBValue::CreateValueFromData (const char* name, SBData data, SBType type) 921 { 922 lldb::SBValue sb_value; 923 lldb::ValueObjectSP new_value_sp; 924 lldb::ValueObjectSP value_sp(GetSP()); 925 if (value_sp) 926 { 927 ExecutionContext exe_ctx (value_sp->GetExecutionContextRef()); 928 929 new_value_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(), 930 type.m_opaque_sp->GetASTContext() , 931 type.m_opaque_sp->GetOpaqueQualType(), 932 ConstString(name), 933 *data.m_opaque_sp, 934 LLDB_INVALID_ADDRESS); 935 new_value_sp->SetAddressTypeOfChildren(eAddressTypeLoad); 936 sb_value.SetSP(new_value_sp); 937 } 938 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 939 if (log) 940 { 941 if (new_value_sp) 942 log->Printf ("SBValue(%p)::CreateValueFromData => \"%s\"", value_sp.get(), new_value_sp->GetName().AsCString()); 943 else 944 log->Printf ("SBValue(%p)::CreateValueFromData => NULL", value_sp.get()); 945 } 946 return sb_value; 947 } 948 949 SBValue 950 SBValue::GetChildAtIndex (uint32_t idx) 951 { 952 const bool can_create_synthetic = false; 953 lldb::DynamicValueType use_dynamic = eNoDynamicValues; 954 lldb::ValueObjectSP value_sp(GetSP()); 955 if (value_sp) 956 { 957 TargetSP target_sp(value_sp->GetTargetSP()); 958 if (target_sp) 959 use_dynamic = target_sp->GetPreferDynamicValue(); 960 } 961 return GetChildAtIndex (idx, use_dynamic, can_create_synthetic); 962 } 963 964 SBValue 965 SBValue::GetChildAtIndex (uint32_t idx, lldb::DynamicValueType use_dynamic, bool can_create_synthetic) 966 { 967 lldb::ValueObjectSP child_sp; 968 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 969 970 lldb::ValueObjectSP value_sp(GetSP()); 971 if (value_sp) 972 { 973 ProcessSP process_sp(value_sp->GetProcessSP()); 974 Process::StopLocker stop_locker; 975 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 976 { 977 if (log) 978 log->Printf ("SBValue(%p)::GetChildAtIndex() => error: process is running", value_sp.get()); 979 } 980 else 981 { 982 TargetSP target_sp(value_sp->GetTargetSP()); 983 if (target_sp) 984 { 985 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 986 const bool can_create = true; 987 child_sp = value_sp->GetChildAtIndex (idx, can_create); 988 if (can_create_synthetic && !child_sp) 989 { 990 if (value_sp->IsPointerType()) 991 { 992 child_sp = value_sp->GetSyntheticArrayMemberFromPointer(idx, can_create); 993 } 994 else if (value_sp->IsArrayType()) 995 { 996 child_sp = value_sp->GetSyntheticArrayMemberFromArray(idx, can_create); 997 } 998 } 999 1000 } 1001 } 1002 } 1003 1004 SBValue sb_value; 1005 sb_value.SetSP (child_sp, use_dynamic, GetPreferSyntheticValue()); 1006 if (log) 1007 log->Printf ("SBValue(%p)::GetChildAtIndex (%u) => SBValue(%p)", value_sp.get(), idx, value_sp.get()); 1008 1009 return sb_value; 1010 } 1011 1012 uint32_t 1013 SBValue::GetIndexOfChildWithName (const char *name) 1014 { 1015 uint32_t idx = UINT32_MAX; 1016 lldb::ValueObjectSP value_sp(GetSP()); 1017 if (value_sp) 1018 { 1019 TargetSP target_sp(value_sp->GetTargetSP()); 1020 if (target_sp) 1021 { 1022 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1023 1024 idx = value_sp->GetIndexOfChildWithName (ConstString(name)); 1025 } 1026 } 1027 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1028 if (log) 1029 { 1030 if (idx == UINT32_MAX) 1031 log->Printf ("SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => NOT FOUND", value_sp.get(), name); 1032 else 1033 log->Printf ("SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => %u", value_sp.get(), name, idx); 1034 } 1035 return idx; 1036 } 1037 1038 SBValue 1039 SBValue::GetChildMemberWithName (const char *name) 1040 { 1041 lldb::ValueObjectSP value_sp(GetSP()); 1042 if (value_sp) 1043 { 1044 lldb::DynamicValueType use_dynamic_value = eNoDynamicValues; 1045 TargetSP target_sp(value_sp->GetTargetSP()); 1046 if (target_sp) 1047 { 1048 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1049 use_dynamic_value = target_sp->GetPreferDynamicValue(); 1050 } 1051 return GetChildMemberWithName (name, use_dynamic_value); 1052 } 1053 return SBValue(); 1054 } 1055 1056 SBValue 1057 SBValue::GetChildMemberWithName (const char *name, lldb::DynamicValueType use_dynamic_value) 1058 { 1059 lldb::ValueObjectSP child_sp; 1060 const ConstString str_name (name); 1061 1062 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1063 1064 lldb::ValueObjectSP value_sp(GetSP()); 1065 if (value_sp) 1066 { 1067 ProcessSP process_sp(value_sp->GetProcessSP()); 1068 Process::StopLocker stop_locker; 1069 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 1070 { 1071 if (log) 1072 log->Printf ("SBValue(%p)::GetChildMemberWithName() => error: process is running", value_sp.get()); 1073 } 1074 else 1075 { 1076 TargetSP target_sp(value_sp->GetTargetSP()); 1077 if (target_sp) 1078 { 1079 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1080 child_sp = value_sp->GetChildMemberWithName (str_name, true); 1081 } 1082 } 1083 } 1084 1085 SBValue sb_value; 1086 sb_value.SetSP(child_sp, use_dynamic_value, GetPreferSyntheticValue()); 1087 1088 if (log) 1089 log->Printf ("SBValue(%p)::GetChildMemberWithName (name=\"%s\") => SBValue(%p)", value_sp.get(), name, value_sp.get()); 1090 1091 return sb_value; 1092 } 1093 1094 lldb::SBValue 1095 SBValue::GetDynamicValue (lldb::DynamicValueType use_dynamic) 1096 { 1097 SBValue value_sb; 1098 if (IsValid()) 1099 { 1100 ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),use_dynamic,m_opaque_sp->GetUseSynthetic())); 1101 value_sb.SetSP(proxy_sp); 1102 } 1103 return value_sb; 1104 } 1105 1106 lldb::SBValue 1107 SBValue::GetStaticValue () 1108 { 1109 SBValue value_sb; 1110 if (IsValid()) 1111 { 1112 ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),eNoDynamicValues,m_opaque_sp->GetUseSynthetic())); 1113 value_sb.SetSP(proxy_sp); 1114 } 1115 return value_sb; 1116 } 1117 1118 lldb::SBValue 1119 SBValue::GetNonSyntheticValue () 1120 { 1121 SBValue value_sb; 1122 if (IsValid()) 1123 { 1124 ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),m_opaque_sp->GetUseDynamic(),false)); 1125 value_sb.SetSP(proxy_sp); 1126 } 1127 return value_sb; 1128 } 1129 1130 lldb::DynamicValueType 1131 SBValue::GetPreferDynamicValue () 1132 { 1133 if (!IsValid()) 1134 return eNoDynamicValues; 1135 return m_opaque_sp->GetUseDynamic(); 1136 } 1137 1138 void 1139 SBValue::SetPreferDynamicValue (lldb::DynamicValueType use_dynamic) 1140 { 1141 if (IsValid()) 1142 return m_opaque_sp->SetUseDynamic (use_dynamic); 1143 } 1144 1145 bool 1146 SBValue::GetPreferSyntheticValue () 1147 { 1148 if (!IsValid()) 1149 return false; 1150 return m_opaque_sp->GetUseSynthetic(); 1151 } 1152 1153 void 1154 SBValue::SetPreferSyntheticValue (bool use_synthetic) 1155 { 1156 if (IsValid()) 1157 return m_opaque_sp->SetUseSynthetic (use_synthetic); 1158 } 1159 1160 bool 1161 SBValue::IsDynamic() 1162 { 1163 lldb::ValueObjectSP value_sp(GetSP()); 1164 if (value_sp) 1165 { 1166 TargetSP target_sp(value_sp->GetTargetSP()); 1167 if (target_sp) 1168 { 1169 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1170 return value_sp->IsDynamic(); 1171 } 1172 } 1173 return false; 1174 } 1175 1176 bool 1177 SBValue::IsSynthetic () 1178 { 1179 lldb::ValueObjectSP value_sp(GetSP()); 1180 if (value_sp) 1181 { 1182 TargetSP target_sp(value_sp->GetTargetSP()); 1183 if (target_sp) 1184 { 1185 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1186 return value_sp->IsSynthetic(); 1187 } 1188 } 1189 return false; 1190 } 1191 1192 lldb::SBValue 1193 SBValue::GetValueForExpressionPath(const char* expr_path) 1194 { 1195 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1196 lldb::ValueObjectSP child_sp; 1197 lldb::ValueObjectSP value_sp(GetSP()); 1198 if (value_sp) 1199 { 1200 ProcessSP process_sp(value_sp->GetProcessSP()); 1201 Process::StopLocker stop_locker; 1202 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 1203 { 1204 if (log) 1205 log->Printf ("SBValue(%p)::GetValueForExpressionPath() => error: process is running", value_sp.get()); 1206 } 1207 else 1208 { 1209 TargetSP target_sp(value_sp->GetTargetSP()); 1210 if (target_sp) 1211 { 1212 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1213 // using default values for all the fancy options, just do it if you can 1214 child_sp = value_sp->GetValueForExpressionPath(expr_path); 1215 } 1216 } 1217 } 1218 1219 SBValue sb_value; 1220 sb_value.SetSP(child_sp,GetPreferDynamicValue(),GetPreferSyntheticValue()); 1221 1222 if (log) 1223 log->Printf ("SBValue(%p)::GetValueForExpressionPath (expr_path=\"%s\") => SBValue(%p)", value_sp.get(), expr_path, value_sp.get()); 1224 1225 return sb_value; 1226 } 1227 1228 int64_t 1229 SBValue::GetValueAsSigned(SBError& error, int64_t fail_value) 1230 { 1231 error.Clear(); 1232 lldb::ValueObjectSP value_sp(GetSP()); 1233 if (value_sp) 1234 { 1235 ProcessSP process_sp(value_sp->GetProcessSP()); 1236 Process::StopLocker stop_locker; 1237 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 1238 { 1239 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1240 if (log) 1241 log->Printf ("SBValue(%p)::GetValueAsSigned() => error: process is running", value_sp.get()); 1242 error.SetErrorString("process is running"); 1243 } 1244 else 1245 { 1246 TargetSP target_sp(value_sp->GetTargetSP()); 1247 if (target_sp) 1248 { 1249 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1250 Scalar scalar; 1251 if (value_sp->ResolveValue (scalar)) 1252 return scalar.SLongLong(fail_value); 1253 else 1254 error.SetErrorString("could not get value"); 1255 } 1256 else 1257 error.SetErrorString("could not get target"); 1258 } 1259 } 1260 error.SetErrorString("invalid SBValue"); 1261 return fail_value; 1262 } 1263 1264 uint64_t 1265 SBValue::GetValueAsUnsigned(SBError& error, uint64_t fail_value) 1266 { 1267 error.Clear(); 1268 lldb::ValueObjectSP value_sp(GetSP()); 1269 if (value_sp) 1270 { 1271 ProcessSP process_sp(value_sp->GetProcessSP()); 1272 Process::StopLocker stop_locker; 1273 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 1274 { 1275 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1276 if (log) 1277 log->Printf ("SBValue(%p)::GetValueAsUnsigned() => error: process is running", value_sp.get()); 1278 error.SetErrorString("process is running"); 1279 } 1280 else 1281 { 1282 TargetSP target_sp(value_sp->GetTargetSP()); 1283 if (target_sp) 1284 { 1285 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1286 Scalar scalar; 1287 if (value_sp->ResolveValue (scalar)) 1288 return scalar.ULongLong(fail_value); 1289 else 1290 error.SetErrorString("could not get value"); 1291 } 1292 else 1293 error.SetErrorString("could not get target"); 1294 } 1295 } 1296 error.SetErrorString("invalid SBValue"); 1297 return fail_value; 1298 } 1299 1300 int64_t 1301 SBValue::GetValueAsSigned(int64_t fail_value) 1302 { 1303 lldb::ValueObjectSP value_sp(GetSP()); 1304 if (value_sp) 1305 { 1306 ProcessSP process_sp(value_sp->GetProcessSP()); 1307 Process::StopLocker stop_locker; 1308 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 1309 { 1310 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1311 if (log) 1312 log->Printf ("SBValue(%p)::GetValueAsSigned() => error: process is running", value_sp.get()); 1313 } 1314 else 1315 { 1316 TargetSP target_sp(value_sp->GetTargetSP()); 1317 if (target_sp) 1318 { 1319 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1320 Scalar scalar; 1321 if (value_sp->ResolveValue (scalar)) 1322 return scalar.SLongLong(fail_value); 1323 } 1324 } 1325 } 1326 return fail_value; 1327 } 1328 1329 uint64_t 1330 SBValue::GetValueAsUnsigned(uint64_t fail_value) 1331 { 1332 lldb::ValueObjectSP value_sp(GetSP()); 1333 if (value_sp) 1334 { 1335 ProcessSP process_sp(value_sp->GetProcessSP()); 1336 Process::StopLocker stop_locker; 1337 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 1338 { 1339 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1340 if (log) 1341 log->Printf ("SBValue(%p)::GetValueAsUnsigned() => error: process is running", value_sp.get()); 1342 } 1343 else 1344 { 1345 TargetSP target_sp(value_sp->GetTargetSP()); 1346 if (target_sp) 1347 { 1348 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1349 Scalar scalar; 1350 if (value_sp->ResolveValue (scalar)) 1351 return scalar.ULongLong(fail_value); 1352 } 1353 } 1354 } 1355 return fail_value; 1356 } 1357 1358 bool 1359 SBValue::MightHaveChildren () 1360 { 1361 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1362 bool has_children = false; 1363 lldb::ValueObjectSP value_sp(GetSP()); 1364 if (value_sp) 1365 has_children = value_sp->MightHaveChildren(); 1366 1367 if (log) 1368 log->Printf ("SBValue(%p)::MightHaveChildren() => %i", value_sp.get(), has_children); 1369 return has_children; 1370 } 1371 1372 uint32_t 1373 SBValue::GetNumChildren () 1374 { 1375 uint32_t num_children = 0; 1376 1377 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1378 lldb::ValueObjectSP value_sp(GetSP()); 1379 if (value_sp) 1380 { 1381 ProcessSP process_sp(value_sp->GetProcessSP()); 1382 Process::StopLocker stop_locker; 1383 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 1384 { 1385 if (log) 1386 log->Printf ("SBValue(%p)::GetNumChildren() => error: process is running", value_sp.get()); 1387 } 1388 else 1389 { 1390 TargetSP target_sp(value_sp->GetTargetSP()); 1391 if (target_sp) 1392 { 1393 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1394 1395 num_children = value_sp->GetNumChildren(); 1396 } 1397 } 1398 } 1399 1400 if (log) 1401 log->Printf ("SBValue(%p)::GetNumChildren () => %u", value_sp.get(), num_children); 1402 1403 return num_children; 1404 } 1405 1406 1407 SBValue 1408 SBValue::Dereference () 1409 { 1410 SBValue sb_value; 1411 lldb::ValueObjectSP value_sp(GetSP()); 1412 if (value_sp) 1413 { 1414 TargetSP target_sp(value_sp->GetTargetSP()); 1415 if (target_sp) 1416 { 1417 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1418 1419 Error error; 1420 sb_value = value_sp->Dereference (error); 1421 } 1422 } 1423 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1424 if (log) 1425 log->Printf ("SBValue(%p)::Dereference () => SBValue(%p)", value_sp.get(), value_sp.get()); 1426 1427 return sb_value; 1428 } 1429 1430 bool 1431 SBValue::TypeIsPointerType () 1432 { 1433 bool is_ptr_type = false; 1434 1435 lldb::ValueObjectSP value_sp(GetSP()); 1436 if (value_sp) 1437 { 1438 TargetSP target_sp(value_sp->GetTargetSP()); 1439 if (target_sp) 1440 { 1441 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1442 1443 is_ptr_type = value_sp->IsPointerType(); 1444 } 1445 } 1446 1447 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1448 if (log) 1449 log->Printf ("SBValue(%p)::TypeIsPointerType () => %i", value_sp.get(), is_ptr_type); 1450 1451 1452 return is_ptr_type; 1453 } 1454 1455 void * 1456 SBValue::GetOpaqueType() 1457 { 1458 lldb::ValueObjectSP value_sp(GetSP()); 1459 if (value_sp) 1460 { 1461 TargetSP target_sp(value_sp->GetTargetSP()); 1462 if (target_sp) 1463 { 1464 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1465 1466 return value_sp->GetClangType(); 1467 } 1468 } 1469 return NULL; 1470 } 1471 1472 lldb::SBTarget 1473 SBValue::GetTarget() 1474 { 1475 SBTarget sb_target; 1476 TargetSP target_sp; 1477 lldb::ValueObjectSP value_sp(GetSP()); 1478 if (value_sp) 1479 { 1480 target_sp = value_sp->GetTargetSP(); 1481 sb_target.SetSP (target_sp); 1482 } 1483 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1484 if (log) 1485 { 1486 if (target_sp.get() == NULL) 1487 log->Printf ("SBValue(%p)::GetTarget () => NULL", value_sp.get()); 1488 else 1489 log->Printf ("SBValue(%p)::GetTarget () => %p", value_sp.get(), target_sp.get()); 1490 } 1491 return sb_target; 1492 } 1493 1494 lldb::SBProcess 1495 SBValue::GetProcess() 1496 { 1497 SBProcess sb_process; 1498 ProcessSP process_sp; 1499 lldb::ValueObjectSP value_sp(GetSP()); 1500 if (value_sp) 1501 { 1502 process_sp = value_sp->GetProcessSP(); 1503 if (process_sp) 1504 sb_process.SetSP (process_sp); 1505 } 1506 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1507 if (log) 1508 { 1509 if (process_sp.get() == NULL) 1510 log->Printf ("SBValue(%p)::GetProcess () => NULL", value_sp.get()); 1511 else 1512 log->Printf ("SBValue(%p)::GetProcess () => %p", value_sp.get(), process_sp.get()); 1513 } 1514 return sb_process; 1515 } 1516 1517 lldb::SBThread 1518 SBValue::GetThread() 1519 { 1520 SBThread sb_thread; 1521 ThreadSP thread_sp; 1522 lldb::ValueObjectSP value_sp(GetSP()); 1523 if (value_sp) 1524 { 1525 thread_sp = value_sp->GetThreadSP(); 1526 sb_thread.SetThread(thread_sp); 1527 } 1528 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1529 if (log) 1530 { 1531 if (thread_sp.get() == NULL) 1532 log->Printf ("SBValue(%p)::GetThread () => NULL", value_sp.get()); 1533 else 1534 log->Printf ("SBValue(%p)::GetThread () => %p", value_sp.get(), thread_sp.get()); 1535 } 1536 return sb_thread; 1537 } 1538 1539 lldb::SBFrame 1540 SBValue::GetFrame() 1541 { 1542 SBFrame sb_frame; 1543 StackFrameSP frame_sp; 1544 lldb::ValueObjectSP value_sp(GetSP()); 1545 if (value_sp) 1546 { 1547 frame_sp = value_sp->GetFrameSP(); 1548 sb_frame.SetFrameSP (frame_sp); 1549 } 1550 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1551 if (log) 1552 { 1553 if (frame_sp.get() == NULL) 1554 log->Printf ("SBValue(%p)::GetFrame () => NULL", value_sp.get()); 1555 else 1556 log->Printf ("SBValue(%p)::GetFrame () => %p", value_sp.get(), frame_sp.get()); 1557 } 1558 return sb_frame; 1559 } 1560 1561 1562 lldb::ValueObjectSP 1563 SBValue::GetSP () const 1564 { 1565 if (!m_opaque_sp || !m_opaque_sp->IsValid()) 1566 return ValueObjectSP(); 1567 return m_opaque_sp->GetSP(); 1568 } 1569 1570 void 1571 SBValue::SetSP (ValueImplSP impl_sp) 1572 { 1573 m_opaque_sp = impl_sp; 1574 } 1575 1576 void 1577 SBValue::SetSP (const lldb::ValueObjectSP &sp) 1578 { 1579 if (sp) 1580 { 1581 lldb::TargetSP target_sp(sp->GetTargetSP()); 1582 if (target_sp) 1583 { 1584 lldb::DynamicValueType use_dynamic = target_sp->GetPreferDynamicValue(); 1585 bool use_synthetic = target_sp->TargetProperties::GetEnableSyntheticValue(); 1586 m_opaque_sp = ValueImplSP(new ValueImpl(sp, use_dynamic, use_synthetic)); 1587 } 1588 else 1589 m_opaque_sp = ValueImplSP(new ValueImpl(sp,eNoDynamicValues,true)); 1590 } 1591 else 1592 m_opaque_sp = ValueImplSP(new ValueImpl(sp,eNoDynamicValues,false)); 1593 } 1594 1595 void 1596 SBValue::SetSP (const lldb::ValueObjectSP &sp, lldb::DynamicValueType use_dynamic) 1597 { 1598 if (sp) 1599 { 1600 lldb::TargetSP target_sp(sp->GetTargetSP()); 1601 if (target_sp) 1602 { 1603 bool use_synthetic = target_sp->TargetProperties::GetEnableSyntheticValue(); 1604 SetSP (sp, use_dynamic, use_synthetic); 1605 } 1606 else 1607 SetSP (sp, use_dynamic, true); 1608 } 1609 else 1610 SetSP (sp, use_dynamic, false); 1611 } 1612 1613 void 1614 SBValue::SetSP (const lldb::ValueObjectSP &sp, bool use_synthetic) 1615 { 1616 if (sp) 1617 { 1618 lldb::TargetSP target_sp(sp->GetTargetSP()); 1619 if (target_sp) 1620 { 1621 lldb::DynamicValueType use_dynamic = target_sp->GetPreferDynamicValue(); 1622 SetSP (sp, use_dynamic, use_synthetic); 1623 } 1624 else 1625 SetSP (sp, eNoDynamicValues, use_synthetic); 1626 } 1627 else 1628 SetSP (sp, eNoDynamicValues, use_synthetic); 1629 } 1630 1631 void 1632 SBValue::SetSP (const lldb::ValueObjectSP &sp, lldb::DynamicValueType use_dynamic, bool use_synthetic) 1633 { 1634 m_opaque_sp = ValueImplSP(new ValueImpl(sp,use_dynamic,use_synthetic)); 1635 } 1636 1637 bool 1638 SBValue::GetExpressionPath (SBStream &description) 1639 { 1640 lldb::ValueObjectSP value_sp(GetSP()); 1641 if (value_sp) 1642 { 1643 value_sp->GetExpressionPath (description.ref(), false); 1644 return true; 1645 } 1646 return false; 1647 } 1648 1649 bool 1650 SBValue::GetExpressionPath (SBStream &description, bool qualify_cxx_base_classes) 1651 { 1652 lldb::ValueObjectSP value_sp(GetSP()); 1653 if (value_sp) 1654 { 1655 value_sp->GetExpressionPath (description.ref(), qualify_cxx_base_classes); 1656 return true; 1657 } 1658 return false; 1659 } 1660 1661 bool 1662 SBValue::GetDescription (SBStream &description) 1663 { 1664 Stream &strm = description.ref(); 1665 1666 lldb::ValueObjectSP value_sp(GetSP()); 1667 if (value_sp) 1668 { 1669 ProcessSP process_sp(value_sp->GetProcessSP()); 1670 Process::StopLocker stop_locker; 1671 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 1672 { 1673 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1674 if (log) 1675 log->Printf ("SBValue(%p)::GetDescription() => error: process is running", value_sp.get()); 1676 } 1677 else 1678 { 1679 ValueObject::DumpValueObject (strm, value_sp.get()); 1680 } 1681 } 1682 else 1683 strm.PutCString ("No value"); 1684 1685 return true; 1686 } 1687 1688 lldb::Format 1689 SBValue::GetFormat () 1690 { 1691 lldb::ValueObjectSP value_sp(GetSP()); 1692 if (value_sp) 1693 return value_sp->GetFormat(); 1694 return eFormatDefault; 1695 } 1696 1697 void 1698 SBValue::SetFormat (lldb::Format format) 1699 { 1700 lldb::ValueObjectSP value_sp(GetSP()); 1701 if (value_sp) 1702 value_sp->SetFormat(format); 1703 } 1704 1705 lldb::SBValue 1706 SBValue::AddressOf() 1707 { 1708 SBValue sb_value; 1709 lldb::ValueObjectSP value_sp(GetSP()); 1710 if (value_sp) 1711 { 1712 TargetSP target_sp (value_sp->GetTargetSP()); 1713 if (target_sp) 1714 { 1715 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1716 Error error; 1717 sb_value.SetSP(value_sp->AddressOf (error),GetPreferDynamicValue(), GetPreferSyntheticValue()); 1718 } 1719 } 1720 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1721 if (log) 1722 log->Printf ("SBValue(%p)::AddressOf () => SBValue(%p)", value_sp.get(), value_sp.get()); 1723 1724 return sb_value; 1725 } 1726 1727 lldb::addr_t 1728 SBValue::GetLoadAddress() 1729 { 1730 lldb::addr_t value = LLDB_INVALID_ADDRESS; 1731 lldb::ValueObjectSP value_sp(GetSP()); 1732 if (value_sp) 1733 { 1734 TargetSP target_sp (value_sp->GetTargetSP()); 1735 if (target_sp) 1736 { 1737 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1738 const bool scalar_is_load_address = true; 1739 AddressType addr_type; 1740 value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type); 1741 if (addr_type == eAddressTypeFile) 1742 { 1743 ModuleSP module_sp (value_sp->GetModule()); 1744 if (!module_sp) 1745 value = LLDB_INVALID_ADDRESS; 1746 else 1747 { 1748 Address addr; 1749 module_sp->ResolveFileAddress(value, addr); 1750 value = addr.GetLoadAddress(target_sp.get()); 1751 } 1752 } 1753 else if (addr_type == eAddressTypeHost || addr_type == eAddressTypeInvalid) 1754 value = LLDB_INVALID_ADDRESS; 1755 } 1756 } 1757 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1758 if (log) 1759 log->Printf ("SBValue(%p)::GetLoadAddress () => (%" PRIu64 ")", value_sp.get(), value); 1760 1761 return value; 1762 } 1763 1764 lldb::SBAddress 1765 SBValue::GetAddress() 1766 { 1767 Address addr; 1768 lldb::ValueObjectSP value_sp(GetSP()); 1769 if (value_sp) 1770 { 1771 TargetSP target_sp (value_sp->GetTargetSP()); 1772 if (target_sp) 1773 { 1774 lldb::addr_t value = LLDB_INVALID_ADDRESS; 1775 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1776 const bool scalar_is_load_address = true; 1777 AddressType addr_type; 1778 value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type); 1779 if (addr_type == eAddressTypeFile) 1780 { 1781 ModuleSP module_sp (value_sp->GetModule()); 1782 if (module_sp) 1783 module_sp->ResolveFileAddress(value, addr); 1784 } 1785 else if (addr_type == eAddressTypeLoad) 1786 { 1787 // no need to check the return value on this.. if it can actually do the resolve 1788 // addr will be in the form (section,offset), otherwise it will simply be returned 1789 // as (NULL, value) 1790 addr.SetLoadAddress(value, target_sp.get()); 1791 } 1792 } 1793 } 1794 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1795 if (log) 1796 log->Printf ("SBValue(%p)::GetAddress () => (%s,%" PRIu64 ")", value_sp.get(), 1797 (addr.GetSection() ? addr.GetSection()->GetName().GetCString() : "NULL"), 1798 addr.GetOffset()); 1799 return SBAddress(new Address(addr)); 1800 } 1801 1802 lldb::SBData 1803 SBValue::GetPointeeData (uint32_t item_idx, 1804 uint32_t item_count) 1805 { 1806 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1807 lldb::SBData sb_data; 1808 lldb::ValueObjectSP value_sp(GetSP()); 1809 if (value_sp) 1810 { 1811 ProcessSP process_sp(value_sp->GetProcessSP()); 1812 Process::StopLocker stop_locker; 1813 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 1814 { 1815 if (log) 1816 log->Printf ("SBValue(%p)::GetPointeeData() => error: process is running", value_sp.get()); 1817 } 1818 else 1819 { 1820 TargetSP target_sp (value_sp->GetTargetSP()); 1821 if (target_sp) 1822 { 1823 DataExtractorSP data_sp(new DataExtractor()); 1824 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1825 value_sp->GetPointeeData(*data_sp, item_idx, item_count); 1826 if (data_sp->GetByteSize() > 0) 1827 *sb_data = data_sp; 1828 } 1829 } 1830 } 1831 if (log) 1832 log->Printf ("SBValue(%p)::GetPointeeData (%d, %d) => SBData(%p)", 1833 value_sp.get(), 1834 item_idx, 1835 item_count, 1836 sb_data.get()); 1837 1838 return sb_data; 1839 } 1840 1841 lldb::SBData 1842 SBValue::GetData () 1843 { 1844 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1845 lldb::SBData sb_data; 1846 lldb::ValueObjectSP value_sp(GetSP()); 1847 if (value_sp) 1848 { 1849 ProcessSP process_sp(value_sp->GetProcessSP()); 1850 Process::StopLocker stop_locker; 1851 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 1852 { 1853 if (log) 1854 log->Printf ("SBValue(%p)::GetData() => error: process is running", value_sp.get()); 1855 } 1856 else 1857 { 1858 TargetSP target_sp (value_sp->GetTargetSP()); 1859 if (target_sp) 1860 { 1861 Mutex::Locker api_locker (target_sp->GetAPIMutex()); 1862 DataExtractorSP data_sp(new DataExtractor()); 1863 value_sp->GetData(*data_sp); 1864 if (data_sp->GetByteSize() > 0) 1865 *sb_data = data_sp; 1866 } 1867 } 1868 } 1869 if (log) 1870 log->Printf ("SBValue(%p)::GetData () => SBData(%p)", 1871 value_sp.get(), 1872 sb_data.get()); 1873 1874 return sb_data; 1875 } 1876 1877 lldb::SBDeclaration 1878 SBValue::GetDeclaration () 1879 { 1880 lldb::ValueObjectSP value_sp(GetSP()); 1881 SBDeclaration decl_sb; 1882 if (value_sp) 1883 { 1884 Declaration decl; 1885 if (value_sp->GetDeclaration(decl)) 1886 decl_sb.SetDeclaration(decl); 1887 } 1888 return decl_sb; 1889 } 1890 1891 lldb::SBWatchpoint 1892 SBValue::Watch (bool resolve_location, bool read, bool write, SBError &error) 1893 { 1894 SBWatchpoint sb_watchpoint; 1895 1896 // If the SBValue is not valid, there's no point in even trying to watch it. 1897 lldb::ValueObjectSP value_sp(GetSP()); 1898 TargetSP target_sp (GetTarget().GetSP()); 1899 if (value_sp && target_sp) 1900 { 1901 // Can't watch this if the process is running 1902 ProcessSP process_sp(value_sp->GetProcessSP()); 1903 Process::StopLocker stop_locker; 1904 if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) 1905 { 1906 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1907 if (log) 1908 log->Printf ("SBValue(%p)::Watch() => error: process is running", value_sp.get()); 1909 return sb_watchpoint; 1910 } 1911 1912 // Read and Write cannot both be false. 1913 if (!read && !write) 1914 return sb_watchpoint; 1915 1916 // If the value is not in scope, don't try and watch and invalid value 1917 if (!IsInScope()) 1918 return sb_watchpoint; 1919 1920 addr_t addr = GetLoadAddress(); 1921 if (addr == LLDB_INVALID_ADDRESS) 1922 return sb_watchpoint; 1923 size_t byte_size = GetByteSize(); 1924 if (byte_size == 0) 1925 return sb_watchpoint; 1926 1927 uint32_t watch_type = 0; 1928 if (read) 1929 watch_type |= LLDB_WATCH_TYPE_READ; 1930 if (write) 1931 watch_type |= LLDB_WATCH_TYPE_WRITE; 1932 1933 Error rc; 1934 ClangASTType type (value_sp->GetClangAST(), value_sp->GetClangType()); 1935 WatchpointSP watchpoint_sp = target_sp->CreateWatchpoint(addr, byte_size, &type, watch_type, rc); 1936 error.SetError(rc); 1937 1938 if (watchpoint_sp) 1939 { 1940 sb_watchpoint.SetSP (watchpoint_sp); 1941 Declaration decl; 1942 if (value_sp->GetDeclaration (decl)) 1943 { 1944 if (decl.GetFile()) 1945 { 1946 StreamString ss; 1947 // True to show fullpath for declaration file. 1948 decl.DumpStopContext(&ss, true); 1949 watchpoint_sp->SetDeclInfo(ss.GetString()); 1950 } 1951 } 1952 } 1953 } 1954 return sb_watchpoint; 1955 } 1956 1957 // FIXME: Remove this method impl (as well as the decl in .h) once it is no longer needed. 1958 // Backward compatibility fix in the interim. 1959 lldb::SBWatchpoint 1960 SBValue::Watch (bool resolve_location, bool read, bool write) 1961 { 1962 SBError error; 1963 return Watch(resolve_location, read, write, error); 1964 } 1965 1966 lldb::SBWatchpoint 1967 SBValue::WatchPointee (bool resolve_location, bool read, bool write, SBError &error) 1968 { 1969 SBWatchpoint sb_watchpoint; 1970 if (IsInScope() && GetType().IsPointerType()) 1971 sb_watchpoint = Dereference().Watch (resolve_location, read, write, error); 1972 return sb_watchpoint; 1973 } 1974