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