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 #include "lldb/API/SBStream.h" 12 13 #include "lldb/Breakpoint/Watchpoint.h" 14 #include "lldb/Core/DataExtractor.h" 15 #include "lldb/Core/Log.h" 16 #include "lldb/Core/Module.h" 17 #include "lldb/Core/Scalar.h" 18 #include "lldb/Core/Stream.h" 19 #include "lldb/Core/StreamFile.h" 20 #include "lldb/Core/Value.h" 21 #include "lldb/Core/ValueObject.h" 22 #include "lldb/Core/ValueObjectConstResult.h" 23 #include "lldb/Symbol/Block.h" 24 #include "lldb/Symbol/ObjectFile.h" 25 #include "lldb/Symbol/Variable.h" 26 #include "lldb/Symbol/VariableList.h" 27 #include "lldb/Target/ExecutionContext.h" 28 #include "lldb/Target/Process.h" 29 #include "lldb/Target/StackFrame.h" 30 #include "lldb/Target/Target.h" 31 #include "lldb/Target/Thread.h" 32 33 #include "lldb/API/SBProcess.h" 34 #include "lldb/API/SBTarget.h" 35 #include "lldb/API/SBThread.h" 36 #include "lldb/API/SBFrame.h" 37 #include "lldb/API/SBDebugger.h" 38 39 using namespace lldb; 40 using namespace lldb_private; 41 42 SBValue::SBValue () : 43 m_opaque_sp () 44 { 45 } 46 47 SBValue::SBValue (const lldb::ValueObjectSP &value_sp) : 48 m_opaque_sp (value_sp) 49 { 50 } 51 52 SBValue::SBValue(const SBValue &rhs) : 53 m_opaque_sp (rhs.m_opaque_sp) 54 { 55 } 56 57 SBValue & 58 SBValue::operator = (const SBValue &rhs) 59 { 60 if (this != &rhs) 61 m_opaque_sp = rhs.m_opaque_sp; 62 return *this; 63 } 64 65 SBValue::~SBValue() 66 { 67 } 68 69 bool 70 SBValue::IsValid () 71 { 72 // If this function ever changes to anything that does more than just 73 // check if the opaque shared pointer is non NULL, then we need to update 74 // all "if (m_opaque_sp)" code in this file. 75 return m_opaque_sp.get() != NULL; 76 } 77 78 SBError 79 SBValue::GetError() 80 { 81 SBError sb_error; 82 83 if (m_opaque_sp.get()) 84 sb_error.SetError(m_opaque_sp->GetError()); 85 86 return sb_error; 87 } 88 89 user_id_t 90 SBValue::GetID() 91 { 92 if (m_opaque_sp) 93 return m_opaque_sp->GetID(); 94 return LLDB_INVALID_UID; 95 } 96 97 const char * 98 SBValue::GetName() 99 { 100 101 const char *name = NULL; 102 if (m_opaque_sp) 103 name = m_opaque_sp->GetName().GetCString(); 104 105 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 106 if (log) 107 { 108 if (name) 109 log->Printf ("SBValue(%p)::GetName () => \"%s\"", m_opaque_sp.get(), name); 110 else 111 log->Printf ("SBValue(%p)::GetName () => NULL", m_opaque_sp.get()); 112 } 113 114 return name; 115 } 116 117 const char * 118 SBValue::GetTypeName () 119 { 120 const char *name = NULL; 121 if (m_opaque_sp) 122 name = m_opaque_sp->GetTypeName().GetCString(); 123 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 124 if (log) 125 { 126 if (name) 127 log->Printf ("SBValue(%p)::GetTypeName () => \"%s\"", m_opaque_sp.get(), name); 128 else 129 log->Printf ("SBValue(%p)::GetTypeName () => NULL", m_opaque_sp.get()); 130 } 131 132 return name; 133 } 134 135 size_t 136 SBValue::GetByteSize () 137 { 138 size_t result = 0; 139 140 if (m_opaque_sp) 141 result = m_opaque_sp->GetByteSize(); 142 143 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 144 if (log) 145 log->Printf ("SBValue(%p)::GetByteSize () => %zu", m_opaque_sp.get(), result); 146 147 return result; 148 } 149 150 bool 151 SBValue::IsInScope () 152 { 153 bool result = false; 154 155 if (m_opaque_sp) 156 { 157 if (m_opaque_sp->GetUpdatePoint().GetTargetSP()) 158 { 159 Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); 160 result = m_opaque_sp->IsInScope (); 161 } 162 } 163 164 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 165 if (log) 166 log->Printf ("SBValue(%p)::IsInScope () => %i", m_opaque_sp.get(), result); 167 168 return result; 169 } 170 171 const char * 172 SBValue::GetValue () 173 { 174 const char *cstr = NULL; 175 if (m_opaque_sp) 176 { 177 if (m_opaque_sp->GetUpdatePoint().GetTargetSP()) 178 { 179 Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); 180 cstr = m_opaque_sp->GetValueAsCString (); 181 } 182 } 183 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 184 if (log) 185 { 186 if (cstr) 187 log->Printf ("SBValue(%p)::GetValue => \"%s\"", m_opaque_sp.get(), cstr); 188 else 189 log->Printf ("SBValue(%p)::GetValue => NULL", m_opaque_sp.get()); 190 } 191 192 return cstr; 193 } 194 195 ValueType 196 SBValue::GetValueType () 197 { 198 ValueType result = eValueTypeInvalid; 199 if (m_opaque_sp) 200 result = m_opaque_sp->GetValueType(); 201 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 202 if (log) 203 { 204 switch (result) 205 { 206 case eValueTypeInvalid: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeInvalid", m_opaque_sp.get()); break; 207 case eValueTypeVariableGlobal: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableGlobal", m_opaque_sp.get()); break; 208 case eValueTypeVariableStatic: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableStatic", m_opaque_sp.get()); break; 209 case eValueTypeVariableArgument:log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableArgument", m_opaque_sp.get()); break; 210 case eValueTypeVariableLocal: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableLocal", m_opaque_sp.get()); break; 211 case eValueTypeRegister: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeRegister", m_opaque_sp.get()); break; 212 case eValueTypeRegisterSet: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeRegisterSet", m_opaque_sp.get()); break; 213 case eValueTypeConstResult: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeConstResult", m_opaque_sp.get()); break; 214 default: log->Printf ("SBValue(%p)::GetValueType () => %i ???", m_opaque_sp.get(), result); break; 215 } 216 } 217 return result; 218 } 219 220 const char * 221 SBValue::GetObjectDescription () 222 { 223 const char *cstr = NULL; 224 if (m_opaque_sp) 225 { 226 if (m_opaque_sp->GetUpdatePoint().GetTargetSP()) 227 { 228 Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); 229 cstr = m_opaque_sp->GetObjectDescription (); 230 } 231 } 232 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 233 if (log) 234 { 235 if (cstr) 236 log->Printf ("SBValue(%p)::GetObjectDescription => \"%s\"", m_opaque_sp.get(), cstr); 237 else 238 log->Printf ("SBValue(%p)::GetObjectDescription => NULL", m_opaque_sp.get()); 239 } 240 return cstr; 241 } 242 243 SBType 244 SBValue::GetType() 245 { 246 SBType result; 247 if (m_opaque_sp) 248 { 249 if (m_opaque_sp->GetUpdatePoint().GetTargetSP()) 250 { 251 Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); 252 result = SBType(ClangASTType (m_opaque_sp->GetClangAST(), m_opaque_sp->GetClangType())); 253 } 254 } 255 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 256 if (log) 257 { 258 if (result.IsValid()) 259 log->Printf ("SBValue(%p)::GetType => %p", m_opaque_sp.get(), &result); 260 else 261 log->Printf ("SBValue(%p)::GetType => NULL", m_opaque_sp.get()); 262 } 263 return result; 264 } 265 266 bool 267 SBValue::GetValueDidChange () 268 { 269 bool result = false; 270 if (m_opaque_sp) 271 { 272 if (m_opaque_sp->GetUpdatePoint().GetTargetSP()) 273 { 274 Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); 275 result = m_opaque_sp->GetValueDidChange (); 276 } 277 } 278 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 279 if (log) 280 log->Printf ("SBValue(%p)::GetValueDidChange => %i", m_opaque_sp.get(), result); 281 282 return result; 283 } 284 285 const char * 286 SBValue::GetSummary () 287 { 288 const char *cstr = NULL; 289 if (m_opaque_sp) 290 { 291 if (m_opaque_sp->GetUpdatePoint().GetTargetSP()) 292 { 293 Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); 294 cstr = m_opaque_sp->GetSummaryAsCString(); 295 } 296 } 297 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 298 if (log) 299 { 300 if (cstr) 301 log->Printf ("SBValue(%p)::GetSummary => \"%s\"", m_opaque_sp.get(), cstr); 302 else 303 log->Printf ("SBValue(%p)::GetSummary => NULL", m_opaque_sp.get()); 304 } 305 return cstr; 306 } 307 308 const char * 309 SBValue::GetLocation () 310 { 311 const char *cstr = NULL; 312 if (m_opaque_sp) 313 { 314 if (m_opaque_sp->GetUpdatePoint().GetTargetSP()) 315 { 316 Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); 317 cstr = m_opaque_sp->GetLocationAsCString(); 318 } 319 } 320 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 321 if (log) 322 { 323 if (cstr) 324 log->Printf ("SBValue(%p)::GetSummary => \"%s\"", m_opaque_sp.get(), cstr); 325 else 326 log->Printf ("SBValue(%p)::GetSummary => NULL", m_opaque_sp.get()); 327 } 328 return cstr; 329 } 330 331 bool 332 SBValue::SetValueFromCString (const char *value_str) 333 { 334 bool success = false; 335 if (m_opaque_sp) 336 { 337 if (m_opaque_sp->GetUpdatePoint().GetTargetSP()) 338 { 339 Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); 340 success = m_opaque_sp->SetValueFromCString (value_str); 341 } 342 } 343 return success; 344 } 345 346 lldb::SBValue 347 SBValue::CreateChildAtOffset (const char *name, uint32_t offset, SBType type) 348 { 349 lldb::SBValue result; 350 if (m_opaque_sp) 351 { 352 if (type.IsValid()) 353 { 354 result = SBValue(m_opaque_sp->GetSyntheticChildAtOffset(offset, type.m_opaque_sp->GetClangASTType(), true)); 355 result.m_opaque_sp->SetName(ConstString(name)); 356 } 357 } 358 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 359 if (log) 360 { 361 if (result.IsValid()) 362 log->Printf ("SBValue(%p)::GetChildAtOffset => \"%s\"", m_opaque_sp.get(), result.m_opaque_sp->GetName().AsCString()); 363 else 364 log->Printf ("SBValue(%p)::GetChildAtOffset => NULL", m_opaque_sp.get()); 365 } 366 return result; 367 } 368 369 lldb::SBValue 370 SBValue::Cast (SBType type) 371 { 372 return CreateChildAtOffset(m_opaque_sp->GetName().GetCString(), 0, type); 373 } 374 375 lldb::SBValue 376 SBValue::CreateValueFromExpression (const char *name, const char* expression) 377 { 378 lldb::SBValue result; 379 if (m_opaque_sp) 380 { 381 ValueObjectSP result_valobj_sp; 382 m_opaque_sp->GetUpdatePoint().GetTargetSP()->EvaluateExpression (expression, 383 m_opaque_sp->GetUpdatePoint().GetExecutionContextScope()->CalculateStackFrame(), 384 eExecutionPolicyOnlyWhenNeeded, 385 true, // unwind on error 386 true, // keep in memory 387 eNoDynamicValues, 388 result_valobj_sp); 389 result_valobj_sp->SetName(ConstString(name)); 390 result = SBValue(result_valobj_sp); 391 } 392 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 393 if (log) 394 { 395 if (result.IsValid()) 396 log->Printf ("SBValue(%p)::GetChildFromExpression => \"%s\"", m_opaque_sp.get(), result.m_opaque_sp->GetName().AsCString()); 397 else 398 log->Printf ("SBValue(%p)::GetChildFromExpression => NULL", m_opaque_sp.get()); 399 } 400 return result; 401 } 402 403 lldb::SBValue 404 SBValue::CreateValueFromAddress(const char* name, lldb::addr_t address, SBType type) 405 { 406 lldb::SBValue result; 407 if (m_opaque_sp) 408 { 409 410 SBType real_type(type.GetPointerType()); 411 412 lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(&address,sizeof(lldb::addr_t))); 413 414 ValueObjectSP ptr_result_valobj_sp(ValueObjectConstResult::Create (m_opaque_sp->GetUpdatePoint().GetExecutionContextScope(), 415 real_type.m_opaque_sp->GetASTContext(), 416 real_type.m_opaque_sp->GetOpaqueQualType(), 417 ConstString(name), 418 buffer, 419 lldb::endian::InlHostByteOrder(), 420 GetTarget().GetProcess().GetAddressByteSize())); 421 422 ValueObjectSP result_valobj_sp; 423 424 ptr_result_valobj_sp->GetValue().SetValueType(Value::eValueTypeLoadAddress); 425 if (ptr_result_valobj_sp) 426 { 427 Error err; 428 result_valobj_sp = ptr_result_valobj_sp->Dereference(err); 429 if (result_valobj_sp) 430 result_valobj_sp->SetName(ConstString(name)); 431 } 432 result = SBValue(result_valobj_sp); 433 } 434 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 435 if (log) 436 { 437 if (result.IsValid()) 438 log->Printf ("SBValue(%p)::GetChildFromAddress => \"%s\"", m_opaque_sp.get(), result.m_opaque_sp->GetName().AsCString()); 439 else 440 log->Printf ("SBValue(%p)::GetChildFromAddress => NULL", m_opaque_sp.get()); 441 } 442 return result; 443 } 444 445 lldb::SBValue 446 SBValue::CreateValueFromData (const char* name, SBData data, SBType type) 447 { 448 SBValue result; 449 450 AddressType addr_of_children_priv = eAddressTypeLoad; 451 452 if (m_opaque_sp) 453 { 454 ValueObjectSP valobj_sp; 455 valobj_sp = ValueObjectConstResult::Create (m_opaque_sp->GetExecutionContextScope(), 456 type.m_opaque_sp->GetASTContext() , 457 type.m_opaque_sp->GetOpaqueQualType(), 458 ConstString(name), 459 *data.m_opaque_sp, 460 LLDB_INVALID_ADDRESS); 461 valobj_sp->SetAddressTypeOfChildren(addr_of_children_priv); 462 result = SBValue(valobj_sp); 463 } 464 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 465 if (log) 466 { 467 if (result.IsValid()) 468 log->Printf ("SBValue(%p)::GetChildFromExpression => \"%s\"", m_opaque_sp.get(), result.m_opaque_sp->GetName().AsCString()); 469 else 470 log->Printf ("SBValue(%p)::GetChildFromExpression => NULL", m_opaque_sp.get()); 471 } 472 return result; 473 } 474 475 SBValue 476 SBValue::GetChildAtIndex (uint32_t idx) 477 { 478 const bool can_create_synthetic = false; 479 lldb::DynamicValueType use_dynamic = eNoDynamicValues; 480 if (m_opaque_sp) 481 use_dynamic = m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetPreferDynamicValue(); 482 return GetChildAtIndex (idx, use_dynamic, can_create_synthetic); 483 } 484 485 SBValue 486 SBValue::GetChildAtIndex (uint32_t idx, lldb::DynamicValueType use_dynamic, bool can_create_synthetic) 487 { 488 lldb::ValueObjectSP child_sp; 489 490 if (m_opaque_sp) 491 { 492 if (m_opaque_sp->GetUpdatePoint().GetTargetSP()) 493 { 494 Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); 495 const bool can_create = true; 496 child_sp = m_opaque_sp->GetChildAtIndex (idx, can_create); 497 if (can_create_synthetic && !child_sp) 498 { 499 if (m_opaque_sp->IsPointerType()) 500 { 501 child_sp = m_opaque_sp->GetSyntheticArrayMemberFromPointer(idx, can_create); 502 } 503 else if (m_opaque_sp->IsArrayType()) 504 { 505 child_sp = m_opaque_sp->GetSyntheticArrayMemberFromArray(idx, can_create); 506 } 507 } 508 509 if (child_sp) 510 { 511 if (use_dynamic != lldb::eNoDynamicValues) 512 { 513 lldb::ValueObjectSP dynamic_sp(child_sp->GetDynamicValue (use_dynamic)); 514 if (dynamic_sp) 515 child_sp = dynamic_sp; 516 } 517 } 518 } 519 } 520 521 SBValue sb_value (child_sp); 522 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 523 if (log) 524 log->Printf ("SBValue(%p)::GetChildAtIndex (%u) => SBValue(%p)", m_opaque_sp.get(), idx, sb_value.get()); 525 526 return sb_value; 527 } 528 529 uint32_t 530 SBValue::GetIndexOfChildWithName (const char *name) 531 { 532 uint32_t idx = UINT32_MAX; 533 if (m_opaque_sp) 534 { 535 if (m_opaque_sp->GetUpdatePoint().GetTargetSP()) 536 { 537 Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); 538 539 idx = m_opaque_sp->GetIndexOfChildWithName (ConstString(name)); 540 } 541 } 542 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 543 if (log) 544 { 545 if (idx == UINT32_MAX) 546 log->Printf ("SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => NOT FOUND", m_opaque_sp.get(), name); 547 else 548 log->Printf ("SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => %u", m_opaque_sp.get(), name, idx); 549 } 550 return idx; 551 } 552 553 SBValue 554 SBValue::GetChildMemberWithName (const char *name) 555 { 556 if (m_opaque_sp) 557 { 558 lldb::DynamicValueType use_dynamic_value = m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetPreferDynamicValue(); 559 return GetChildMemberWithName (name, use_dynamic_value); 560 } 561 else 562 return GetChildMemberWithName (name, eNoDynamicValues); 563 } 564 565 SBValue 566 SBValue::GetChildMemberWithName (const char *name, lldb::DynamicValueType use_dynamic_value) 567 { 568 lldb::ValueObjectSP child_sp; 569 const ConstString str_name (name); 570 571 572 if (m_opaque_sp) 573 { 574 if (m_opaque_sp->GetUpdatePoint().GetTargetSP()) 575 { 576 Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); 577 child_sp = m_opaque_sp->GetChildMemberWithName (str_name, true); 578 if (use_dynamic_value != lldb::eNoDynamicValues) 579 { 580 if (child_sp) 581 { 582 lldb::ValueObjectSP dynamic_sp = child_sp->GetDynamicValue (use_dynamic_value); 583 if (dynamic_sp) 584 child_sp = dynamic_sp; 585 } 586 } 587 } 588 } 589 590 SBValue sb_value (child_sp); 591 592 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 593 if (log) 594 log->Printf ("SBValue(%p)::GetChildMemberWithName (name=\"%s\") => SBValue(%p)", m_opaque_sp.get(), name, sb_value.get()); 595 596 return sb_value; 597 } 598 599 lldb::SBValue 600 SBValue::GetValueForExpressionPath(const char* expr_path) 601 { 602 lldb::ValueObjectSP child_sp; 603 if (m_opaque_sp) 604 { 605 if (m_opaque_sp->GetUpdatePoint().GetTargetSP()) 606 { 607 Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); 608 // using default values for all the fancy options, just do it if you can 609 child_sp = m_opaque_sp->GetValueForExpressionPath(expr_path); 610 } 611 } 612 613 SBValue sb_value (child_sp); 614 615 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 616 if (log) 617 log->Printf ("SBValue(%p)::GetValueForExpressionPath (expr_path=\"%s\") => SBValue(%p)", m_opaque_sp.get(), expr_path, sb_value.get()); 618 619 return sb_value; 620 } 621 622 int64_t 623 SBValue::GetValueAsSigned(SBError& error, int64_t fail_value) 624 { 625 error.Clear(); 626 if (m_opaque_sp) 627 { 628 if (m_opaque_sp->GetUpdatePoint().GetTargetSP()) 629 { 630 Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); 631 Scalar scalar; 632 if (m_opaque_sp->ResolveValue (scalar)) 633 return scalar.GetRawBits64(fail_value); 634 else 635 error.SetErrorString("could not get value"); 636 } 637 else 638 error.SetErrorString("could not get target"); 639 } 640 error.SetErrorString("invalid SBValue"); 641 return fail_value; 642 } 643 644 uint64_t 645 SBValue::GetValueAsUnsigned(SBError& error, uint64_t fail_value) 646 { 647 error.Clear(); 648 if (m_opaque_sp) 649 { 650 if (m_opaque_sp->GetUpdatePoint().GetTargetSP()) 651 { 652 Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); 653 Scalar scalar; 654 if (m_opaque_sp->ResolveValue (scalar)) 655 return scalar.GetRawBits64(fail_value); 656 else 657 error.SetErrorString("could not get value"); 658 } 659 else 660 error.SetErrorString("could not get target"); 661 } 662 error.SetErrorString("invalid SBValue"); 663 return fail_value; 664 } 665 666 int64_t 667 SBValue::GetValueAsSigned(int64_t fail_value) 668 { 669 if (m_opaque_sp) 670 { 671 if (m_opaque_sp->GetUpdatePoint().GetTargetSP()) 672 { 673 Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); 674 Scalar scalar; 675 if (m_opaque_sp->ResolveValue (scalar)) 676 return scalar.GetRawBits64(fail_value); 677 } 678 } 679 return fail_value; 680 } 681 682 uint64_t 683 SBValue::GetValueAsUnsigned(uint64_t fail_value) 684 { 685 if (m_opaque_sp) 686 { 687 if (m_opaque_sp->GetUpdatePoint().GetTargetSP()) 688 { 689 Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); 690 Scalar scalar; 691 if (m_opaque_sp->ResolveValue (scalar)) 692 return scalar.GetRawBits64(fail_value); 693 } 694 } 695 return fail_value; 696 } 697 698 uint32_t 699 SBValue::GetNumChildren () 700 { 701 uint32_t num_children = 0; 702 703 if (m_opaque_sp) 704 { 705 if (m_opaque_sp->GetUpdatePoint().GetTargetSP()) 706 { 707 Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); 708 709 num_children = m_opaque_sp->GetNumChildren(); 710 } 711 } 712 713 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 714 if (log) 715 log->Printf ("SBValue(%p)::GetNumChildren () => %u", m_opaque_sp.get(), num_children); 716 717 return num_children; 718 } 719 720 721 SBValue 722 SBValue::Dereference () 723 { 724 SBValue sb_value; 725 if (m_opaque_sp) 726 { 727 if (m_opaque_sp->GetUpdatePoint().GetTargetSP()) 728 { 729 Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); 730 731 Error error; 732 sb_value = m_opaque_sp->Dereference (error); 733 } 734 } 735 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 736 if (log) 737 log->Printf ("SBValue(%p)::Dereference () => SBValue(%p)", m_opaque_sp.get(), sb_value.get()); 738 739 return sb_value; 740 } 741 742 bool 743 SBValue::TypeIsPointerType () 744 { 745 bool is_ptr_type = false; 746 747 if (m_opaque_sp) 748 { 749 if (m_opaque_sp->GetUpdatePoint().GetTargetSP()) 750 { 751 Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); 752 753 is_ptr_type = m_opaque_sp->IsPointerType(); 754 } 755 } 756 757 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 758 if (log) 759 log->Printf ("SBValue(%p)::TypeIsPointerType () => %i", m_opaque_sp.get(), is_ptr_type); 760 761 762 return is_ptr_type; 763 } 764 765 void * 766 SBValue::GetOpaqueType() 767 { 768 if (m_opaque_sp) 769 { 770 if (m_opaque_sp->GetUpdatePoint().GetTargetSP()) 771 { 772 Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); 773 774 return m_opaque_sp->GetClangType(); 775 } 776 } 777 return NULL; 778 } 779 780 lldb::SBTarget 781 SBValue::GetTarget() 782 { 783 SBTarget result; 784 if (m_opaque_sp) 785 { 786 if (m_opaque_sp->GetUpdatePoint().GetTargetSP()) 787 { 788 result = SBTarget(lldb::TargetSP(m_opaque_sp->GetUpdatePoint().GetTargetSP())); 789 } 790 } 791 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 792 if (log) 793 { 794 if (result.get() == NULL) 795 log->Printf ("SBValue(%p)::GetTarget () => NULL", m_opaque_sp.get()); 796 else 797 log->Printf ("SBValue(%p)::GetTarget () => %p", m_opaque_sp.get(), result.get()); 798 } 799 return result; 800 } 801 802 lldb::SBProcess 803 SBValue::GetProcess() 804 { 805 SBProcess result; 806 if (m_opaque_sp) 807 { 808 Target* target = m_opaque_sp->GetUpdatePoint().GetTargetSP().get(); 809 if (target) 810 { 811 result = SBProcess(lldb::ProcessSP(target->GetProcessSP())); 812 } 813 } 814 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 815 if (log) 816 { 817 if (result.get() == NULL) 818 log->Printf ("SBValue(%p)::GetProcess () => NULL", m_opaque_sp.get()); 819 else 820 log->Printf ("SBValue(%p)::GetProcess () => %p", m_opaque_sp.get(), result.get()); 821 } 822 return result; 823 } 824 825 lldb::SBThread 826 SBValue::GetThread() 827 { 828 SBThread result; 829 if (m_opaque_sp) 830 { 831 if (m_opaque_sp->GetUpdatePoint().GetExecutionContextScope()) 832 { 833 result = SBThread(m_opaque_sp->GetUpdatePoint().GetExecutionContextScope()->CalculateThread()->GetSP()); 834 } 835 } 836 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 837 if (log) 838 { 839 if (result.get() == NULL) 840 log->Printf ("SBValue(%p)::GetThread () => NULL", m_opaque_sp.get()); 841 else 842 log->Printf ("SBValue(%p)::GetThread () => %p", m_opaque_sp.get(), result.get()); 843 } 844 return result; 845 } 846 847 lldb::SBFrame 848 SBValue::GetFrame() 849 { 850 SBFrame result; 851 if (m_opaque_sp) 852 { 853 if (m_opaque_sp->GetUpdatePoint().GetExecutionContextScope()) 854 { 855 result.SetFrame (m_opaque_sp->GetUpdatePoint().GetExecutionContextScope()->CalculateStackFrame()->GetSP()); 856 } 857 } 858 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 859 if (log) 860 { 861 if (result.get() == NULL) 862 log->Printf ("SBValue(%p)::GetFrame () => NULL", m_opaque_sp.get()); 863 else 864 log->Printf ("SBValue(%p)::GetFrame () => %p", m_opaque_sp.get(), result.get()); 865 } 866 return result; 867 } 868 869 870 // Mimic shared pointer... 871 lldb_private::ValueObject * 872 SBValue::get() const 873 { 874 return m_opaque_sp.get(); 875 } 876 877 lldb_private::ValueObject * 878 SBValue::operator->() const 879 { 880 return m_opaque_sp.get(); 881 } 882 883 lldb::ValueObjectSP & 884 SBValue::operator*() 885 { 886 return m_opaque_sp; 887 } 888 889 const lldb::ValueObjectSP & 890 SBValue::operator*() const 891 { 892 return m_opaque_sp; 893 } 894 895 bool 896 SBValue::GetExpressionPath (SBStream &description) 897 { 898 if (m_opaque_sp) 899 { 900 m_opaque_sp->GetExpressionPath (description.ref(), false); 901 return true; 902 } 903 return false; 904 } 905 906 bool 907 SBValue::GetExpressionPath (SBStream &description, bool qualify_cxx_base_classes) 908 { 909 if (m_opaque_sp) 910 { 911 m_opaque_sp->GetExpressionPath (description.ref(), qualify_cxx_base_classes); 912 return true; 913 } 914 return false; 915 } 916 917 bool 918 SBValue::GetDescription (SBStream &description) 919 { 920 Stream &strm = description.ref(); 921 922 if (m_opaque_sp) 923 { 924 ValueObject::DumpValueObject (strm, m_opaque_sp.get()); 925 } 926 else 927 strm.PutCString ("No value"); 928 929 return true; 930 } 931 932 lldb::Format 933 SBValue::GetFormat () 934 { 935 if (m_opaque_sp) 936 return m_opaque_sp->GetFormat(); 937 return eFormatDefault; 938 } 939 940 void 941 SBValue::SetFormat (lldb::Format format) 942 { 943 if (m_opaque_sp) 944 m_opaque_sp->SetFormat(format); 945 } 946 947 lldb::SBValue 948 SBValue::AddressOf() 949 { 950 SBValue sb_value; 951 if (m_opaque_sp) 952 { 953 Target* target = m_opaque_sp->GetUpdatePoint().GetTargetSP().get(); 954 if (target) 955 { 956 Mutex::Locker api_locker (target->GetAPIMutex()); 957 Error error; 958 sb_value = m_opaque_sp->AddressOf (error); 959 } 960 } 961 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 962 if (log) 963 log->Printf ("SBValue(%p)::GetPointerToObject () => SBValue(%p)", m_opaque_sp.get(), sb_value.get()); 964 965 return sb_value; 966 } 967 968 lldb::addr_t 969 SBValue::GetLoadAddress() 970 { 971 lldb::addr_t value = LLDB_INVALID_ADDRESS; 972 if (m_opaque_sp) 973 { 974 Target* target = m_opaque_sp->GetUpdatePoint().GetTargetSP().get(); 975 if (target) 976 { 977 Mutex::Locker api_locker (target->GetAPIMutex()); 978 const bool scalar_is_load_address = true; 979 AddressType addr_type; 980 value = m_opaque_sp->GetAddressOf(scalar_is_load_address, &addr_type); 981 if (addr_type == eAddressTypeFile) 982 { 983 Module* module = m_opaque_sp->GetModule(); 984 if (!module) 985 value = LLDB_INVALID_ADDRESS; 986 else 987 { 988 Address addr; 989 module->ResolveFileAddress(value, addr); 990 value = addr.GetLoadAddress(m_opaque_sp->GetUpdatePoint().GetTargetSP().get()); 991 } 992 } 993 else if (addr_type == eAddressTypeHost || addr_type == eAddressTypeInvalid) 994 value = LLDB_INVALID_ADDRESS; 995 } 996 } 997 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 998 if (log) 999 log->Printf ("SBValue(%p)::GetLoadAddress () => (%llu)", m_opaque_sp.get(), value); 1000 1001 return value; 1002 } 1003 1004 lldb::SBAddress 1005 SBValue::GetAddress() 1006 { 1007 Address addr; 1008 if (m_opaque_sp) 1009 { 1010 Target* target = m_opaque_sp->GetUpdatePoint().GetTargetSP().get(); 1011 if (target) 1012 { 1013 lldb::addr_t value = LLDB_INVALID_ADDRESS; 1014 Mutex::Locker api_locker (target->GetAPIMutex()); 1015 const bool scalar_is_load_address = true; 1016 AddressType addr_type; 1017 value = m_opaque_sp->GetAddressOf(scalar_is_load_address, &addr_type); 1018 if (addr_type == eAddressTypeFile) 1019 { 1020 Module* module = m_opaque_sp->GetModule(); 1021 if (module) 1022 module->ResolveFileAddress(value, addr); 1023 } 1024 else if (addr_type == eAddressTypeLoad) 1025 { 1026 // no need to check the return value on this.. if it can actually do the resolve 1027 // addr will be in the form (section,offset), otherwise it will simply be returned 1028 // as (NULL, value) 1029 addr.SetLoadAddress(value, target); 1030 } 1031 } 1032 } 1033 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1034 if (log) 1035 log->Printf ("SBValue(%p)::GetAddress () => (%s,%llu)", m_opaque_sp.get(), (addr.GetSection() ? addr.GetSection()->GetName().GetCString() : "NULL"), addr.GetOffset()); 1036 return SBAddress(new Address(addr)); 1037 } 1038 1039 lldb::SBData 1040 SBValue::GetPointeeData (uint32_t item_idx, 1041 uint32_t item_count) 1042 { 1043 lldb::SBData sb_data; 1044 if (m_opaque_sp) 1045 { 1046 Target* target = m_opaque_sp->GetUpdatePoint().GetTargetSP().get(); 1047 if (target) 1048 { 1049 DataExtractorSP data_sp(new DataExtractor()); 1050 Mutex::Locker api_locker (target->GetAPIMutex()); 1051 m_opaque_sp->GetPointeeData(*data_sp, item_idx, item_count); 1052 if (data_sp->GetByteSize() > 0) 1053 *sb_data = data_sp; 1054 } 1055 } 1056 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1057 if (log) 1058 log->Printf ("SBValue(%p)::GetPointeeData (%d, %d) => SBData(%p)", 1059 m_opaque_sp.get(), 1060 item_idx, 1061 item_count, 1062 sb_data.get()); 1063 1064 return sb_data; 1065 } 1066 1067 lldb::SBData 1068 SBValue::GetData () 1069 { 1070 lldb::SBData sb_data; 1071 if (m_opaque_sp) 1072 { 1073 Target* target = m_opaque_sp->GetUpdatePoint().GetTargetSP().get(); 1074 if (target) 1075 { 1076 DataExtractorSP data_sp(new DataExtractor()); 1077 Mutex::Locker api_locker (target->GetAPIMutex()); 1078 m_opaque_sp->GetData(*data_sp); 1079 if (data_sp->GetByteSize() > 0) 1080 *sb_data = data_sp; 1081 } 1082 } 1083 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1084 if (log) 1085 log->Printf ("SBValue(%p)::GetData () => SBData(%p)", 1086 m_opaque_sp.get(), 1087 sb_data.get()); 1088 1089 return sb_data; 1090 } 1091 1092 lldb::SBWatchpoint 1093 SBValue::Watch (bool resolve_location, bool read, bool write) 1094 { 1095 lldb::SBWatchpoint sb_watchpoint; 1096 if (!m_opaque_sp) 1097 return sb_watchpoint; 1098 1099 Target* target = m_opaque_sp->GetUpdatePoint().GetTargetSP().get(); 1100 if (target) 1101 { 1102 Mutex::Locker api_locker (target->GetAPIMutex()); 1103 sb_watchpoint = WatchValue(read, write, false); 1104 } 1105 LogSP log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1106 if (log) 1107 log->Printf ("SBValue(%p)::Watch (resolve_location=%i, read=%i, write=%i) => wp(%p)", 1108 m_opaque_sp.get(), resolve_location, read, write, sb_watchpoint.get()); 1109 return sb_watchpoint; 1110 } 1111 1112 lldb::SBWatchpoint 1113 SBValue::WatchPointee (bool resolve_location, bool read, bool write) 1114 { 1115 lldb::SBWatchpoint sb_watchpoint; 1116 if (!m_opaque_sp) 1117 return sb_watchpoint; 1118 1119 Target* target = m_opaque_sp->GetUpdatePoint().GetTargetSP().get(); 1120 if (target) 1121 { 1122 Mutex::Locker api_locker (target->GetAPIMutex()); 1123 sb_watchpoint = WatchValue(read, write, true); 1124 } 1125 LogSP log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1126 if (log) 1127 log->Printf ("SBValue(%p)::WatchPointee (resolve_location=%i, read=%i, write=%i) => wp(%p)", 1128 m_opaque_sp.get(), resolve_location, read, write, sb_watchpoint.get()); 1129 return sb_watchpoint; 1130 } 1131 1132 // Helper function for SBValue::Watch() and SBValue::WatchPointee(). 1133 SBWatchpoint 1134 SBValue::WatchValue(bool read, bool write, bool watch_pointee) 1135 { 1136 SBWatchpoint sb_wp_empty; 1137 1138 // If the SBValue is not valid, there's no point in even trying to watch it. 1139 if (!IsValid() || !GetFrame().IsValid()) 1140 return sb_wp_empty; 1141 1142 // Read and Write cannot both be false. 1143 if (!read && !write) 1144 return sb_wp_empty; 1145 1146 // If we are watching the pointee, check that the SBValue is a pointer type. 1147 if (watch_pointee && !GetType().IsPointerType()) 1148 return sb_wp_empty; 1149 1150 addr_t addr; 1151 size_t size; 1152 if (watch_pointee) { 1153 addr = GetValueAsUnsigned(LLDB_INVALID_ADDRESS); 1154 size = GetType().GetPointeeType().GetByteSize(); 1155 } else { 1156 addr = GetLoadAddress(); 1157 size = GetByteSize(); 1158 } 1159 1160 // Sanity check the address and the size before calling Target::CreateWatchpoint(). 1161 if (addr == LLDB_INVALID_ADDRESS || size == 0) 1162 return sb_wp_empty; 1163 1164 uint32_t watch_type = (read ? LLDB_WATCH_TYPE_READ : 0) | 1165 (write ? LLDB_WATCH_TYPE_WRITE : 0); 1166 WatchpointSP wp_sp = GetFrame().m_opaque_sp->GetThread().GetProcess().GetTarget(). 1167 CreateWatchpoint(addr, size, watch_type); 1168 1169 if (wp_sp) { 1170 // StackFrame::GetInScopeVariableList(true) to get file globals as well. 1171 VariableListSP var_list_sp(GetFrame().m_opaque_sp->GetInScopeVariableList(true)); 1172 VariableSP var_sp = var_list_sp->FindVariable(ConstString(GetName())); 1173 if (var_sp && var_sp->GetDeclaration().GetFile()) { 1174 StreamString ss; 1175 // True to show fullpath for declaration file. 1176 var_sp->GetDeclaration().DumpStopContext(&ss, true); 1177 wp_sp->SetDeclInfo(ss.GetString()); 1178 } 1179 } 1180 return wp_sp; 1181 } 1182 1183