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