From 9128ee2f7accbb6225858416c8a956e6102b86b8 Mon Sep 17 00:00:00 2001 From: Enrico Granata Date: Tue, 6 Sep 2011 19:20:51 +0000 Subject: 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 llvm-svn: 139160 --- lldb/scripts/Python/interface/SBData.i | 95 +++++++++++++++++++++++++++++++++ lldb/scripts/Python/interface/SBValue.i | 55 ++++++++++++++++++- 2 files changed, 149 insertions(+), 1 deletion(-) create mode 100644 lldb/scripts/Python/interface/SBData.i (limited to 'lldb/scripts/Python/interface') diff --git a/lldb/scripts/Python/interface/SBData.i b/lldb/scripts/Python/interface/SBData.i new file mode 100644 index 00000000000..416afb6eab9 --- /dev/null +++ b/lldb/scripts/Python/interface/SBData.i @@ -0,0 +1,95 @@ +//===-- SWIG Interface for SBData -------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + + +namespace lldb { + +class SBData +{ +public: + + SBData (); + + SBData (const SBData &rhs); + + ~SBData (); + + uint8_t + GetAddressByteSize (); + + void + Clear (); + + bool + IsValid(); + + size_t + GetByteSize (); + + lldb::ByteOrder + GetByteOrder(); + + float + GetFloat (lldb::SBError& error, uint32_t offset); + + double + GetDouble (lldb::SBError& error, uint32_t offset); + + long double + GetLongDouble (lldb::SBError& error, uint32_t offset); + + lldb::addr_t + GetAddress (lldb::SBError& error, uint32_t offset); + + uint8_t + GetUnsignedInt8 (lldb::SBError& error, uint32_t offset); + + uint16_t + GetUnsignedInt16 (lldb::SBError& error, uint32_t offset); + + uint32_t + GetUnsignedInt32 (lldb::SBError& error, uint32_t offset); + + uint64_t + GetUnsignedInt64 (lldb::SBError& error, uint32_t offset); + + int8_t + GetSignedInt8 (lldb::SBError& error, uint32_t offset); + + int16_t + GetSignedInt16 (lldb::SBError& error, uint32_t offset); + + int32_t + GetSignedInt32 (lldb::SBError& error, uint32_t offset); + + int64_t + GetSignedInt64 (lldb::SBError& error, uint32_t offset); + + const char* + GetString (lldb::SBError& error, uint32_t offset); + + bool + GetDescription (lldb::SBStream &description); + + size_t + ReadRawData (lldb::SBError& error, + uint32_t offset, + void *buf, + size_t size); + + void + SetData(lldb::SBError& error, const void *buf, size_t size, lldb::ByteOrder endian, uint8_t addr_size); + + bool + Append(const SBData& rhs); + + +}; + +} // namespace lldb diff --git a/lldb/scripts/Python/interface/SBValue.i b/lldb/scripts/Python/interface/SBValue.i index d73e6012c62..e87241070cb 100644 --- a/lldb/scripts/Python/interface/SBValue.i +++ b/lldb/scripts/Python/interface/SBValue.i @@ -196,6 +196,11 @@ public: lldb::SBValue CreateValueFromAddress(const char* name, lldb::addr_t address, const SBType& type); + lldb::SBValue + CreateValueFromData (const char* name, + const SBData& data, + const SBType& type); + lldb::SBType GetType(); @@ -278,9 +283,57 @@ public: bool GetExpressionPath (lldb::SBStream &description); + + %feature("docstring", " + //------------------------------------------------------------------ + /// Get an SBData wrapping what this SBValue points to. + /// + /// This method will dereference the current SBValue, if its + /// data type is a T* or T[], and extract item_count elements + /// of type T from it, copying their contents in an SBData. + /// + /// @param[in] item_idx + /// The index of the first item to retrieve. For an array + /// this is equivalent to array[item_idx], for a pointer + /// to *(pointer + item_idx). In either case, the measurement + /// unit for item_idx is the sizeof(T) rather than the byte + /// + /// @param[in] item_count + /// How many items should be copied into the output. By default + /// only one item is copied, but more can be asked for. + /// + /// @return + /// An SBData with the contents of the copied items, on success. + /// An empty SBData otherwise. + //------------------------------------------------------------------ + ") GetPointeeData; + lldb::SBData + GetPointeeData (uint32_t item_idx = 0, + uint32_t item_count = 1); + + %feature("docstring", " + //------------------------------------------------------------------ + /// Get an SBData wrapping the contents of this SBValue. + /// + /// This method will read the contents of this object in memory + /// and copy them into an SBData for future use. + /// + /// @return + /// An SBData with the contents of this SBValue, on success. + /// An empty SBData otherwise. + //------------------------------------------------------------------ + ") GetData; + lldb::SBData + GetData (); + + lldb::addr_t + GetLoadAddress(); + + lldb::SBAddress + GetAddress(); %feature("docstring", "Returns an expression path for this value." - ) GetValueForExpressionPath; + ) GetExpressionPath; bool GetExpressionPath (lldb::SBStream &description, bool qualify_cxx_base_classes); }; -- cgit v1.2.3