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