60 const char *name =
nullptr)
64 if ((
m_valobj_sp = in_valobj_sp->GetQualifiedRepresentationIfAvailable(
100 return target_sp && target_sp->IsValid();
107 std::unique_lock<std::recursive_mutex> &lock,
110 error.SetErrorString(
"invalid value object");
116 Target *target = value_sp->GetTargetSP().get();
118 if (value_sp->GetError().Fail())
124 lock = std::unique_lock<std::recursive_mutex>(target->
GetAPIMutex());
126 ProcessSP process_sp(value_sp->GetProcessSP());
127 if (process_sp && !stop_locker.
TryLock(&process_sp->GetRunLock())) {
131 error.SetErrorString(
"process must be stopped.");
138 value_sp = dynamic_sp;
144 value_sp = synthetic_sp;
148 error.SetErrorString(
"invalid value object");
150 value_sp->SetName(
m_name);
216 std::unique_lock<std::recursive_mutex>
m_lock;
247 return this->
operator bool();
249SBValue::operator bool()
const {
255 return m_opaque_sp.get() !=
nullptr && m_opaque_sp->IsValid() &&
256 m_opaque_sp->GetRootSP().get() !=
nullptr;
273 sb_error.
SetError(value_sp->GetError());
275 sb_error.SetErrorStringWithFormat(
"error: %s",
287 return value_sp->GetID();
299 return value_sp->GetName().GetCString();
310 return value_sp->GetQualifiedTypeName().GetCString();
321 return value_sp->GetDisplayTypeName().GetCString();
332 result = value_sp->GetByteSize().value_or(0);
346 result = value_sp->IsInScope();
369 result = value_sp->GetValueType();
393 type_sp = std::make_shared<TypeImpl>(value_sp->GetTypeImpl());
394 sb_type.
SetSP(type_sp);
407 if (value_sp->UpdateValueIfNeeded(
false))
408 result = value_sp->GetValueDidChange();
433 if (value_sp->GetSummaryAsCString(buffer, options.
ref()) && !buffer.empty())
434 stream.Printf(
"%s", buffer.c_str());
461 bool success =
false;
465 success = value_sp->SetValueFromCString(value_str,
error.ref());
467 error.SetErrorStringWithFormat(
"Could not get value: %s",
480 if (value_sp->UpdateValueIfNeeded(
true)) {
483 format.
SetSP(format_sp);
496 if (value_sp->UpdateValueIfNeeded(
true)) {
499 summary.
SetSP(summary_sp);
512 if (value_sp->UpdateValueIfNeeded(
true)) {
515 if (synthetic_sp && !synthetic_sp->IsScripted()) {
517 std::static_pointer_cast<TypeFilterImpl>(synthetic_sp);
518 filter.
SetSP(filter_sp);
532 if (value_sp->UpdateValueIfNeeded(
true)) {
535 if (children_sp && children_sp->IsScripted()) {
537 std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
538 synthetic.
SetSP(synth_sp);
556 sb_value.
SetSP(value_sp->GetSyntheticChildAtOffset(
557 offset, type_sp->GetCompilerType(
false),
true),
571 if (value_sp && type_sp)
572 sb_value.
SetSP(value_sp->Cast(type_sp->GetCompilerType(
false)),
578 const char *expression) {
587 const char *expression,
598 name, expression, exe_ctx, options.
ref());
602 sb_value.
SetSP(new_value_sp);
616 if (value_sp && type_impl_sp) {
617 CompilerType ast_type(type_impl_sp->GetCompilerType(
true));
622 sb_value.
SetSP(new_value_sp);
635 if (value_sp && type_impl_sp) {
638 name, **data, exe_ctx, type_impl_sp->GetCompilerType(
true));
641 sb_value.
SetSP(new_value_sp);
648 const bool can_create_synthetic =
false;
655 use_dynamic = target_sp->GetPreferDynamicValue();
662 bool can_create_synthetic) {
670 const bool can_create =
true;
671 child_sp = value_sp->GetChildAtIndex(idx);
672 if (can_create_synthetic && !child_sp) {
673 child_sp = value_sp->GetSyntheticArrayMember(idx, can_create);
690 idx = value_sp->GetIndexOfChildWithName(name);
704 use_dynamic_value = target_sp->GetPreferDynamicValue();
718 child_sp = value_sp->GetChildMemberWithName(name);
734 value_sb.
SetSP(proxy_sp);
747 value_sb.
SetSP(proxy_sp);
759 value_sb.
SetSP(proxy_sp);
791 return m_opaque_sp->SetUseSynthetic(use_synthetic);
800 return value_sp->IsDynamic();
810 return value_sp->IsSynthetic();
820 return value_sp->IsSyntheticChildrenGenerated();
830 return value_sp->SetSyntheticChildrenGenerated(is);
841 child_sp = value_sp->GetValueForExpressionPath(expr_path);
858 uint64_t ret_val = fail_value;
859 ret_val = value_sp->GetValueAsSigned(fail_value, &success);
861 error.SetErrorString(
"could not resolve value");
864 error.SetErrorStringWithFormat(
"could not get SBValue: %s",
878 uint64_t ret_val = fail_value;
879 ret_val = value_sp->GetValueAsUnsigned(fail_value, &success);
881 error.SetErrorString(
"could not resolve value");
884 error.SetErrorStringWithFormat(
"could not get SBValue: %s",
896 return value_sp->GetValueAsSigned(fail_value);
907 return value_sp->GetValueAsUnsigned(fail_value);
915 bool has_children =
false;
919 has_children = value_sp->MightHaveChildren();
927 bool is_support =
false;
931 is_support = value_sp->IsRuntimeSupportValue();
945 uint32_t num_children = 0;
950 num_children = value_sp->GetNumChildrenIgnoringErrors(max);
970bool SBValue::TypeIsPointerType() {
982 return value_sp->GetCompilerType().GetOpaqueQualType();
993 sb_target.
SetSP(target_sp);
1006 sb_process.
SetSP(process_sp);
1044 && !
m_opaque_sp->GetRootSP()->GetError().Fail()))) {
1055 return GetSP(locker);
1065 bool use_synthetic =
1066 target_sp->TargetProperties::GetEnableSyntheticValue();
1079 bool use_synthetic =
1080 target_sp->TargetProperties::GetEnableSyntheticValue();
1081 SetSP(
sp, use_dynamic, use_synthetic);
1085 SetSP(
sp, use_dynamic,
false);
1093 SetSP(
sp, use_dynamic, use_synthetic);
1118 value_sp->GetExpressionPath(description.
ref());
1125 bool qualify_cxx_base_classes) {
1131 value_sp->GetExpressionPath(description.
ref());
1167 const char *name)
const {
1170 if (!expr || expr[0] ==
'\0') {
1186 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1195 target_sp->EvaluateExpression(expr, frame, res_val_sp, options.
ref(),
nullptr,
1217 value_sp->Dump(strm, options);
1231 return value_sp->GetFormat();
1241 value_sp->SetFormat(format);
1266 TargetSP target_sp(value_sp->GetTargetSP());
1268 const bool scalar_is_load_address =
true;
1270 value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type);
1272 ModuleSP module_sp(value_sp->GetModule());
1277 module_sp->ResolveFileAddress(value, addr);
1296 TargetSP target_sp(value_sp->GetTargetSP());
1299 const bool scalar_is_load_address =
true;
1301 value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type);
1303 ModuleSP module_sp(value_sp->GetModule());
1305 module_sp->ResolveFileAddress(value, addr);
1325 TargetSP target_sp(value_sp->GetTargetSP());
1328 value_sp->GetPointeeData(*data_sp, item_idx, item_count);
1329 if (data_sp->GetByteSize() > 0)
1346 value_sp->GetData(*data_sp,
error);
1347 if (
error.Success())
1364 if (!data_extractor) {
1365 error.SetErrorString(
"No data to set");
1370 value_sp->SetData(*data_extractor, set_error);
1373 error.SetErrorStringWithFormat(
"Couldn't set data: %s",
1379 error.SetErrorStringWithFormat(
1380 "Couldn't set data: could not get SBValue: %s",
1408 if (value_sp->GetDeclaration(decl))
1424 if (value_sp && target_sp) {
1426 if (!read && !write)
1427 return sb_watchpoint;
1431 return sb_watchpoint;
1435 return sb_watchpoint;
1438 return sb_watchpoint;
1440 uint32_t watch_type = 0;
1456 target_sp->CreateWatchpoint(addr, byte_size, &type, watch_type, rc);
1459 if (watchpoint_sp) {
1460 sb_watchpoint.
SetSP(watchpoint_sp);
1462 if (value_sp->GetDeclaration(decl)) {
1467 watchpoint_sp->SetDeclInfo(std::string(ss.
GetString()));
1471 }
else if (target_sp) {
1472 error.SetErrorStringWithFormat(
"could not get SBValue: %s",
1475 error.SetErrorString(
"could not set watchpoint, a target is required");
1478 return sb_watchpoint;
1489 return Watch(resolve_location, read, write,
error);
1499 return sb_watchpoint;
1509 persisted_sb.
SetSP(value_sp->Persist());
1511 return persisted_sb;
1521 vtable_sb.
SetSP(value_sp->GetVTable());
static llvm::raw_ostream & error(Stream &strm)
#define LLDB_INSTRUMENT_VA(...)
StackFrameSP GetFrameSP()
lldb::DynamicValueType m_use_dynamic
lldb::ValueObjectSP GetRootSP()
void SetUseSynthetic(bool use_synthetic)
ValueImpl(const ValueImpl &rhs)=default
ValueImpl(lldb::ValueObjectSP in_valobj_sp, lldb::DynamicValueType use_dynamic, bool use_synthetic, const char *name=nullptr)
lldb::ValueObjectSP GetSP(Process::StopLocker &stop_locker, std::unique_lock< std::recursive_mutex > &lock, Status &error)
ValueImpl & operator=(const ValueImpl &rhs)
lldb::DynamicValueType GetUseDynamic()
void SetUseDynamic(lldb::DynamicValueType use_dynamic)
lldb::ValueObjectSP m_valobj_sp
ValueObjectSP GetLockedSP(ValueImpl &in_value)
Process::StopLocker m_stop_locker
std::unique_lock< std::recursive_mutex > m_lock
lldb_private::DataExtractor * get() const
void SetDeclaration(const lldb_private::Declaration &lldb_object_ref)
void SetError(uint32_t err, lldb::ErrorType type)
void SetFetchDynamicValue(lldb::DynamicValueType dynamic=lldb::eDynamicCanRunTarget)
lldb_private::EvaluateExpressionOptions & ref() const
void SetIgnoreBreakpoints(bool ignore=true)
void SetUnwindOnError(bool unwind=true)
lldb::DynamicValueType GetFetchDynamicValue() const
void SetFrameSP(const lldb::StackFrameSP &lldb_object_sp)
void SetSP(const lldb::ProcessSP &process_sp)
lldb_private::Stream & ref()
void SetSP(const lldb::TargetSP &target_sp)
void SetThread(const lldb::ThreadSP &lldb_object_sp)
void SetSP(const lldb::TypeFilterImplSP &typefilter_impl_sp)
lldb_private::TypeSummaryOptions & ref()
void SetSP(const lldb::TypeSummaryImplSP &typefilter_impl_sp)
void SetSP(const lldb::ScriptedSyntheticChildrenSP &typefilter_impl_sp)
void SetSP(const lldb::TypeImplSP &type_impl_sp)
bool SetData(lldb::SBData &data, lldb::SBError &error)
bool GetDescription(lldb::SBStream &description)
lldb::SBValue EvaluateExpression(const char *expr) const
lldb::SBValue GetChildAtIndex(uint32_t idx)
lldb::SBTypeFilter GetTypeFilter()
lldb::SBAddress GetAddress()
lldb::SBData GetPointeeData(uint32_t item_idx=0, uint32_t item_count=1)
Get an SBData wrapping what this SBValue points to.
const char * GetTypeName()
bool GetExpressionPath(lldb::SBStream &description)
lldb::SBValue CreateValueFromData(const char *name, lldb::SBData data, lldb::SBType type)
void SetSP(const lldb::ValueObjectSP &sp)
lldb::SBValue CreateValueFromAddress(const char *name, lldb::addr_t address, lldb::SBType type)
const char * GetDisplayTypeName()
lldb::SBValue CreateValueFromExpression(const char *name, const char *expression)
lldb::SBData GetData()
Get an SBData wrapping the contents of this SBValue.
lldb::SBValue Clone(const char *new_name)
Creates a copy of the SBValue with a new name and setting the current SBValue as its parent.
void SetSyntheticChildrenGenerated(bool)
lldb::SBProcess GetProcess()
const char * GetLocation()
lldb::SBValue & operator=(const lldb::SBValue &rhs)
int64_t GetValueAsSigned(lldb::SBError &error, int64_t fail_value=0)
lldb::SBWatchpoint WatchPointee(bool resolve_location, bool read, bool write, SBError &error)
Watch this value that this value points to in memory.
lldb::SBWatchpoint Watch(bool resolve_location, bool read, bool write, SBError &error)
Watch this value if it resides in memory.
lldb::SBTypeFormat GetTypeFormat()
bool MightHaveChildren()
Find out if a SBValue might have children.
lldb::SBTypeSummary GetTypeSummary()
lldb::SBValue GetDynamicValue(lldb::DynamicValueType use_dynamic)
bool IsSyntheticChildrenGenerated()
lldb::SBValue CreateChildAtOffset(const char *name, uint32_t offset, lldb::SBType type)
lldb::SBValue Dereference()
std::shared_ptr< ValueImpl > ValueImplSP
lldb::SBValue GetStaticValue()
lldb::SBValue Cast(lldb::SBType type)
lldb::SBValue GetNonSyntheticValue()
bool GetPreferSyntheticValue()
uint32_t GetIndexOfChildWithName(const char *name)
lldb::SBValue GetVTable()
If this value represents a C++ class that has a vtable, return an value that represents the virtual f...
const char * GetObjectDescription()
const char * GetSummary()
lldb::ValueObjectSP GetSP() const
Same as the protected version of GetSP that takes a locker, except that we make the locker locally in...
lldb::SBTypeSynthetic GetTypeSynthetic()
void SetFormat(lldb::Format format)
lldb::SBValue AddressOf()
bool SetValueFromCString(const char *value_str, lldb::SBError &error)
lldb::DynamicValueType GetPreferDynamicValue()
lldb::SBThread GetThread()
lldb::SBValue GetChildMemberWithName(const char *name)
lldb::SBTarget GetTarget()
uint64_t GetValueAsUnsigned(lldb::SBError &error, uint64_t fail_value=0)
uint32_t GetNumChildren()
void SetPreferDynamicValue(lldb::DynamicValueType use_dynamic)
lldb::SBValue GetValueForExpressionPath(const char *expr_path)
lldb::addr_t GetLoadAddress()
void SetPreferSyntheticValue(bool use_synthetic)
lldb::SBDeclaration GetDeclaration()
bool IsRuntimeSupportValue()
void SetSP(const lldb::WatchpointSP &sp)
A section + offset based address class.
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
bool SetLoadAddress(lldb::addr_t load_addr, Target *target, bool allow_section_end=false)
Set the address to represent load_addr.
Generic representation of a type in a programming language.
A uniqued constant string class.
bool IsEmpty() const
Test for empty string.
const char * GetCString() const
Get the string value as a C string.
A class that describes the declaration location of a lldb object.
bool DumpStopContext(Stream *s, bool show_fullpaths) const
FileSpec & GetFile()
Get accessor for file specification.
DumpValueObjectOptions & SetUseSyntheticValue(bool use_synthetic=true)
DumpValueObjectOptions & SetUseDynamicType(lldb::DynamicValueType dyn=lldb::eNoDynamicValues)
void SetKeepInMemory(bool keep=true)
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
StackFrame * GetFramePtr() const
Returns a pointer to the frame object.
bool TryLock(ProcessRunLock *lock)
This base class provides an interface to stack frames.
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
bool Success() const
Test for success condition.
llvm::StringRef GetString() const
A stream class that can stream formatted output to a file.
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
std::recursive_mutex & GetAPIMutex()
static lldb::ValueObjectSP CreateValueObjectFromExpression(llvm::StringRef name, llvm::StringRef expression, const ExecutionContext &exe_ctx)
static lldb::ValueObjectSP CreateValueObjectFromData(llvm::StringRef name, const DataExtractor &data, const ExecutionContext &exe_ctx, CompilerType type)
static lldb::ValueObjectSP CreateValueObjectFromAddress(llvm::StringRef name, uint64_t address, const ExecutionContext &exe_ctx, CompilerType type)
#define LLDB_WATCH_TYPE_WRITE
#define LLDB_WATCH_TYPE_MODIFY
#define LLDB_WATCH_TYPE_READ
#define LLDB_INVALID_ADDRESS
A class that represents a running process on the host machine.
@ eAddressTypeFile
Address is an address as found in an object or symbol file.
@ eAddressTypeLoad
Address is an address as in the current target inferior process.
@ eAddressTypeHost
Address is an address in the process that is running this code.
std::shared_ptr< lldb_private::StackFrame > StackFrameSP
std::shared_ptr< lldb_private::TypeSummaryImpl > TypeSummaryImplSP
std::shared_ptr< lldb_private::Thread > ThreadSP
std::shared_ptr< lldb_private::TypeFormatImpl > TypeFormatImplSP
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
Format
Display format definitions.
std::shared_ptr< lldb_private::Process > ProcessSP
std::shared_ptr< lldb_private::Watchpoint > WatchpointSP
std::shared_ptr< lldb_private::SyntheticChildren > SyntheticChildrenSP
std::shared_ptr< lldb_private::ScriptedSyntheticChildren > ScriptedSyntheticChildrenSP
std::shared_ptr< lldb_private::TypeFilterImpl > TypeFilterImplSP
std::shared_ptr< lldb_private::TypeImpl > TypeImplSP
std::shared_ptr< lldb_private::Target > TargetSP
std::shared_ptr< lldb_private::DataExtractor > DataExtractorSP
std::shared_ptr< lldb_private::Module > ModuleSP