Redesign of the interaction between Python and frozen objects:
- introduced two new classes ValueObjectConstResultChild and ValueObjectConstResultImpl: the first one is a ValueObjectChild obtained from
a ValueObjectConstResult, the second is a common implementation backend for VOCR and VOCRCh of method calls meant to read through pointers stored
in frozen objects ; now such reads transparently move from host to target as required
- as a consequence of the above, removed code that made target-memory copies of expression results in several places throughout LLDB, and also
removed code that enabled to recognize an expression result VO as such
- introduced a new GetPointeeData() method in ValueObject that lets you read a given amount of objects of type T from a VO
representing a T* or T[], and doing dereferences transparently
in private layer it returns a DataExtractor ; in public layer it returns an instance of a newly created lldb::SBData
- as GetPointeeData() does the right thing for both frozen and non-frozen ValueObject's, reimplemented ReadPointedString() to use it
en lieu of doing the raw read itself
- introduced a new GetData() method in ValueObject that lets you get a copy of the data that backs the ValueObject (for pointers,
this returns the address without any previous dereferencing steps ; for arrays it actually reads the whole chunk of memory)
in public layer this returns an SBData, just like GetPointeeData()
- introduced a new CreateValueFromData() method in SBValue that lets you create a new SBValue from a chunk of data wrapped in an SBData
the limitation to remember for this kind of SBValue is that they have no address: extracting the address-of for these objects (with any
of GetAddress(), GetLoadAddress() and AddressOf()) will return invalid values
- added several tests to check that "p"-ing objects (STL classes, char* and char[]) will do the right thing
Solved a bug where global pointers to global variables were not dereferenced correctly for display
New target setting "max-string-summary-length" gives the maximum number of characters to show in a string when summarizing it, instead of the hardcoded 128
Solved a bug where the summary for char[] and char* would not be shown if the ValueObject's were dumped via the "p" command
Removed m_pointers_point_to_load_addrs from ValueObject. Introduced a new m_address_type_of_children, which each ValueObject can set to tell the address type
of any pointers and/or references it creates. In the current codebase, this is load address most of the time (the only notable exception being file
addresses that generate file address children UNLESS we have a live process)
Updated help text for summary-string
Fixed an issue in STL formatters where std::stlcontainer::iterator would match the container's synthetic children providers
Edited the syntax and help for some commands to have proper argument types
git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@139160 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/source/API/SBValue.cpp b/source/API/SBValue.cpp
index a58957b..ea7ebf8 100644
--- a/source/API/SBValue.cpp
+++ b/source/API/SBValue.cpp
@@ -479,6 +479,38 @@
return result;
}
+lldb::SBValue
+SBValue::CreateValueFromData (const char* name,
+ const SBData& data,
+ const SBType& type)
+{
+ SBValue result;
+
+ AddressType addr_of_children_priv = eAddressTypeLoad;
+
+ if (m_opaque_sp)
+ {
+ ValueObjectSP valobj_sp;
+ valobj_sp = ValueObjectConstResult::Create (m_opaque_sp->GetExecutionContextScope(),
+ type.m_opaque_sp->GetASTContext() ,
+ type.m_opaque_sp->GetOpaqueQualType(),
+ ConstString(name),
+ *data.m_opaque_sp,
+ LLDB_INVALID_ADDRESS);
+ valobj_sp->SetAddressTypeOfChildren(addr_of_children_priv);
+ result = SBValue(valobj_sp);
+ }
+ LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+ if (log)
+ {
+ if (result.IsValid())
+ log->Printf ("SBValue(%p)::GetChildFromExpression => \"%s\"", m_opaque_sp.get(), result.m_opaque_sp.get());
+ else
+ log->Printf ("SBValue(%p)::GetChildFromExpression => NULL", m_opaque_sp.get());
+ }
+ return result;
+}
+
SBValue
SBValue::GetChildAtIndex (uint32_t idx)
{
@@ -812,9 +844,10 @@
SBProcess result;
if (m_opaque_sp)
{
- if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
+ Target* target = m_opaque_sp->GetUpdatePoint().GetTargetSP().get();
+ if (target)
{
- result = SBProcess(lldb::ProcessSP(m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetProcessSP()));
+ result = SBProcess(lldb::ProcessSP(target->GetProcessSP()));
}
}
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
@@ -967,10 +1000,10 @@
SBValue sb_value;
if (m_opaque_sp)
{
- if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
+ Target* target = m_opaque_sp->GetUpdatePoint().GetTargetSP().get();
+ if (target)
{
- Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
-
+ Mutex::Locker api_locker (target->GetAPIMutex());
Error error;
sb_value = m_opaque_sp->AddressOf (error);
}
@@ -981,3 +1014,127 @@
return sb_value;
}
+
+lldb::addr_t
+SBValue::GetLoadAddress()
+{
+ lldb::addr_t value = LLDB_INVALID_ADDRESS;
+ if (m_opaque_sp)
+ {
+ Target* target = m_opaque_sp->GetUpdatePoint().GetTargetSP().get();
+ if (target)
+ {
+ Mutex::Locker api_locker (target->GetAPIMutex());
+ const bool scalar_is_load_address = true;
+ AddressType addr_type;
+ value = m_opaque_sp->GetAddressOf(scalar_is_load_address, &addr_type);
+ if (addr_type == eAddressTypeFile)
+ {
+ Module* module = m_opaque_sp->GetModule();
+ if (!module)
+ value = LLDB_INVALID_ADDRESS;
+ else
+ {
+ Address addr;
+ module->ResolveFileAddress(value, addr);
+ value = addr.GetLoadAddress(m_opaque_sp->GetUpdatePoint().GetTargetSP().get());
+ }
+ }
+ else if (addr_type == eAddressTypeHost || addr_type == eAddressTypeInvalid)
+ value = LLDB_INVALID_ADDRESS;
+ }
+ }
+ LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+ if (log)
+ log->Printf ("SBValue(%p)::GetLoadAddress () => (%llu)", m_opaque_sp.get(), value);
+
+ return value;
+}
+
+lldb::SBAddress
+SBValue::GetAddress()
+{
+ Address addr;
+ if (m_opaque_sp)
+ {
+ Target* target = m_opaque_sp->GetUpdatePoint().GetTargetSP().get();
+ if (target)
+ {
+ lldb::addr_t value = LLDB_INVALID_ADDRESS;
+ Mutex::Locker api_locker (target->GetAPIMutex());
+ const bool scalar_is_load_address = true;
+ AddressType addr_type;
+ value = m_opaque_sp->GetAddressOf(scalar_is_load_address, &addr_type);
+ if (addr_type == eAddressTypeFile)
+ {
+ Module* module = m_opaque_sp->GetModule();
+ if (module)
+ module->ResolveFileAddress(value, addr);
+ }
+ else if (addr_type == eAddressTypeLoad)
+ {
+ // no need to check the return value on this.. if it can actually do the resolve
+ // addr will be in the form (section,offset), otherwise it will simply be returned
+ // as (NULL, value)
+ addr.SetLoadAddress(value, target);
+ }
+ }
+ }
+ LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+ if (log)
+ log->Printf ("SBValue(%p)::GetAddress () => (%s,%llu)", m_opaque_sp.get(), (addr.GetSection() ? addr.GetSection()->GetName().GetCString() : "NULL"), addr.GetOffset());
+ return SBAddress(new Address(addr));
+}
+
+lldb::SBData
+SBValue::GetPointeeData (uint32_t item_idx,
+ uint32_t item_count)
+{
+ lldb::SBData sb_data;
+ if (m_opaque_sp)
+ {
+ Target* target = m_opaque_sp->GetUpdatePoint().GetTargetSP().get();
+ if (target)
+ {
+ DataExtractorSP data_sp(new DataExtractor());
+ Mutex::Locker api_locker (target->GetAPIMutex());
+ m_opaque_sp->GetPointeeData(*data_sp, item_idx, item_count);
+ if (data_sp->GetByteSize() > 0)
+ *sb_data = data_sp;
+ }
+ }
+ LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+ if (log)
+ log->Printf ("SBValue(%p)::GetPointeeData (%d, %d) => SBData(%p)",
+ m_opaque_sp.get(),
+ item_idx,
+ item_count,
+ sb_data.get());
+
+ return sb_data;
+}
+
+lldb::SBData
+SBValue::GetData ()
+{
+ lldb::SBData sb_data;
+ if (m_opaque_sp)
+ {
+ Target* target = m_opaque_sp->GetUpdatePoint().GetTargetSP().get();
+ if (target)
+ {
+ DataExtractorSP data_sp(new DataExtractor());
+ Mutex::Locker api_locker (target->GetAPIMutex());
+ m_opaque_sp->GetData(*data_sp);
+ if (data_sp->GetByteSize() > 0)
+ *sb_data = data_sp;
+ }
+ }
+ LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+ if (log)
+ log->Printf ("SBValue(%p)::GetData () => SBData(%p)",
+ m_opaque_sp.get(),
+ sb_data.get());
+
+ return sb_data;
+}